sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-10-07 00:15:48 -04:00
Code Issues Packages Projects Releases Wiki Activity

[GRASS] multi version build

Browse Source
This commit is contained in:
Radim Blazek 2015-04-02 21:34:51 +02:00
parent 892f142e28
commit 7d4eb8bce3
15 changed files with 440 additions and 358 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
CMakeLists.txt
View File

@ -35,11 +35,24 @@ SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
#SET (CMAKE_USE_RELATIVE_PATHS ON) #SET (CMAKE_USE_RELATIVE_PATHS ON)
# try to configure and build GRASS plugin by default # try to configure and build GRASS plugin by default
SET (WITH_GRASS TRUE CACHE BOOL "Determines whether GRASS plugin should be built") FOREACH (GRASS_SEARCH_VERSION 6 7)
IF (WITH_GRASS) # For GRASS 6 are used cached variables without version suffix so that existing caches don't have to be reconfigured.
FIND_PACKAGE(GRASS) # Cached variables: WITH_GRASS, WITH_GRASS7, GRASS_PREFIX, GRASS_PREFIX7, GRASS_INCLUDE_DIR, GRASS_INCLUDE_DIR7
SET (GRASS_PREFIX ${GRASS_PREFIX} CACHE PATH "Path to GRASS base directory") # Everywhere else each variable has version major appended.
ENDIF (WITH_GRASS) # Normal variables: GRASS_FOUND6, GRASS_FOUND7, GRASS_MAJOR_VERSION6, GRASS_MAJOR_VERSION7, etc.
# In addition there is also GRASS_FOUND, which is TRUE if at least one version of GRASS was found
IF (GRASS_SEARCH_VERSION EQUAL 6)
SET (GRASS_CACHE_VERSION "")
ELSE (GRASS_SEARCH_VERSION EQUAL 6)
SET (GRASS_CACHE_VERSION ${GRASS_SEARCH_VERSION})
ENDIF (GRASS_SEARCH_VERSION EQUAL 6)
SET (WITH_GRASS${GRASS_CACHE_VERSION} TRUE CACHE BOOL "Determines whether GRASS ${GRASS_SEARCH_VERSION} plugin should be built")
IF (WITH_GRASS${GRASS_CACHE_VERSION})
FIND_PACKAGE(GRASS ${GRASS_SEARCH_VERSION})
SET (GRASS_PREFIX${GRASS_CACHE_VERSION} ${GRASS_PREFIX${GRASS_SEARCH_VERSION}} CACHE PATH "Path to GRASS ${GRASS_SEARCH_VERSION} base directory")
ENDIF (WITH_GRASS${GRASS_CACHE_VERSION})
ENDFOREACH (GRASS_SEARCH_VERSION)
SET (WITH_DESKTOP TRUE CACHE BOOL "Determines whether QGIS desktop should be built") SET (WITH_DESKTOP TRUE CACHE BOOL "Determines whether QGIS desktop should be built")

147
cmake/FindGRASS.cmake
View File

