sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-04-13 00:03:09 -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)
# try to configure and build GRASS plugin by default
SET (WITH_GRASS TRUE CACHE BOOL "Determines whether GRASS plugin should be built")
IF (WITH_GRASS)
FIND_PACKAGE(GRASS)
SET (GRASS_PREFIX ${GRASS_PREFIX} CACHE PATH "Path to GRASS base directory")
ENDIF (WITH_GRASS)
FOREACH (GRASS_SEARCH_VERSION 6 7)
# For GRASS 6 are used cached variables without version suffix so that existing caches don't have to be reconfigured.
# Cached variables: WITH_GRASS, WITH_GRASS7, GRASS_PREFIX, GRASS_PREFIX7, GRASS_INCLUDE_DIR, GRASS_INCLUDE_DIR7
# Everywhere else each variable has version major appended.
# 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")

147
cmake/FindGRASS.cmake
View File

@ -7,99 +7,130 @@
# macro that checks for grass installation in specified directory
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)
FILE(READ ${GRASS_INCLUDE_DIR}/grass/version.h VERSIONFILE)
#MESSAGE(STATUS "GRASS_INCLUDE_DIR${GRASS_CACHE_VERSION} = ${GRASS_INCLUDE_DIR${GRASS_CACHE_VERSION}}")
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
# version_greater. Are there compatibility problems?
STRING(REGEX MATCH "[0-9]+\\.[0-9]+\\.[^ ]+" GRASS_VERSION ${VERSIONFILE})
STRING(REGEX REPLACE "^([0-9]*)\\.[0-9]*\\..*$" "\\1" GRASS_MAJOR_VERSION ${GRASS_VERSION})
STRING(REGEX REPLACE "^[0-9]*\\.([0-9]*)\\..*$" "\\1" GRASS_MINOR_VERSION ${GRASS_VERSION})
STRING(REGEX REPLACE "^[0-9]*\\.[0-9]*\\.(.*)$" "\\1" GRASS_MICRO_VERSION ${GRASS_VERSION})
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_FIND_VERSION} ${GRASS_VERSION${GRASS_FIND_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_FIND_VERSION} ${GRASS_VERSION${GRASS_FIND_VERSION}})
# Add micro version too?
# 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)
SET (GRASS_LIB_NAMES gis dig2 dbmiclient dbmibase shape dgl rtree datetime linkm gproj)
IF (GRASS_MAJOR_VERSION LESS 7 )
LIST(APPEND GRASS_LIB_NAMES vect)
LIST(APPEND GRASS_LIB_NAMES form)
ELSE (GRASS_MAJOR_VERSION LESS 7 )
LIST(APPEND GRASS_LIB_NAMES vector)
LIST(APPEND GRASS_LIB_NAMES raster)
ENDIF (GRASS_MAJOR_VERSION LESS 7 )
#MESSAGE(STATUS "GRASS_MAJOR_VERSION${GRASS_FIND_VERSION} = ${GRASS_MAJOR_VERSION${GRASS_FIND_VERSION}}")
IF(GRASS_MAJOR_VERSION${GRASS_FIND_VERSION} EQUAL GRASS_FIND_VERSION)
SET(GRASS_LIBRARIES_FOUND${GRASS_FIND_VERSION} TRUE)
SET(GRASS_LIB_NAMES${GRASS_FIND_VERSION} gis dig2 dbmiclient dbmibase shape dgl rtree datetime linkm gproj)
IF(GRASS_MAJOR_VERSION${GRASS_FIND_VERSION} LESS 7 )
LIST(APPEND GRASS_LIB_NAMES${GRASS_FIND_VERSION} vect)
LIST(APPEND GRASS_LIB_NAMES${GRASS_FIND_VERSION} form)
ELSE(GRASS_MAJOR_VERSION${GRASS_FIND_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})
MARK_AS_ADVANCED ( GRASS_LIBRARY_${LIB} )
FOREACH(LIB ${GRASS_LIB_NAMES${GRASS_FIND_VERSION}})
MARK_AS_ADVANCED ( GRASS_LIBRARY${GRASS_FIND_VERSION}_${LIB} )
SET(LIB_PATH NOTFOUND)
FIND_LIBRARY(LIB_PATH NAMES grass_${LIB} PATHS ${G_PREFIX}/lib NO_DEFAULT_PATH)
SET(LIB_PATH NOTFOUND)
FIND_LIBRARY(LIB_PATH NAMES grass_${LIB} PATHS ${G_PREFIX}/lib NO_DEFAULT_PATH)
IF (LIB_PATH)
SET (GRASS_LIBRARY_${LIB} ${LIB_PATH})
ELSE (LIB_PATH)
SET (GRASS_LIBRARY_${LIB} NOTFOUND)
SET (GRASS_LIBRARIES_FOUND FALSE)
ENDIF (LIB_PATH)
ENDFOREACH (LIB)
IF(LIB_PATH)
SET(GRASS_LIBRARY${GRASS_FIND_VERSION}_${LIB} ${LIB_PATH})
ELSE(LIB_PATH)
SET(GRASS_LIBRARY${GRASS_FIND_VERSION}_${LIB} NOTFOUND)
SET(GRASS_LIBRARIES_FOUND${GRASS_FIND_VERSION} FALSE)
ENDIF (LIB_PATH)
ENDFOREACH(LIB)
# LIB_PATH is only temporary variable, so hide it (is it possible to delete a variable?)
UNSET(LIB_PATH CACHE)
# LIB_PATH is only temporary variable, so hide it (is it possible to delete a variable?)
UNSET(LIB_PATH CACHE)
IF (GRASS_LIBRARIES_FOUND)
SET (GRASS_FOUND TRUE)
SET (GRASS_PREFIX ${G_PREFIX})
ENDIF (GRASS_LIBRARIES_FOUND)
ENDIF( GRASS_INCLUDE_DIR )
IF(GRASS_LIBRARIES_FOUND${GRASS_FIND_VERSION})
SET(GRASS_FOUND${GRASS_FIND_VERSION} TRUE)
SET(GRASS_FOUND TRUE) # GRASS_FOUND is true if at least one version was found
SET(GRASS_PREFIX${GRASS_CACHE_VERSION} ${G_PREFIX})
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)
###################################
# search for grass installations
# list of paths which to search - user's choice as first
SET (GRASS_PATHS ${GRASS_PREFIX} /usr/lib/grass /usr/lib64/grass64 /usr/lib/grass64 c:/msys/local /opt/grass $ENV{GRASS_PREFIX})
#MESSAGE(STATUS "GRASS_FIND_VERSION = ${GRASS_FIND_VERSION}")
# 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)
SET (GRASS_PATHS ${GRASS_PATHS}
/Applications/GRASS-6.3.app/Contents/MacOS
/Applications/GRASS-6.4.app/Contents/MacOS
/Applications/GRASS.app/Contents/Resources
)
IF (GRASS_FIND_VERSION EQUAL 6)
LIST(APPEND GRASS_PATHS
/Applications/GRASS-6.3.app/Contents/MacOS
/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)
IF (WITH_GRASS)
IF (WITH_GRASS${GRASS_CACHE_VERSION})
FOREACH (G_PREFIX ${GRASS_PATHS})
IF (NOT GRASS_FOUND)
IF (NOT GRASS_FOUND${GRASS_FIND_VERSION})
CHECK_GRASS(${G_PREFIX})
ENDIF (NOT GRASS_FOUND)
ENDIF (NOT GRASS_FOUND${GRASS_FIND_VERSION})
ENDFOREACH (G_PREFIX)
ENDIF (WITH_GRASS)
ENDIF (WITH_GRASS${GRASS_CACHE_VERSION})
###################################
IF (GRASS_FOUND)
IF (GRASS_FOUND${GRASS_FIND_VERSION})
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)
ELSE (GRASS_FOUND)
ELSE (GRASS_FOUND${GRASS_FIND_VERSION})
IF (WITH_GRASS)
IF (WITH_GRASS${GRASS_CACHE_VERSION})
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)
MESSAGE(STATUS "Could not find GRASS")
MESSAGE(STATUS "Could not find GRASS ${GRASS_FIND_VERSION}")
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)
IF (GRASS_FOUND)
IF (GRASS_MAJOR_VERSION LESS 7 )
ADD_SUBDIRECTORY(grass)
ENDIF (GRASS_MAJOR_VERSION LESS 7 )
ADD_SUBDIRECTORY(grass)
ENDIF (GRASS_FOUND)
IF (WITH_GLOBE)

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