@ -7,99 +7,130 @@
# macro that checks for grass installation in specified directory # macro that checks for grass installation in specified directory
MACRO (CHECK_GRASS G_PREFIX) MACRO (CHECK_GRASS G_PREFIX)
#MESSAGE(STATUS "Find GRASS ${GRASS_FIND_VERSION} in ${G_PREFIX}")
FIND_PATH (GRASS_INCLUDE_DIR grass/version.h ${G_PREFIX}/include) FIND_PATH(GRASS_INCLUDE_DIR${GRASS_CACHE_VERSION} grass/version.h ${G_PREFIX}/include DOC "Path to GRASS ${GRASS_FIND_VERSION} include directory")
IF(GRASS_INCLUDE_DIR) #MESSAGE(STATUS "GRASS_INCLUDE_DIR${GRASS_CACHE_VERSION} = ${GRASS_INCLUDE_DIR${GRASS_CACHE_VERSION}}")
FILE(READ ${GRASS_INCLUDE_DIR}/grass/version.h VERSIONFILE)
IF(GRASS_INCLUDE_DIR${GRASS_CACHE_VERSION})
FILE(READ ${GRASS_INCLUDE_DIR${GRASS_CACHE_VERSION}}/grass/version.h VERSIONFILE)
# We can avoid the following block using version_less version_equal and # We can avoid the following block using version_less version_equal and
# version_greater. Are there compatibility problems? # version_greater. Are there compatibility problems?
STRING(REGEX MATCH "[0-9]+\\.[0-9]+\\.[^ ]+" GRASS_VERSION ${VERSIONFILE}) STRING(REGEX MATCH "[0-9]+\\.[0-9]+\\.[^ ]+" GRASS_VERSION${GRASS_FIND_VERSION} ${VERSIONFILE})
STRING(REGEX REPLACE "^([0-9]*)\\.[0-9]*\\..*$" "\\1" GRASS_MAJOR_VERSION ${GRASS_VERSION}) STRING(REGEX REPLACE "^([0-9]*)\\.[0-9]*\\..*$" "\\1" GRASS_MAJOR_VERSION${GRASS_FIND_VERSION} ${GRASS_VERSION${GRASS_FIND_VERSION}})
STRING(REGEX REPLACE "^[0-9]*\\.([0-9]*)\\..*$" "\\1" GRASS_MINOR_VERSION ${GRASS_VERSION}) STRING(REGEX REPLACE "^[0-9]*\\.([0-9]*)\\..*$" "\\1" GRASS_MINOR_VERSION${GRASS_FIND_VERSION} ${GRASS_VERSION${GRASS_FIND_VERSION}})
STRING(REGEX REPLACE "^[0-9]*\\.[0-9]*\\.(.*)$" "\\1" GRASS_MICRO_VERSION ${GRASS_VERSION}) STRING(REGEX REPLACE "^[0-9]*\\.[0-9]*\\.(.*)$" "\\1" GRASS_MICRO_VERSION${GRASS_FIND_VERSION} ${GRASS_VERSION${GRASS_FIND_VERSION}})
# Add micro version too? # Add micro version too?
# How to numerize RC versions? # How to numerize RC versions?
MATH( EXPR GRASS_NUM_VERSION "${GRASS_MAJOR_VERSION}*10000 + ${GRASS_MINOR_VERSION}*100") MATH( EXPR GRASS_NUM_VERSION${GRASS_FIND_VERSION} "${GRASS_MAJOR_VERSION${GRASS_FIND_VERSION}}*10000 + ${GRASS_MINOR_VERSION${GRASS_FIND_VERSION}}*100")
SET (GRASS_LIBRARIES_FOUND TRUE) #MESSAGE(STATUS "GRASS_MAJOR_VERSION${GRASS_FIND_VERSION} = ${GRASS_MAJOR_VERSION${GRASS_FIND_VERSION}}")
SET (GRASS_LIB_NAMES gis dig2 dbmiclient dbmibase shape dgl rtree datetime linkm gproj) IF(GRASS_MAJOR_VERSION${GRASS_FIND_VERSION} EQUAL GRASS_FIND_VERSION)
IF (GRASS_MAJOR_VERSION LESS 7 ) SET(GRASS_LIBRARIES_FOUND${GRASS_FIND_VERSION} TRUE)
LIST(APPEND GRASS_LIB_NAMES vect) SET(GRASS_LIB_NAMES${GRASS_FIND_VERSION} gis dig2 dbmiclient dbmibase shape dgl rtree datetime linkm gproj)
LIST(APPEND GRASS_LIB_NAMES form) IF(GRASS_MAJOR_VERSION${GRASS_FIND_VERSION} LESS 7 )
ELSE (GRASS_MAJOR_VERSION LESS 7 ) LIST(APPEND GRASS_LIB_NAMES${GRASS_FIND_VERSION} vect)
LIST(APPEND GRASS_LIB_NAMES vector) LIST(APPEND GRASS_LIB_NAMES${GRASS_FIND_VERSION} form)
LIST(APPEND GRASS_LIB_NAMES raster) ELSE(GRASS_MAJOR_VERSION${GRASS_FIND_VERSION} LESS 7 )
ENDIF (GRASS_MAJOR_VERSION LESS 7 ) LIST(APPEND GRASS_LIB_NAMES${GRASS_FIND_VERSION} vector)
LIST(APPEND GRASS_LIB_NAMES${GRASS_FIND_VERSION} raster)
ENDIF(GRASS_MAJOR_VERSION${GRASS_FIND_VERSION} LESS 7 )
FOREACH (LIB ${GRASS_LIB_NAMES}) FOREACH(LIB ${GRASS_LIB_NAMES${GRASS_FIND_VERSION}})
MARK_AS_ADVANCED ( GRASS_LIBRARY_${LIB} ) MARK_AS_ADVANCED ( GRASS_LIBRARY${GRASS_FIND_VERSION}_${LIB} )
SET(LIB_PATH NOTFOUND) SET(LIB_PATH NOTFOUND)
FIND_LIBRARY(LIB_PATH NAMES grass_${LIB} PATHS ${G_PREFIX}/lib NO_DEFAULT_PATH) FIND_LIBRARY(LIB_PATH NAMES grass_${LIB} PATHS ${G_PREFIX}/lib NO_DEFAULT_PATH)
IF (LIB_PATH) IF(LIB_PATH)
SET (GRASS_LIBRARY_${LIB} ${LIB_PATH}) SET(GRASS_LIBRARY${GRASS_FIND_VERSION}_${LIB} ${LIB_PATH})
ELSE (LIB_PATH) ELSE(LIB_PATH)
SET (GRASS_LIBRARY_${LIB} NOTFOUND) SET(GRASS_LIBRARY${GRASS_FIND_VERSION}_${LIB} NOTFOUND)
SET (GRASS_LIBRARIES_FOUND FALSE) SET(GRASS_LIBRARIES_FOUND${GRASS_FIND_VERSION} FALSE)
ENDIF (LIB_PATH) ENDIF (LIB_PATH)
ENDFOREACH (LIB) ENDFOREACH(LIB)
# LIB_PATH is only temporary variable, so hide it (is it possible to delete a variable?) # LIB_PATH is only temporary variable, so hide it (is it possible to delete a variable?)
UNSET(LIB_PATH CACHE) UNSET(LIB_PATH CACHE)
IF (GRASS_LIBRARIES_FOUND) IF(GRASS_LIBRARIES_FOUND${GRASS_FIND_VERSION})
SET (GRASS_FOUND TRUE) SET(GRASS_FOUND${GRASS_FIND_VERSION} TRUE)
SET (GRASS_PREFIX ${G_PREFIX}) SET(GRASS_FOUND TRUE) # GRASS_FOUND is true if at least one version was found
ENDIF (GRASS_LIBRARIES_FOUND) SET(GRASS_PREFIX${GRASS_CACHE_VERSION} ${G_PREFIX})
ENDIF( GRASS_INCLUDE_DIR ) IF(GRASS_FIND_VERSION EQUAL 6)
# Set also normal variable with number
SET(GRASS_INCLUDE_DIR${GRASS_FIND_VERSION} ${GRASS_INCLUDE_DIR${GRASS_CACHE_VERSION}})
SET(GRASS_PREFIX${GRASS_FIND_VERSION} ${G_PREFIX})
ENDIF(GRASS_FIND_VERSION EQUAL 6)
ENDIF(GRASS_LIBRARIES_FOUND${GRASS_FIND_VERSION})
ENDIF(GRASS_MAJOR_VERSION${GRASS_FIND_VERSION} EQUAL GRASS_FIND_VERSION)
ENDIF(GRASS_INCLUDE_DIR${GRASS_CACHE_VERSION})
MARK_AS_ADVANCED ( GRASS_INCLUDE_DIR ) MARK_AS_ADVANCED ( GRASS_INCLUDE_DIR${GRASS_CACHE_VERSION} )
ENDMACRO (CHECK_GRASS) ENDMACRO (CHECK_GRASS)
################################### ###################################
# search for grass installations # search for grass installations
# list of paths which to search - user's choice as first #MESSAGE(STATUS "GRASS_FIND_VERSION = ${GRASS_FIND_VERSION}")
SET (GRASS_PATHS ${GRASS_PREFIX} /usr/lib/grass /usr/lib64/grass64 /usr/lib/grass64 c:/msys/local /opt/grass $ENV{GRASS_PREFIX})
# list of paths which to search - user's choice as first
SET (GRASS_PATHS ${GRASS_PREFIX${GRASS_CACHE_VERSION}} /usr/lib/grass /opt/grass $ENV{GRASS_PREFIX${GRASS_CACHE_VERSION}})
# os specific paths
IF (WIN32)
LIST(APPEND GRASS_PATHS c:/msys/local)
ENDIF (WIN32)
IF (UNIX)
IF (GRASS_FIND_VERSION EQUAL 6)
LIST(APPEND GRASS_PATHS /usr/lib64/grass64 /usr/lib/grass64)
ELSEIF (GRASS_FIND_VERSION EQUAL 7)
LIST(APPEND GRASS_PATHS /usr/lib64/grass70 /usr/lib/grass70 /usr/lib64/grass71 /usr/lib/grass71)
ENDIF ()
ENDIF (UNIX)
# mac-specific path
IF (APPLE) IF (APPLE)
SET (GRASS_PATHS ${GRASS_PATHS} IF (GRASS_FIND_VERSION EQUAL 6)
/Applications/GRASS-6.3.app/Contents/MacOS LIST(APPEND GRASS_PATHS
/Applications/GRASS-6.4.app/Contents/MacOS /Applications/GRASS-6.3.app/Contents/MacOS
/Applications/GRASS.app/Contents/Resources /Applications/GRASS-6.4.app/Contents/MacOS
) )
ELSEIF (GRASS_FIND_VERSION EQUAL 7)
LIST(APPEND GRASS_PATHS
/Applications/GRASS-7.0.app/Contents/MacOS
/Applications/GRASS-7.1.app/Contents/MacOS
)
ENDIF ()
LIST(APPEND GRASS_PATHS /Applications/GRASS.app/Contents/Resources)
ENDIF (APPLE) ENDIF (APPLE)
IF (WITH_GRASS) IF (WITH_GRASS${GRASS_CACHE_VERSION})
FOREACH (G_PREFIX ${GRASS_PATHS}) FOREACH (G_PREFIX ${GRASS_PATHS})
IF (NOT GRASS_FOUND) IF (NOT GRASS_FOUND${GRASS_FIND_VERSION})
CHECK_GRASS(${G_PREFIX}) CHECK_GRASS(${G_PREFIX})
ENDIF (NOT GRASS_FOUND) ENDIF (NOT GRASS_FOUND${GRASS_FIND_VERSION})
ENDFOREACH (G_PREFIX) ENDFOREACH (G_PREFIX)
ENDIF (WITH_GRASS${GRASS_CACHE_VERSION})
ENDIF (WITH_GRASS)
################################### ###################################
IF (GRASS_FOUND) IF (GRASS_FOUND${GRASS_FIND_VERSION})
IF (NOT GRASS_FIND_QUIETLY) IF (NOT GRASS_FIND_QUIETLY)
MESSAGE(STATUS "Found GRASS: ${GRASS_PREFIX} (${GRASS_VERSION})") MESSAGE(STATUS "Found GRASS ${GRASS_FIND_VERSION}: ${GRASS_PREFIX${GRASS_CACHE_VERSION}} (${GRASS_VERSION${GRASS_FIND_VERSION}})")
ENDIF (NOT GRASS_FIND_QUIETLY) ENDIF (NOT GRASS_FIND_QUIETLY)
ELSE (GRASS_FOUND) ELSE (GRASS_FOUND${GRASS_FIND_VERSION})
IF (WITH_GRASS) IF (WITH_GRASS${GRASS_CACHE_VERSION})
IF (GRASS_FIND_REQUIRED) IF (GRASS_FIND_REQUIRED)
MESSAGE(FATAL_ERROR "Could not find GRASS") MESSAGE(FATAL_ERROR "Could not find GRASS ${GRASS_FIND_VERSION}")
ELSE (GRASS_FIND_REQUIRED) ELSE (GRASS_FIND_REQUIRED)
MESSAGE(STATUS "Could not find GRASS") MESSAGE(STATUS "Could not find GRASS ${GRASS_FIND_VERSION}")
ENDIF (GRASS_FIND_REQUIRED) ENDIF (GRASS_FIND_REQUIRED)
ENDIF (WITH_GRASS) ENDIF (WITH_GRASS${GRASS_CACHE_VERSION})
ENDIF (GRASS_FOUND) ENDIF (GRASS_FOUND${GRASS_FIND_VERSION})

4
src/plugins/CMakeLists.txt
View File

@ -22,9 +22,7 @@ IF (POSTGRES_FOUND)
ENDIF (POSTGRES_FOUND) ENDIF (POSTGRES_FOUND)
IF (GRASS_FOUND) IF (GRASS_FOUND)
IF (GRASS_MAJOR_VERSION LESS 7 ) ADD_SUBDIRECTORY(grass)
ADD_SUBDIRECTORY(grass)
ENDIF (GRASS_MAJOR_VERSION LESS 7 )
ENDIF (GRASS_FOUND) ENDIF (GRASS_FOUND)
IF (WITH_GLOBE) IF (WITH_GLOBE)

278
src/plugins/grass/CMakeLists.txt
View File

@ -1,7 +1,7 @@
ADD_SUBDIRECTORY(modules) ADD_SUBDIRECTORY(modules)
ADD_SUBDIRECTORY(scripts) ADD_SUBDIRECTORY(scripts)
ADD_DEFINITIONS(-DGRASS_BASE=\\\"${GRASS_PREFIX}\\\") #ADD_DEFINITIONS(-DGRASS_BASE=\\\"${GRASS_PREFIX}\\\")
ADD_DEFINITIONS(-DHAVE_OPENPTY=${HAVE_OPENPTY}) ADD_DEFINITIONS(-DHAVE_OPENPTY=${HAVE_OPENPTY})
ADD_DEFINITIONS("-DGRASS_EXPORT=${DLLIMPORT} -DGRASS_LIB_EXPORT=${DLLIMPORT}") ADD_DEFINITIONS("-DGRASS_EXPORT=${DLLIMPORT} -DGRASS_LIB_EXPORT=${DLLIMPORT}")
@ -18,96 +18,96 @@ ENDIF (WIN32)
# Files # Files
SET (GRASS_PLUGIN_SRCS SET (GRASS_PLUGIN_SRCS
qgsgrassplugin.cpp qgsgrassplugin.cpp
qgsgrassselect.cpp qgsgrassselect.cpp
qgsgrassbrowser.cpp qgsgrassbrowser.cpp
qgsgrassedit.cpp qgsgrassedit.cpp
qgsgrassedittools.cpp qgsgrassedittools.cpp
qgsgrasstools.cpp qgsgrasstools.cpp
qgsgrassmodel.cpp qgsgrassmodel.cpp
qgsgrassmapcalc.cpp qgsgrassmapcalc.cpp
qgsgrassmodule.cpp qgsgrassmodule.cpp
qgsgrassnewmapset.cpp qgsgrassnewmapset.cpp
qgsgrassattributes.cpp qgsgrassattributes.cpp
qgsgrassregion.cpp qgsgrassregion.cpp
qgsgrassutils.cpp qgsgrassutils.cpp
) )
SET (GRASS_PLUGIN_UIS SET (GRASS_PLUGIN_UIS
qgsgrasstoolsbase.ui qgsgrasstoolsbase.ui
qgsgrassselectbase.ui qgsgrassselectbase.ui
qgsgrasseditbase.ui qgsgrasseditbase.ui
qgsgrassmapcalcbase.ui qgsgrassmapcalcbase.ui
qgsgrassmodulebase.ui qgsgrassmodulebase.ui
qgsgrassnewmapsetbase.ui qgsgrassnewmapsetbase.ui
qgsgrassattributesbase.ui qgsgrassattributesbase.ui
qgsgrassregionbase.ui qgsgrassregionbase.ui
../../ui/qgsprojectionselectorbase.ui ../../ui/qgsprojectionselectorbase.ui
) )
SET (GRASS_PLUGIN_MOC_HDRS SET (GRASS_PLUGIN_MOC_HDRS
qgsgrassplugin.h qgsgrassplugin.h
qgsgrassselect.h qgsgrassselect.h
qgsgrassbrowser.h qgsgrassbrowser.h
qgsgrassedit.h qgsgrassedit.h
qgsgrasstools.h qgsgrasstools.h
qgsgrassmodel.h qgsgrassmodel.h
qgsgrassmapcalc.h qgsgrassmapcalc.h
qgsgrassmodule.h qgsgrassmodule.h
qgsgrassnewmapset.h qgsgrassnewmapset.h
qgsgrassattributes.h qgsgrassattributes.h
qgsgrassregion.h qgsgrassregion.h
qgsgrassutils.h qgsgrassutils.h
qgsgrassedittools.h qgsgrassedittools.h
) )
IF(NOT WIN32) IF(NOT WIN32)
SET (GRASS_PLUGIN_SRCS ${GRASS_PLUGIN_SRCS} SET (GRASS_PLUGIN_SRCS ${GRASS_PLUGIN_SRCS}
qgsgrassshell.cpp qgsgrassshell.cpp
qtermwidget/BlockArray.cpp qtermwidget/BlockArray.cpp
qtermwidget/Emulation.cpp qtermwidget/Emulation.cpp
qtermwidget/Filter.cpp qtermwidget/Filter.cpp
qtermwidget/History.cpp qtermwidget/History.cpp
qtermwidget/KeyboardTranslator.cpp qtermwidget/KeyboardTranslator.cpp
qtermwidget/Pty.cpp qtermwidget/Pty.cpp
qtermwidget/Screen.cpp qtermwidget/Screen.cpp
qtermwidget/ScreenWindow.cpp qtermwidget/ScreenWindow.cpp
qtermwidget/Session.cpp qtermwidget/Session.cpp
qtermwidget/ShellCommand.cpp qtermwidget/ShellCommand.cpp
qtermwidget/TerminalCharacterDecoder.cpp qtermwidget/TerminalCharacterDecoder.cpp
qtermwidget/TerminalDisplay.cpp qtermwidget/TerminalDisplay.cpp
qtermwidget/Vt102Emulation.cpp qtermwidget/Vt102Emulation.cpp
qtermwidget/k3process.cpp qtermwidget/k3process.cpp
qtermwidget/k3processcontroller.cpp qtermwidget/k3processcontroller.cpp
qtermwidget/konsole_wcwidth.cpp qtermwidget/konsole_wcwidth.cpp
qtermwidget/kpty.cpp qtermwidget/kpty.cpp
qtermwidget/qtermwidget.cpp qtermwidget/qtermwidget.cpp
) )
SET (GRASS_PLUGIN_MOC_HDRS ${GRASS_PLUGIN_MOC_HDRS} SET (GRASS_PLUGIN_MOC_HDRS ${GRASS_PLUGIN_MOC_HDRS}
qgsgrassshell.h qgsgrassshell.h
qtermwidget/Emulation.h qtermwidget/Emulation.h
qtermwidget/Filter.h qtermwidget/Filter.h
qtermwidget/Pty.h qtermwidget/Pty.h
qtermwidget/ScreenWindow.h qtermwidget/ScreenWindow.h
qtermwidget/Session.h qtermwidget/Session.h
qtermwidget/TerminalDisplay.h qtermwidget/TerminalDisplay.h
qtermwidget/Vt102Emulation.h qtermwidget/Vt102Emulation.h
qtermwidget/k3process.h qtermwidget/k3process.h
qtermwidget/k3processcontroller.h qtermwidget/k3processcontroller.h
qtermwidget/qtermwidget.h qtermwidget/qtermwidget.h
) )
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
SET_SOURCE_FILES_PROPERTIES( SET_SOURCE_FILES_PROPERTIES(
${CMAKE_CURRENT_BINARY_DIR}/qtermwidget/moc_Pty.cxx ${CMAKE_CURRENT_BINARY_DIR}/qtermwidget/moc_Pty.cxx
qtermwidget/Pty.cpp qtermwidget/Pty.cpp
qtermwidget/Session.cpp qtermwidget/Session.cpp
qtermwidget/kpty.cpp qtermwidget/kpty.cpp
qtermwidget/k3process.cpp qtermwidget/k3process.cpp
PROPERTIES COMPILE_FLAGS "-Wno-overloaded-virtual -Wno-mismatched-tags" PROPERTIES COMPILE_FLAGS "-Wno-overloaded-virtual -Wno-mismatched-tags"
) )
ENDIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") ENDIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
ENDIF(NOT WIN32) ENDIF(NOT WIN32)
@ -124,68 +124,86 @@ QT4_WRAP_CPP (GRASS_PLUGIN_MOC_SRCS ${GRASS_PLUGIN_MOC_HDRS})
QT4_ADD_RESOURCES(GRASS_PLUGIN_RCC_SRCS ${GRASS_PLUGIN_RCCS}) QT4_ADD_RESOURCES(GRASS_PLUGIN_RCC_SRCS ${GRASS_PLUGIN_RCCS})
########################################################
# build lib
ADD_LIBRARY (grassplugin MODULE
${GRASS_PLUGIN_SRCS}
${GRASS_PLUGIN_MOC_SRCS}
${GRASS_PLUGIN_UIS_H}
${GRASS_PLUGIN_RCC_SRCS}
)
INCLUDE_DIRECTORIES( INCLUDE_DIRECTORIES(
.. ..
${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}
../../core ../../core
../../core/raster ../../core/raster
../../gui ../../gui
../../providers/grass ../../providers/grass
${CMAKE_CURRENT_BINARY_DIR}/../../ui ${CMAKE_CURRENT_BINARY_DIR}/../../ui
${GRASS_INCLUDE_DIR} ${GDAL_INCLUDE_DIR}
${GDAL_INCLUDE_DIR} ${PROJ_INCLUDE_DIR}
${PROJ_INCLUDE_DIR} ${GEOS_INCLUDE_DIR}
${GEOS_INCLUDE_DIR} qtermwidget
qtermwidget
) )
TARGET_LINK_LIBRARIES(grassplugin FOREACH(GRASS_BUILD_VERSION 6) # GRASS 6 and GRASS 7
qgisgrass IF(GRASS_FOUND${GRASS_BUILD_VERSION})
qgis_gui SET(GRASS_PREFIX ${GRASS_PREFIX${GRASS_BUILD_VERSION}})
${OPENPTY_LIBRARY} SET(GRASS_MAJOR_VERSION ${GRASS_MAJOR_VERSION${GRASS_BUILD_VERSION}})
) SET(GRASS_MINOR_VERSION ${GRASS_MINOR_VERSION${GRASS_BUILD_VERSION}})
IF (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD") GET_PROPERTY(INCLUDE_DIRECTORIES DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
TARGET_LINK_LIBRARIES(grassplugin ulog) LIST(APPEND INCLUDE_DIRECTORIES ${GRASS_INCLUDE_DIR${GRASS_BUILD_VERSION}})
ENDIF (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
# override default path where built files are put to allow running qgis without installing ADD_LIBRARY (grassplugin${GRASS_BUILD_VERSION} MODULE
# the binary goes under libexec subdir ${GRASS_PLUGIN_SRCS}
SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${QGIS_OUTPUT_DIRECTORY}/${QGIS_LIBEXEC_SUBDIR}/grass/bin) ${GRASS_PLUGIN_MOC_SRCS}
${GRASS_PLUGIN_UIS_H}
${GRASS_PLUGIN_RCC_SRCS}
)
ADD_EXECUTABLE(qgis.g.browser ${GRASS_BROWSER_SRCS}) SET_TARGET_PROPERTIES(grassplugin${GRASS_BUILD_VERSION} PROPERTIES
INCLUDE_DIRECTORIES "${INCLUDE_DIRECTORIES}"
COMPILE_FLAGS "-DGRASS_BASE=\\\"${GRASS_PREFIX}\\\""
)
TARGET_LINK_LIBRARIES (qgis.g.browser TARGET_LINK_LIBRARIES(grassplugin${GRASS_BUILD_VERSION}
${QT_QTGUI_LIBRARY} qgisgrass${GRASS_BUILD_VERSION}
${QT_QTCORE_LIBRARY} qgis_gui
) ${OPENPTY_LIBRARY}
)
######################################################## IF (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
# Install TARGET_LINK_LIBRARIES(grassplugin${GRASS_BUILD_VERSION} ulog)
ENDIF (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
INSTALL(TARGETS grassplugin # override default path where built files are put to allow running qgis without installing
RUNTIME DESTINATION ${QGIS_PLUGIN_DIR} # the binary goes under libexec subdir
LIBRARY DESTINATION ${QGIS_PLUGIN_DIR}) SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${QGIS_OUTPUT_DIRECTORY}/${QGIS_LIBEXEC_SUBDIR}/grass/bin)
FILE (GLOB GMLS *.gml) ADD_EXECUTABLE(qgis.g.browser${GRASS_BUILD_VERSION} ${GRASS_BROWSER_SRCS})
INSTALL (FILES ${GMLS}
DESTINATION ${QGIS_DATA_DIR}/grass)
INSTALL (FILES themes/default/grass_arrow.svg themes/default/grass_plus.svg themes/default/grass_arrow.png themes/default/grass_plus.png SET_TARGET_PROPERTIES(qgis.g.browser${GRASS_BUILD_VERSION} PROPERTIES
DESTINATION ${QGIS_DATA_DIR}/grass/modules) INCLUDE_DIRECTORIES "${INCLUDE_DIRECTORIES}"
COMPILE_FLAGS "-DGRASS_BASE=\\\"${GRASS_PREFIX}\\\""
)
INSTALL(TARGETS qgis.g.browser TARGET_LINK_LIBRARIES (qgis.g.browser${GRASS_BUILD_VERSION}
RUNTIME DESTINATION ${QGIS_LIBEXEC_DIR}/grass/bin ${QT_QTGUI_LIBRARY}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE ${QT_QTCORE_LIBRARY}
) )
########################################################
# Install
INSTALL(TARGETS grassplugin${GRASS_BUILD_VERSION}
RUNTIME DESTINATION ${QGIS_PLUGIN_DIR}
LIBRARY DESTINATION ${QGIS_PLUGIN_DIR})
FILE (GLOB GMLS *.gml)
INSTALL (FILES ${GMLS}
DESTINATION ${QGIS_DATA_DIR}/grass)
INSTALL (FILES themes/default/grass_arrow.svg themes/default/grass_plus.svg themes/default/grass_arrow.png themes/default/grass_plus.png
DESTINATION ${QGIS_DATA_DIR}/grass/modules)
INSTALL(TARGETS qgis.g.browser${GRASS_BUILD_VERSION}
RUNTIME DESTINATION ${QGIS_LIBEXEC_DIR}/grass/bin
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)
ENDIF(GRASS_FOUND${GRASS_BUILD_VERSION})
ENDFOREACH(GRASS_BUILD_VERSION 6 7)

2
src/plugins/grass/qgsgrassmodule.cpp
View File

@ -1625,7 +1625,7 @@ void QgsGrassModule::run()
mOutputTextBrowser->clear(); mOutputTextBrowser->clear();
QProcessEnvironment environment = QProcessEnvironment::systemEnvironment(); QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
environment.insert( "GRASS_HTML_BROWSER", QgsApplication::libexecPath() + "grass/bin/qgis.g.browser" ); environment.insert( "GRASS_HTML_BROWSER", QgsGrassUtils::htmlBrowserPath() );
// Warning: it is not useful to write requested region to WIND file and // Warning: it is not useful to write requested region to WIND file and
// reset then to original beacuse it is reset before // reset then to original beacuse it is reset before

25
src/plugins/grass/qgsgrassplugin.cpp
View File

@ -48,7 +48,10 @@ extern "C"
#include <grass/version.h> #include <grass/version.h>
} }
static const QString pluginVersion = QObject::tr( "Version 0.1" ); static const QString pluginName = QObject::tr( "GRASS %1" ).arg( GRASS_VERSION_MAJOR );
static const QString pluginDescription = QObject::tr( "GRASS %1 (Geographic Resources Analysis Support System)" ).arg( GRASS_VERSION_MAJOR );
static const QString pluginCategory = QObject::tr( "Plugins" );
static const QString pluginVersion = QObject::tr( "Version 2.0" );
static const QString pluginIcon = ":/images/themes/default/grass/grass_tools.png"; static const QString pluginIcon = ":/images/themes/default/grass/grass_tools.png";
/** /**
@ -58,11 +61,7 @@ static const QString pluginIcon = ":/images/themes/default/grass/grass_tools.png
* @param theQgisInterFace Pointer to the QGIS interface object * @param theQgisInterFace Pointer to the QGIS interface object
*/ */
QgsGrassPlugin::QgsGrassPlugin( QgisInterface * theQgisInterFace ) QgsGrassPlugin::QgsGrassPlugin( QgisInterface * theQgisInterFace )
: pluginNameQString( tr( "GrassVector" ) ) : mToolBarPointer( 0 )
, pluginVersionQString( tr( "0.1" ) )
, pluginDescriptionQString( tr( "GRASS layer" ) )
, pluginCategoryQString( tr( "Plugins" ) )
, mToolBarPointer( 0 )
, qGisInterface( theQgisInterFace ) , qGisInterface( theQgisInterFace )
, mCanvas( 0 ) , mCanvas( 0 )
, mRegionAction( 0 ) , mRegionAction( 0 )
@ -95,22 +94,22 @@ QgsGrassPlugin::~QgsGrassPlugin()
/* Following functions return name, description, version, and type for the plugin */ /* Following functions return name, description, version, and type for the plugin */
QString QgsGrassPlugin::name() QString QgsGrassPlugin::name()
{ {
return pluginNameQString; return pluginName;
} }
QString QgsGrassPlugin::version() QString QgsGrassPlugin::version()
{ {
return pluginVersionQString; return pluginVersion;
} }
QString QgsGrassPlugin::description() QString QgsGrassPlugin::description()
{ {
return pluginDescriptionQString; return pluginDescription;
} }
QString QgsGrassPlugin::category() QString QgsGrassPlugin::category()
{ {
return pluginCategoryQString; return pluginCategory;
} }
void QgsGrassPlugin::help() void QgsGrassPlugin::help()
@ -973,19 +972,19 @@ QGISEXTERN QgisPlugin * classFactory( QgisInterface * theQgisInterfacePointer )
// the class may not yet be insantiated when this method is called. // the class may not yet be insantiated when this method is called.
QGISEXTERN QString name() QGISEXTERN QString name()
{ {
return QObject::tr( "GRASS" ); return pluginName;
} }
// Return the description // Return the description
QGISEXTERN QString description() QGISEXTERN QString description()
{ {
return QObject::tr( "GRASS layer" ); return pluginDescription;
} }
// Return the category // Return the category
QGISEXTERN QString category() QGISEXTERN QString category()
{ {
return QObject::tr( "Plugins" ); return pluginCategory;
} }
// Return the type (either UI or MapLayer plugin) // Return the type (either UI or MapLayer plugin)