@ -1,7 +1,7 @@
ADD_SUBDIRECTORY(modules)
ADD_SUBDIRECTORY(scripts)
ADD_DEFINITIONS(-DGRASS_BASE=\\\"${GRASS_PREFIX}\\\")
#ADD_DEFINITIONS(-DGRASS_BASE=\\\"${GRASS_PREFIX}\\\")
ADD_DEFINITIONS(-DHAVE_OPENPTY=${HAVE_OPENPTY})
ADD_DEFINITIONS("-DGRASS_EXPORT=${DLLIMPORT} -DGRASS_LIB_EXPORT=${DLLIMPORT}")
@ -18,96 +18,96 @@ ENDIF (WIN32)
# Files
SET (GRASS_PLUGIN_SRCS
qgsgrassplugin.cpp
qgsgrassselect.cpp
qgsgrassbrowser.cpp
qgsgrassedit.cpp
qgsgrassedittools.cpp
qgsgrasstools.cpp
qgsgrassmodel.cpp
qgsgrassmapcalc.cpp
qgsgrassmodule.cpp
qgsgrassnewmapset.cpp
qgsgrassattributes.cpp
qgsgrassregion.cpp
qgsgrassutils.cpp
qgsgrassplugin.cpp
qgsgrassselect.cpp
qgsgrassbrowser.cpp
qgsgrassedit.cpp
qgsgrassedittools.cpp
qgsgrasstools.cpp
qgsgrassmodel.cpp
qgsgrassmapcalc.cpp
qgsgrassmodule.cpp
qgsgrassnewmapset.cpp
qgsgrassattributes.cpp
qgsgrassregion.cpp
qgsgrassutils.cpp
)
SET (GRASS_PLUGIN_UIS
qgsgrasstoolsbase.ui
qgsgrassselectbase.ui
qgsgrasseditbase.ui
qgsgrassmapcalcbase.ui
qgsgrassmodulebase.ui
qgsgrassnewmapsetbase.ui
qgsgrassattributesbase.ui
qgsgrassregionbase.ui
../../ui/qgsprojectionselectorbase.ui
qgsgrasstoolsbase.ui
qgsgrassselectbase.ui
qgsgrasseditbase.ui
qgsgrassmapcalcbase.ui
qgsgrassmodulebase.ui
qgsgrassnewmapsetbase.ui
qgsgrassattributesbase.ui
qgsgrassregionbase.ui
../../ui/qgsprojectionselectorbase.ui
)
SET (GRASS_PLUGIN_MOC_HDRS
qgsgrassplugin.h
qgsgrassselect.h
qgsgrassbrowser.h
qgsgrassedit.h
qgsgrasstools.h
qgsgrassmodel.h
qgsgrassmapcalc.h
qgsgrassmodule.h
qgsgrassnewmapset.h
qgsgrassattributes.h
qgsgrassregion.h
qgsgrassutils.h
qgsgrassedittools.h
qgsgrassplugin.h
qgsgrassselect.h
qgsgrassbrowser.h
qgsgrassedit.h
qgsgrasstools.h
qgsgrassmodel.h
qgsgrassmapcalc.h
qgsgrassmodule.h
qgsgrassnewmapset.h
qgsgrassattributes.h
qgsgrassregion.h
qgsgrassutils.h
qgsgrassedittools.h
)
IF(NOT WIN32)
SET (GRASS_PLUGIN_SRCS ${GRASS_PLUGIN_SRCS}
qgsgrassshell.cpp
qtermwidget/BlockArray.cpp
qtermwidget/Emulation.cpp
qtermwidget/Filter.cpp
qtermwidget/History.cpp
qtermwidget/KeyboardTranslator.cpp
qtermwidget/Pty.cpp
qtermwidget/Screen.cpp
qtermwidget/ScreenWindow.cpp
qtermwidget/Session.cpp
qtermwidget/ShellCommand.cpp
qtermwidget/TerminalCharacterDecoder.cpp
qtermwidget/TerminalDisplay.cpp
qtermwidget/Vt102Emulation.cpp
qtermwidget/k3process.cpp
qtermwidget/k3processcontroller.cpp
qtermwidget/konsole_wcwidth.cpp
qtermwidget/kpty.cpp
qtermwidget/qtermwidget.cpp
)
SET (GRASS_PLUGIN_SRCS ${GRASS_PLUGIN_SRCS}
qgsgrassshell.cpp
qtermwidget/BlockArray.cpp
qtermwidget/Emulation.cpp
qtermwidget/Filter.cpp
qtermwidget/History.cpp
qtermwidget/KeyboardTranslator.cpp
qtermwidget/Pty.cpp
qtermwidget/Screen.cpp
qtermwidget/ScreenWindow.cpp
qtermwidget/Session.cpp
qtermwidget/ShellCommand.cpp
qtermwidget/TerminalCharacterDecoder.cpp
qtermwidget/TerminalDisplay.cpp
qtermwidget/Vt102Emulation.cpp
qtermwidget/k3process.cpp
qtermwidget/k3processcontroller.cpp
qtermwidget/konsole_wcwidth.cpp
qtermwidget/kpty.cpp
qtermwidget/qtermwidget.cpp
)
SET (GRASS_PLUGIN_MOC_HDRS ${GRASS_PLUGIN_MOC_HDRS}
qgsgrassshell.h
qtermwidget/Emulation.h
qtermwidget/Filter.h
qtermwidget/Pty.h
qtermwidget/ScreenWindow.h
qtermwidget/Session.h
qtermwidget/TerminalDisplay.h
qtermwidget/Vt102Emulation.h
qtermwidget/k3process.h
qtermwidget/k3processcontroller.h
qtermwidget/qtermwidget.h
)
SET (GRASS_PLUGIN_MOC_HDRS ${GRASS_PLUGIN_MOC_HDRS}
qgsgrassshell.h
qtermwidget/Emulation.h
qtermwidget/Filter.h
qtermwidget/Pty.h
qtermwidget/ScreenWindow.h
qtermwidget/Session.h
qtermwidget/TerminalDisplay.h
qtermwidget/Vt102Emulation.h
qtermwidget/k3process.h
qtermwidget/k3processcontroller.h
qtermwidget/qtermwidget.h
)
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
SET_SOURCE_FILES_PROPERTIES(
${CMAKE_CURRENT_BINARY_DIR}/qtermwidget/moc_Pty.cxx
qtermwidget/Pty.cpp
qtermwidget/Session.cpp
qtermwidget/kpty.cpp
qtermwidget/k3process.cpp
PROPERTIES COMPILE_FLAGS "-Wno-overloaded-virtual -Wno-mismatched-tags"
)
SET_SOURCE_FILES_PROPERTIES(
${CMAKE_CURRENT_BINARY_DIR}/qtermwidget/moc_Pty.cxx
qtermwidget/Pty.cpp
qtermwidget/Session.cpp
qtermwidget/kpty.cpp
qtermwidget/k3process.cpp
PROPERTIES COMPILE_FLAGS "-Wno-overloaded-virtual -Wno-mismatched-tags"
)
ENDIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
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})
########################################################
# build lib
ADD_LIBRARY (grassplugin MODULE
${GRASS_PLUGIN_SRCS}
${GRASS_PLUGIN_MOC_SRCS}
${GRASS_PLUGIN_UIS_H}
${GRASS_PLUGIN_RCC_SRCS}
)
INCLUDE_DIRECTORIES(
..
${CMAKE_CURRENT_BINARY_DIR}
../../core
../../core/raster
../../gui
../../providers/grass
${CMAKE_CURRENT_BINARY_DIR}/../../ui
${GRASS_INCLUDE_DIR}
${GDAL_INCLUDE_DIR}
${PROJ_INCLUDE_DIR}
${GEOS_INCLUDE_DIR}
qtermwidget
..
${CMAKE_CURRENT_BINARY_DIR}
../../core
../../core/raster
../../gui
../../providers/grass
${CMAKE_CURRENT_BINARY_DIR}/../../ui
${GDAL_INCLUDE_DIR}
${PROJ_INCLUDE_DIR}
${GEOS_INCLUDE_DIR}
qtermwidget
)
TARGET_LINK_LIBRARIES(grassplugin
qgisgrass
qgis_gui
${OPENPTY_LIBRARY}
)
FOREACH(GRASS_BUILD_VERSION 6) # 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}})
IF (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
TARGET_LINK_LIBRARIES(grassplugin ulog)
ENDIF (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
GET_PROPERTY(INCLUDE_DIRECTORIES DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
LIST(APPEND INCLUDE_DIRECTORIES ${GRASS_INCLUDE_DIR${GRASS_BUILD_VERSION}})
# override default path where built files are put to allow running qgis without installing
# the binary goes under libexec subdir
SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${QGIS_OUTPUT_DIRECTORY}/${QGIS_LIBEXEC_SUBDIR}/grass/bin)
ADD_LIBRARY (grassplugin${GRASS_BUILD_VERSION} MODULE
${GRASS_PLUGIN_SRCS}
${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
${QT_QTGUI_LIBRARY}
${QT_QTCORE_LIBRARY}
)
TARGET_LINK_LIBRARIES(grassplugin${GRASS_BUILD_VERSION}
qgisgrass${GRASS_BUILD_VERSION}
qgis_gui
${OPENPTY_LIBRARY}
)
########################################################
# Install
IF (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
TARGET_LINK_LIBRARIES(grassplugin${GRASS_BUILD_VERSION} ulog)
ENDIF (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
INSTALL(TARGETS grassplugin
RUNTIME DESTINATION ${QGIS_PLUGIN_DIR}
LIBRARY DESTINATION ${QGIS_PLUGIN_DIR})
# override default path where built files are put to allow running qgis without installing
# the binary goes under libexec subdir
SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${QGIS_OUTPUT_DIRECTORY}/${QGIS_LIBEXEC_SUBDIR}/grass/bin)
FILE (GLOB GMLS *.gml)
INSTALL (FILES ${GMLS}
DESTINATION ${QGIS_DATA_DIR}/grass)
ADD_EXECUTABLE(qgis.g.browser${GRASS_BUILD_VERSION} ${GRASS_BROWSER_SRCS})
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)
SET_TARGET_PROPERTIES(qgis.g.browser${GRASS_BUILD_VERSION} PROPERTIES
INCLUDE_DIRECTORIES "${INCLUDE_DIRECTORIES}"
COMPILE_FLAGS "-DGRASS_BASE=\\\"${GRASS_PREFIX}\\\""
)
INSTALL(TARGETS qgis.g.browser
RUNTIME DESTINATION ${QGIS_LIBEXEC_DIR}/grass/bin
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)
TARGET_LINK_LIBRARIES (qgis.g.browser${GRASS_BUILD_VERSION}
${QT_QTGUI_LIBRARY}
${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();
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
// 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>
}
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";
/**
@ -58,11 +61,7 @@ static const QString pluginIcon = ":/images/themes/default/grass/grass_tools.png
* @param theQgisInterFace Pointer to the QGIS interface object
*/
QgsGrassPlugin::QgsGrassPlugin( QgisInterface * theQgisInterFace )
: pluginNameQString( tr( "GrassVector" ) )
, pluginVersionQString( tr( "0.1" ) )
, pluginDescriptionQString( tr( "GRASS layer" ) )
, pluginCategoryQString( tr( "Plugins" ) )
, mToolBarPointer( 0 )
: mToolBarPointer( 0 )
, qGisInterface( theQgisInterFace )
, mCanvas( 0 )
, mRegionAction( 0 )
@ -95,22 +94,22 @@ QgsGrassPlugin::~QgsGrassPlugin()
/* Following functions return name, description, version, and type for the plugin */
QString QgsGrassPlugin::name()
{
return pluginNameQString;
return pluginName;
}
QString QgsGrassPlugin::version()
{
return pluginVersionQString;
return pluginVersion;
}
QString QgsGrassPlugin::description()
{
return pluginDescriptionQString;
return pluginDescription;
}
QString QgsGrassPlugin::category()
{
return pluginCategoryQString;
return pluginCategory;
}
void QgsGrassPlugin::help()
@ -973,19 +972,19 @@ QGISEXTERN QgisPlugin * classFactory( QgisInterface * theQgisInterfacePointer )
// the class may not yet be insantiated when this method is called.
QGISEXTERN QString name()
{
return QObject::tr( "GRASS" );
return pluginName;
}
// Return the description
QGISEXTERN QString description()
{
return QObject::tr( "GRASS layer" );
return pluginDescription;
}
// Return the category
QGISEXTERN QString category()
{
return QObject::tr( "Plugins" );
return pluginCategory;
}
// 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 editClosed();
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
QToolBar *mToolBarPointer;
//! Pointer to the QGIS interface object

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

@ -23,6 +23,7 @@
#include "qgsgrass.h"
#include "qgsconfig.h"
#include "qgsgrassutils.h"
#include "qgsgrassshell.h"
extern "C"
@ -100,7 +101,7 @@ void QgsGrassShell::initTerminal( QTermWidget *terminal )
env << "TERM=vt100";
env << "GISRC_MODE_MEMORY";
// 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_TCLSH=tclsh";
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" )
{
#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" ) ) )
{
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 "qgisinterface.h"
#include "qgsapplication.h"
#include "qgslogger.h"
#include <QFileInfo>
@ -65,6 +66,12 @@ bool QgsGrassUtils::itemExists( QString element, QString item )
return fi.exists();
}
QString QgsGrassUtils::htmlBrowserPath()
{
return QgsApplication::libexecPath() + "grass/bin/qgis.g.browser" + QString::number( QgsGrass::versionMajor() );
}
QgsGrassElementDialog::QgsGrassElementDialog( QWidget *parent )
: QObject()
, mDialog( 0 )

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

@ -47,6 +47,8 @@ class QgsGrassUtils
// Check if element exists in current mapset
static bool itemExists( QString element, QString item );
//! Get path to custom HTML browser starter executable
static QString htmlBrowserPath();
};
/*! \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
INCLUDE_DIRECTORIES(
../../core
../../core/raster
${GRASS_INCLUDE_DIR}
${GDAL_INCLUDE_DIR}
${PROJ_INCLUDE_DIR}
${GEOS_INCLUDE_DIR}
@ -17,59 +15,167 @@ INCLUDE_DIRECTORIES(
#
# 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)
ADD_LIBRARY(qgisgrass SHARED qgsgrass.cpp qgsgrassfeatureiterator.cpp qgsgrassprovider.cpp ${GRASS_PROVIDER_MOC_SRCS})
GET_PROPERTY(INCLUDE_DIRECTORIES DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
LIST(APPEND INCLUDE_DIRECTORIES ${GRASS_INCLUDE_DIR${GRASS_BUILD_VERSION}})
SET_TARGET_PROPERTIES(qgisgrass 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
COMPILE_FLAGS "\"-DGRASS_LIB_EXPORT=${DLLEXPORT}\" \"-DGRASS_EXPORT=${DLLIMPORT}\"" )
QT4_WRAP_CPP(GRASS_PROVIDER_MOC_SRCS qgsgrassprovider.h)
IF (APPLE)
SET_TARGET_PROPERTIES(qgisgrass PROPERTIES
LINK_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}"
ADD_LIBRARY(qgisgrass${GRASS_BUILD_VERSION} SHARED qgsgrass.cpp qgsgrassfeatureiterator.cpp qgsgrassprovider.cpp ${GRASS_PROVIDER_MOC_SRCS})
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 (NOT ANDROID)
SET_TARGET_PROPERTIES(qgisgrass PROPERTIES
VERSION ${COMPLETE_VERSION}
SOVERSION ${COMPLETE_VERSION}
IF (APPLE)
SET_TARGET_PROPERTIES(qgisgrass${GRASS_BUILD_VERSION} PROPERTIES
LINK_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}"
)
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
qgis_core
${GRASS_LIBRARY_gis}
${GRASS_LIBRARY_vect}
${GRASS_LIBRARY_dbmibase}
${GRASS_LIBRARY_dbmiclient}
${GRASS_LIBRARY_gproj}
#
# grass raster provider
#
QT4_WRAP_CPP(GRASS_RASTERPROVIDER_MOC_SRCS qgsgrassrasterprovider.h)
ADD_LIBRARY(grassrasterprovider${GRASS_BUILD_VERSION} MODULE qgsgrassrasterprovider.cpp ${GRASS_RASTERPROVIDER_MOC_SRCS})
SET_TARGET_PROPERTIES(grassrasterprovider${GRASS_BUILD_VERSION} PROPERTIES
COMPILE_FLAGS "-DGRASS_BASE=\\\"${GRASS_PREFIX}\\\" \"-DGRASS_EXPORT=${DLLEXPORT}\" \"-DGRASS_LIB_EXPORT=${DLLIMPORT}\""
INCLUDE_DIRECTORIES "${INCLUDE_DIRECTORIES}"
)
ELSE (GRASS_MAJOR_VERSION LESS 7 )
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(grassrasterprovider${GRASS_BUILD_VERSION} qgisgrass${GRASS_BUILD_VERSION} qgis_core)
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)
ENDIF (APPLE)
#
# grass raster display module
#
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
@ -547,94 +653,8 @@ IF(WITH_GRASS_DIRECT)
TARGET_LINK_LIBRARIES(${FAKE_LIB_GRASS_GIS}
qgis_core
)
INSTALL(TARGETS ${FAKE_LIB_GRASS_GIS}
RUNTIME DESTINATION ${QGIS_PLUGIN_DIR}
LIBRARY DESTINATION ${QGIS_PLUGIN_DIR})
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 ) );
QProcess *process = new QProcess();
module += QString::number( QgsGrass::versionMajor() );
#ifdef Q_OS_WIN
module += ".exe";
#endif

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

@ -216,7 +216,7 @@ QGISEXTERN QString providerKey()
*/
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")
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 )
: QgsRasterDataProvider( uri )