8
src/plugins/grass/qgsgrassplugin.h
View File

@ -136,14 +136,6 @@ class QgsGrassPlugin : public QObject, public QgisPlugin
void setTransform(); void setTransform();
void editClosed(); void editClosed();
private: private:
//! Name of the plugin
QString pluginNameQString;
//! Version
QString pluginVersionQString;
//! Descrption of the plugin
QString pluginDescriptionQString;
//! Category of the plugin
QString pluginCategoryQString;
//! Pointer to our toolbar //! Pointer to our toolbar
QToolBar *mToolBarPointer; QToolBar *mToolBarPointer;
//! Pointer to the QGIS interface object //! Pointer to the QGIS interface object

3
src/plugins/grass/qgsgrassshell.cpp
View File

@ -23,6 +23,7 @@
#include "qgsgrass.h" #include "qgsgrass.h"
#include "qgsconfig.h" #include "qgsconfig.h"
#include "qgsgrassutils.h"
#include "qgsgrassshell.h" #include "qgsgrassshell.h"
extern "C" extern "C"
@ -100,7 +101,7 @@ void QgsGrassShell::initTerminal( QTermWidget *terminal )
env << "TERM=vt100"; env << "TERM=vt100";
env << "GISRC_MODE_MEMORY"; env << "GISRC_MODE_MEMORY";
// TODO: we should check if these environment variable were set by user before QGIS was started // TODO: we should check if these environment variable were set by user before QGIS was started
env << "GRASS_HTML_BROWSER=" + QgsApplication::libexecPath() + "grass/bin/qgis.g.browser"; env << "GRASS_HTML_BROWSER=" + QgsGrassUtils::htmlBrowserPath() ;
env << "GRASS_WISH=wish"; env << "GRASS_WISH=wish";
env << "GRASS_TCLSH=tclsh"; env << "GRASS_TCLSH=tclsh";
env << "GRASS_PYTHON=python"; env << "GRASS_PYTHON=python";

2
src/plugins/grass/qgsgrasstools.cpp
View File

@ -212,7 +212,7 @@ void QgsGrassTools::runModule( QString name, bool direct )
if ( name == "shell" ) if ( name == "shell" )
{ {
#ifdef Q_OS_WIN #ifdef Q_OS_WIN
QgsGrass::putEnv( "GRASS_HTML_BROWSER", QgsApplication::libexecPath() + "grass/bin/qgis.g.browser" ); QgsGrass::putEnv( "GRASS_HTML_BROWSER", QgsGrassUtils::htmlBrowserPath() );
if ( !QProcess::startDetached( getenv( "COMSPEC" ) ) ) if ( !QProcess::startDetached( getenv( "COMSPEC" ) ) )
{ {
QMessageBox::warning( 0, "Warning", tr( "Cannot start command shell (%1)" ).arg( getenv( "COMSPEC" ) ) ); QMessageBox::warning( 0, "Warning", tr( "Cannot start command shell (%1)" ).arg( getenv( "COMSPEC" ) ) );

7
src/plugins/grass/qgsgrassutils.cpp
View File

@ -17,6 +17,7 @@
#include "qgsgrass.h" #include "qgsgrass.h"
#include "qgisinterface.h" #include "qgisinterface.h"
#include "qgsapplication.h"
#include "qgslogger.h" #include "qgslogger.h"
#include <QFileInfo> #include <QFileInfo>
@ -65,6 +66,12 @@ bool QgsGrassUtils::itemExists( QString element, QString item )
return fi.exists(); return fi.exists();
} }
QString QgsGrassUtils::htmlBrowserPath()
{
return QgsApplication::libexecPath() + "grass/bin/qgis.g.browser" + QString::number( QgsGrass::versionMajor() );
}
QgsGrassElementDialog::QgsGrassElementDialog( QWidget *parent ) QgsGrassElementDialog::QgsGrassElementDialog( QWidget *parent )
: QObject() : QObject()
, mDialog( 0 ) , mDialog( 0 )

2
src/plugins/grass/qgsgrassutils.h
View File

@ -47,6 +47,8 @@ class QgsGrassUtils
// Check if element exists in current mapset // Check if element exists in current mapset
static bool itemExists( QString element, QString item ); static bool itemExists( QString element, QString item );
//! Get path to custom HTML browser starter executable
static QString htmlBrowserPath();
}; };
/*! \class QgsGrassElementDialog /*! \class QgsGrassElementDialog

292
src/providers/grass/CMakeLists.txt
View File

@ -1,12 +1,10 @@
ADD_DEFINITIONS(-DGRASS_BASE=\\\"${GRASS_PREFIX}\\\") #ADD_DEFINITIONS(-DGRASS_BASE=\\\"${GRASS_PREFIX}\\\")
######################################################## ########################################################
# Build # Build
INCLUDE_DIRECTORIES( INCLUDE_DIRECTORIES(
../../core ../../core
../../core/raster ../../core/raster
${GRASS_INCLUDE_DIR}
${GDAL_INCLUDE_DIR} ${GDAL_INCLUDE_DIR}
${PROJ_INCLUDE_DIR} ${PROJ_INCLUDE_DIR}
${GEOS_INCLUDE_DIR} ${GEOS_INCLUDE_DIR}
@ -17,59 +15,167 @@ INCLUDE_DIRECTORIES(
# #
# GRASS library # GRASS library
# #
FOREACH(GRASS_BUILD_VERSION 6 7) # GRASS 6 and GRASS 7
IF(GRASS_FOUND${GRASS_BUILD_VERSION})
SET(GRASS_PREFIX ${GRASS_PREFIX${GRASS_BUILD_VERSION}})
SET(GRASS_MAJOR_VERSION ${GRASS_MAJOR_VERSION${GRASS_BUILD_VERSION}})
SET(GRASS_MINOR_VERSION ${GRASS_MINOR_VERSION${GRASS_BUILD_VERSION}})
QT4_WRAP_CPP(GRASS_PROVIDER_MOC_SRCS qgsgrassprovider.h) GET_PROPERTY(INCLUDE_DIRECTORIES DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
ADD_LIBRARY(qgisgrass SHARED qgsgrass.cpp qgsgrassfeatureiterator.cpp qgsgrassprovider.cpp ${GRASS_PROVIDER_MOC_SRCS}) LIST(APPEND INCLUDE_DIRECTORIES ${GRASS_INCLUDE_DIR${GRASS_BUILD_VERSION}})
SET_TARGET_PROPERTIES(qgisgrass PROPERTIES QT4_WRAP_CPP(GRASS_PROVIDER_MOC_SRCS qgsgrassprovider.h)
CLEAN_DIRECT_OUTPUT 1
FRAMEWORK 1
FRAMEWORK_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}"
MACOSX_FRAMEWORK_INFO_PLIST "${CMAKE_SOURCE_DIR}/mac/framework.info.plist.in"
MACOSX_FRAMEWORK_SHORT_VERSION_STRING ${COMPLETE_VERSION}
MACOSX_FRAMEWORK_IDENTIFIER org.qgis.qgis2_grass
COMPILE_FLAGS "\"-DGRASS_LIB_EXPORT=${DLLEXPORT}\" \"-DGRASS_EXPORT=${DLLIMPORT}\"" )
IF (APPLE) ADD_LIBRARY(qgisgrass${GRASS_BUILD_VERSION} SHARED qgsgrass.cpp qgsgrassfeatureiterator.cpp qgsgrassprovider.cpp ${GRASS_PROVIDER_MOC_SRCS})
SET_TARGET_PROPERTIES(qgisgrass PROPERTIES
LINK_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}" SET_TARGET_PROPERTIES(qgisgrass${GRASS_BUILD_VERSION} PROPERTIES
CLEAN_DIRECT_OUTPUT 1
FRAMEWORK 1
FRAMEWORK_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}"
MACOSX_FRAMEWORK_INFO_PLIST "${CMAKE_SOURCE_DIR}/mac/framework.info.plist.in"
MACOSX_FRAMEWORK_SHORT_VERSION_STRING ${COMPLETE_VERSION}
MACOSX_FRAMEWORK_IDENTIFIER org.qgis.qgis2_grass
INCLUDE_DIRECTORIES "${INCLUDE_DIRECTORIES}"
COMPILE_FLAGS "-DGRASS_BASE=\\\"${GRASS_PREFIX}\\\" \"-DGRASS_LIB_EXPORT=${DLLEXPORT}\" \"-DGRASS_EXPORT=${DLLIMPORT}\""
) )
ENDIF (APPLE)
#generate unversioned libs for android IF (APPLE)
IF (NOT ANDROID) SET_TARGET_PROPERTIES(qgisgrass${GRASS_BUILD_VERSION} PROPERTIES
SET_TARGET_PROPERTIES(qgisgrass PROPERTIES LINK_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}"
VERSION ${COMPLETE_VERSION} )
SOVERSION ${COMPLETE_VERSION} ENDIF (APPLE)
#generate unversioned libs for android
IF (NOT ANDROID)
SET_TARGET_PROPERTIES(qgisgrass${GRASS_BUILD_VERSION} PROPERTIES
VERSION ${COMPLETE_VERSION}
SOVERSION ${COMPLETE_VERSION}
)
ENDIF (NOT ANDROID)
IF (GRASS_MAJOR_VERSION LESS 7 )
SET(GRASS_TARGET_LINK_LIBRARIES${GRASS_BUILD_VERSION}
qgis_core
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_gis}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_vect}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_dbmibase}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_dbmiclient}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_gproj}
)
ELSE (GRASS_MAJOR_VERSION LESS 7 )
SET(GRASS_TARGET_LINK_LIBRARIES${GRASS_BUILD_VERSION}
qgis_core
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_gis}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_vector}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_raster}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_dbmibase}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_dbmiclient}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_gproj}
)
ENDIF (GRASS_MAJOR_VERSION LESS 7 )
TARGET_LINK_LIBRARIES(qgisgrass${GRASS_BUILD_VERSION} ${GRASS_TARGET_LINK_LIBRARIES${GRASS_BUILD_VERSION}})
IF (APPLE)
SET_TARGET_PROPERTIES(qgisgrass${GRASS_BUILD_VERSION} PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE)
ENDIF (APPLE)
#
# GRASS vector provider
#
ADD_LIBRARY(grassprovider${GRASS_BUILD_VERSION} MODULE qgsgrassprovidermodule.cpp)
SET_TARGET_PROPERTIES(grassprovider${GRASS_BUILD_VERSION} PROPERTIES
COMPILE_FLAGS "-DGRASS_BASE=\\\"${GRASS_PREFIX}\\\" \"-DGRASS_EXPORT=${DLLEXPORT}\" \"-DGRASS_LIB_EXPORT=${DLLIMPORT}\""
INCLUDE_DIRECTORIES "${INCLUDE_DIRECTORIES}"
) )
ENDIF (NOT ANDROID) TARGET_LINK_LIBRARIES(grassprovider${GRASS_BUILD_VERSION} qgisgrass${GRASS_BUILD_VERSION})
IF (GRASS_MAJOR_VERSION LESS 7 ) #
SET(GRASS_TARGET_LINK_LIBRARIES # grass raster provider
qgis_core #
${GRASS_LIBRARY_gis} QT4_WRAP_CPP(GRASS_RASTERPROVIDER_MOC_SRCS qgsgrassrasterprovider.h)
${GRASS_LIBRARY_vect} ADD_LIBRARY(grassrasterprovider${GRASS_BUILD_VERSION} MODULE qgsgrassrasterprovider.cpp ${GRASS_RASTERPROVIDER_MOC_SRCS})
${GRASS_LIBRARY_dbmibase} SET_TARGET_PROPERTIES(grassrasterprovider${GRASS_BUILD_VERSION} PROPERTIES
${GRASS_LIBRARY_dbmiclient} COMPILE_FLAGS "-DGRASS_BASE=\\\"${GRASS_PREFIX}\\\" \"-DGRASS_EXPORT=${DLLEXPORT}\" \"-DGRASS_LIB_EXPORT=${DLLIMPORT}\""
${GRASS_LIBRARY_gproj} INCLUDE_DIRECTORIES "${INCLUDE_DIRECTORIES}"
) )
ELSE (GRASS_MAJOR_VERSION LESS 7 ) TARGET_LINK_LIBRARIES(grassrasterprovider${GRASS_BUILD_VERSION} qgisgrass${GRASS_BUILD_VERSION} qgis_core)
SET(GRASS_TARGET_LINK_LIBRARIES
qgis_core
${GRASS_LIBRARY_gis}
${GRASS_LIBRARY_vector}
${GRASS_LIBRARY_raster}
${GRASS_LIBRARY_dbmibase}
${GRASS_LIBRARY_dbmiclient}
${GRASS_LIBRARY_gproj}
)
ENDIF (GRASS_MAJOR_VERSION LESS 7 )
TARGET_LINK_LIBRARIES(qgisgrass ${GRASS_TARGET_LINK_LIBRARIES}) # override default path where built files are put to allow running qgis without installing
# the modules go under libexec subdir
SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${QGIS_OUTPUT_DIRECTORY}/${QGIS_LIBEXEC_SUBDIR}/grass/modules)
IF (APPLE) #
SET_TARGET_PROPERTIES(qgisgrass PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE) # grass raster display module
ENDIF (APPLE) #
ADD_EXECUTABLE(qgis.d.rast${GRASS_BUILD_VERSION} qgis.d.rast.c)
IF (GRASS_MAJOR_VERSION LESS 7 )
TARGET_LINK_LIBRARIES(qgis.d.rast${GRASS_BUILD_VERSION}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_gis}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_datetime}
${GDAL_LIBRARY}
)
ELSE (GRASS_MAJOR_VERSION LESS 7 )
TARGET_LINK_LIBRARIES(qgis.d.rast${GRASS_BUILD_VERSION}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_gis}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_datetime}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_raster}
${GDAL_LIBRARY}
)
ENDIF (GRASS_MAJOR_VERSION LESS 7 )
SET_TARGET_PROPERTIES(qgis.d.rast${GRASS_BUILD_VERSION} PROPERTIES
INCLUDE_DIRECTORIES "${INCLUDE_DIRECTORIES}"
)
#
# grass info module
#
ADD_EXECUTABLE(qgis.g.info${GRASS_BUILD_VERSION} qgis.g.info.c)
IF (GRASS_MAJOR_VERSION LESS 7 )
TARGET_LINK_LIBRARIES(qgis.g.info${GRASS_BUILD_VERSION}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_gis}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_datetime}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_gproj}
${GDAL_LIBRARY}
)
ELSE (GRASS_MAJOR_VERSION LESS 7 )
TARGET_LINK_LIBRARIES(qgis.g.info${GRASS_BUILD_VERSION}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_gis}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_datetime}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_gproj}
${GRASS_LIBRARY${GRASS_BUILD_VERSION}_raster}
${GDAL_LIBRARY}
)
ENDIF (GRASS_MAJOR_VERSION LESS 7 )
IF (UNIX)
TARGET_LINK_LIBRARIES(qgis.g.info${GRASS_BUILD_VERSION} m)
ENDIF (UNIX)
SET_TARGET_PROPERTIES(qgis.g.info${GRASS_BUILD_VERSION} PROPERTIES
INCLUDE_DIRECTORIES "${INCLUDE_DIRECTORIES}"
)
########################################################
# Install
INSTALL(TARGETS qgisgrass${GRASS_BUILD_VERSION}
RUNTIME DESTINATION ${QGIS_BIN_DIR}
LIBRARY DESTINATION ${QGIS_LIB_DIR}
FRAMEWORK DESTINATION ${QGIS_FW_SUBDIR})
INSTALL(TARGETS grassprovider${GRASS_BUILD_VERSION}
RUNTIME DESTINATION ${QGIS_PLUGIN_DIR}
LIBRARY DESTINATION ${QGIS_PLUGIN_DIR})
INSTALL(TARGETS grassrasterprovider${GRASS_BUILD_VERSION}
RUNTIME DESTINATION ${QGIS_PLUGIN_DIR}
LIBRARY DESTINATION ${QGIS_PLUGIN_DIR})
INSTALL(TARGETS qgis.d.rast${GRASS_BUILD_VERSION} qgis.g.info${GRASS_BUILD_VERSION}
RUNTIME DESTINATION ${QGIS_LIBEXEC_DIR}/grass/modules
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)
ENDIF(GRASS_FOUND${GRASS_BUILD_VERSION})
ENDFOREACH(GRASS_BUILD_VERSION 6 7)
# #
# Fake GRASS gis library # Fake GRASS gis library
@ -547,94 +653,8 @@ IF(WITH_GRASS_DIRECT)
TARGET_LINK_LIBRARIES(${FAKE_LIB_GRASS_GIS} TARGET_LINK_LIBRARIES(${FAKE_LIB_GRASS_GIS}
qgis_core qgis_core
) )
INSTALL(TARGETS ${FAKE_LIB_GRASS_GIS}
RUNTIME DESTINATION ${QGIS_PLUGIN_DIR}
LIBRARY DESTINATION ${QGIS_PLUGIN_DIR})
ENDIF(WITH_GRASS_DIRECT) ENDIF(WITH_GRASS_DIRECT)
#
# GRASS vector provider
#
ADD_LIBRARY(grassprovider MODULE qgsgrassprovidermodule.cpp)
SET_TARGET_PROPERTIES(grassprovider PROPERTIES COMPILE_FLAGS "\"-DGRASS_EXPORT=${DLLEXPORT}\" \"-DGRASS_LIB_EXPORT=${DLLIMPORT}\"" )
TARGET_LINK_LIBRARIES(grassprovider qgisgrass)
#
# grass raster provider
#
QT4_WRAP_CPP(GRASS_RASTERPROVIDER_MOC_SRCS qgsgrassrasterprovider.h)
ADD_LIBRARY(grassrasterprovider MODULE qgsgrassrasterprovider.cpp ${GRASS_RASTERPROVIDER_MOC_SRCS})
SET_TARGET_PROPERTIES(grassrasterprovider PROPERTIES COMPILE_FLAGS "\"-DGRASS_EXPORT=${DLLEXPORT}\" \"-DGRASS_LIB_EXPORT=${DLLIMPORT}\"" )
TARGET_LINK_LIBRARIES(grassrasterprovider qgisgrass qgis_core)
# override default path where built files are put to allow running qgis without installing
# the modules go under libexec subdir
SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${QGIS_OUTPUT_DIRECTORY}/${QGIS_LIBEXEC_SUBDIR}/grass/modules)
#
# grass raster display module
#
ADD_EXECUTABLE(qgis.d.rast qgis.d.rast.c)
IF (GRASS_MAJOR_VERSION LESS 7 )
TARGET_LINK_LIBRARIES(qgis.d.rast
${GRASS_LIBRARY_gis}
${GRASS_LIBRARY_datetime}
${GDAL_LIBRARY}
)
ELSE (GRASS_MAJOR_VERSION LESS 7 )
TARGET_LINK_LIBRARIES(qgis.d.rast
${GRASS_LIBRARY_gis}
${GRASS_LIBRARY_datetime}
${GRASS_LIBRARY_raster}
${GDAL_LIBRARY}
)
ENDIF (GRASS_MAJOR_VERSION LESS 7 )
#
# grass info module
#
ADD_EXECUTABLE(qgis.g.info qgis.g.info.c)
IF (GRASS_MAJOR_VERSION LESS 7 )
TARGET_LINK_LIBRARIES(qgis.g.info
${GRASS_LIBRARY_gis}
${GRASS_LIBRARY_datetime}
${GRASS_LIBRARY_gproj}
${GDAL_LIBRARY}
)
ELSE (GRASS_MAJOR_VERSION LESS 7 )
TARGET_LINK_LIBRARIES(qgis.g.info
${GRASS_LIBRARY_gis}
${GRASS_LIBRARY_datetime}
${GRASS_LIBRARY_gproj}
${GRASS_LIBRARY_raster}
${GDAL_LIBRARY}
)
ENDIF (GRASS_MAJOR_VERSION LESS 7 )
IF (UNIX)
TARGET_LINK_LIBRARIES(qgis.g.info m)
ENDIF (UNIX)
########################################################
# Install
INSTALL(TARGETS qgisgrass
RUNTIME DESTINATION ${QGIS_BIN_DIR}
LIBRARY DESTINATION ${QGIS_LIB_DIR}
FRAMEWORK DESTINATION ${QGIS_FW_SUBDIR})
INSTALL(TARGETS ${FAKE_LIB_GRASS_GIS}
RUNTIME DESTINATION ${QGIS_PLUGIN_DIR}
LIBRARY DESTINATION ${QGIS_PLUGIN_DIR})
INSTALL(TARGETS grassprovider
RUNTIME DESTINATION ${QGIS_PLUGIN_DIR}
LIBRARY DESTINATION ${QGIS_PLUGIN_DIR})
INSTALL(TARGETS grassrasterprovider
RUNTIME DESTINATION ${QGIS_PLUGIN_DIR}
LIBRARY DESTINATION ${QGIS_PLUGIN_DIR})
INSTALL(TARGETS qgis.d.rast qgis.g.info
RUNTIME DESTINATION ${QGIS_LIBEXEC_DIR}/grass/modules
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)

1
src/providers/grass/qgsgrass.cpp
View File

@ -1276,6 +1276,7 @@ QProcess GRASS_LIB_EXPORT *QgsGrass::startModule( QString gisdbase, QString loca
QgsDebugMsg( QString( "gisdbase = %1 location = %2" ).arg( gisdbase ).arg( location ) ); QgsDebugMsg( QString( "gisdbase = %1 location = %2" ).arg( gisdbase ).arg( location ) );
QProcess *process = new QProcess(); QProcess *process = new QProcess();
module += QString::number( QgsGrass::versionMajor() );
#ifdef Q_OS_WIN #ifdef Q_OS_WIN
module += ".exe"; module += ".exe";
#endif #endif

2
src/providers/grass/qgsgrassprovidermodule.cpp
View File

@ -216,7 +216,7 @@ QGISEXTERN QString providerKey()
*/ */
QGISEXTERN QString description() QGISEXTERN QString description()
{ {
return QString( "GRASS data provider" ); return QString( "GRASS %1 vector provider" ).arg( GRASS_VERSION_MAJOR );
} }
/** /**

2
src/providers/grass/qgsgrassrasterprovider.cpp
View File

@ -42,7 +42,7 @@
#define ERROR(message) QgsError(message,"GRASS provider") #define ERROR(message) QgsError(message,"GRASS provider")
static QString PROVIDER_KEY = "grassraster"; static QString PROVIDER_KEY = "grassraster";
static QString PROVIDER_DESCRIPTION = "GRASS raster provider"; static QString PROVIDER_DESCRIPTION = QString( "GRASS %1 raster provider" ).arg( GRASS_VERSION_MAJOR );
QgsGrassRasterProvider::QgsGrassRasterProvider( QString const & uri ) QgsGrassRasterProvider::QgsGrassRasterProvider( QString const & uri )
: QgsRasterDataProvider( uri ) : QgsRasterDataProvider( uri )