| gvSIG desktop 1

PROJECT(jpotrace)

# Looking for arch extension!

SET(LIB_POSTFIX "32")

IF(UNIX)

	IF(NOT APPLE)

		IF(CMAKE_SIZEOF_VOID_P MATCHES "8")

			SET(LIB_POSTFIX "64")

		ENDIF(CMAKE_SIZEOF_VOID_P MATCHES "8")

	ENDIF(NOT APPLE)

ELSE(UNIX)

	IF(CMAKE_SYSTEM_NAME MATCHES Windows)

		IF(CMAKE_CL_64)

			SET(LIB_POSTFIX "64")

		ENDIF(CMAKE_CL_64)

	ENDIF(CMAKE_SYSTEM_NAME MATCHES Windows)

ENDIF(UNIX)

SET(platform_dir)

IF(WIN32)

	IF(NOT CYGWIN)

		SET(platform_dir "w${LIB_POSTFIX}")

	ENDIF(NOT CYGWIN)

ENDIF(WIN32)

IF(UNIX)

	IF(APPLE)

		SET(platform_dir "mac")

	ELSE(APPLE)

		SET(platform_dir "linux")

	ENDIF(APPLE)

ENDIF(UNIX)

IF(UNIX)

	SET(CMAKE_CXX_FLAGS_RELEASE "-O -DNDEBUG")

	SET(CMAKE_C_FLAGS_RELEASE "-O -DNDEBUG")

ENDIF(UNIX)

MESSAGE(STATUS "Platform:" ${platform_dir})

SET(GVSIG_BINARIES_PATH "${CMAKE_SOURCE_DIR}/../binaries/${platform_dir}/raster/potrace")

SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/CMakeModules;${CMAKE_MODULE_PATH}")

FILE(MAKE_DIRECTORY ${CMAKE_SOURCE_DIR}/lib-dist)

#FILE(MAKE_DIRECTORY ${CMAKE_SOURCE_DIR}/bin-dist)

set(LIBRARY_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/lib-dist)

#set(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/bin-dist)

#set(CMAKE_SKIP_RPATH TRUE)

IF(APPLE)

	SET(CMAKE_INSTALL_NAME_DIR @executable_path/../Resources/NativeLibs CACHE STRING "Executable Path for MacOS X" FORCE)

		MARK_AS_ADVANCED(CMAKE_INSTALL_NAME_DIR)

ENDIF(APPLE)

SET(CMAKE_INSTALL_PREFIX ${GVSIG_BINARIES_PATH} CACHE STRING "Forcing install path" FORCE)

MARK_AS_ADVANCED(CMAKE_INSTALL_PREFIX)

# This is for an advanced option to give aggressive warnings

# under different compilers. If yours is not implemented, this option

# will not be made available.

IF(CMAKE_COMPILER_IS_GNUCXX)

		# To be complete, we might also do GNUCC flags,

		# but everything here is C++ code.

		# -Wshadow and -Woverloaded-virtual are also interesting flags, but OSG

		# returns too many hits.

		# FYI, if we do implement GNUCC, then -Wmissing-prototypes in another

		# interesting C-specific flag.

		# Also, there is a bug in gcc 4.0. Under C++, -pedantic will create

		# errors instead of warnings for certain issues, including superfluous

		# semicolons and commas, and the use of long long. -fpermissive seems

		# to be the workaround.

		SET(AGGRESSIVE_WARNING_FLAGS "-Wall -Wparentheses -Wformat=2 -Wno-long-long -Wno-import -pedantic -Wreturn-type -Wmissing-braces -Wunknown-pragmas -Wunused -fpermissive")

ELSE(CMAKE_COMPILER_IS_GNUCXX)

		IF(MSVC)

				# FIXME: What are good aggressive warning flags for Visual Studio?

				# And do we need to further subcase this for different versions of VS?

				# CMake variables: MSVC60, MSVC70, MSVC71, MSVC80, CMAKE_COMPILER_2005

				SET(AGGRESSIVE_WARNING_FLAGS "/Wall /W4")

		ELSE(MSVC)

				# CMake lacks an elseif, so other non-gcc, non-VS compilers need

				# to be listed below. If unhandled, OSG_AGGRESSIVE_WARNING_FLAGS should

				# remain unset.

		ENDIF(MSVC)

ENDIF(CMAKE_COMPILER_IS_GNUCXX)

# This part is for the CMake menu option to toggle the warnings on/off.

# This will only be made available if we set values for OSG_AGGRESSIVE_WARNING_FLAGS.

IF(AGGRESSIVE_WARNING_FLAGS)

		OPTION(USE_AGGRESSIVE_WARNINGS "Enable to activate aggressive warnings" OFF)

		MARK_AS_ADVANCED(USE_AGGRESSIVE_WARNINGS)

		IF(USE_AGGRESSIVE_WARNINGS)

				IF(NOT "${OLD_CMAKE_CXX_FLAGS_WAS_SET}")

						SET(OLD_CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE INTERNAL "Old CXX flags")

						SET(OLD_CMAKE_CXX_FLAGS_WAS_SET 1 CACHE INTERNAL "Old CXX flags was set")

						SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${AGGRESSIVE_WARNING_FLAGS}" CACHE STRING "Flags used by the compiler during all build types." FORCE)

				ENDIF(NOT "${OLD_CMAKE_CXX_FLAGS_WAS_SET}")

		ELSE(USE_AGGRESSIVE_WARNINGS)

				# FIXME: This will lose any changes made after OLD_CMAKE_CXX_FLAGS was

				# set. The better way would be to parse the string and remove each

				# option explicitly.

				IF("${OLD_CMAKE_CXX_FLAGS_WAS_SET}")

						SET(CMAKE_CXX_FLAGS "${OLD_CMAKE_CXX_FLAGS}" CACHE STRING "Flags used by the compiler during all build types." FORCE)

						SET(OLD_CMAKE_CXX_FLAGS_WAS_SET 0 CACHE INTERNAL "Old CXX flags was set")

				ENDIF("${OLD_CMAKE_CXX_FLAGS_WAS_SET}")

		ENDIF(USE_AGGRESSIVE_WARNINGS)

ENDIF(AGGRESSIVE_WARNING_FLAGS)

# Set defaults for Universal Binaries. We want 32-bit Intel/PPC on 10.4

# and 32/64-bit Intel/PPC on >= 10.5. Anything <= 10.3 doesn't support.

IF(APPLE)

		# These are just defaults/recommendations, but how we want to build

		# out of the box. But the user needs to be able to change these options.

		# So we must only set the values the first time CMake is run, or we

		# will overwrite any changes the user sets.

		# FORCE is used because the options are not reflected in the UI otherwise.

		# Seems like a good place to add version specific compiler flags too.

		IF(NOT CONFIG_HAS_BEEN_RUN_BEFORE)

				# This is really fragile, but CMake doesn't provide the OS system

				# version information we need. (Darwin versions can be changed

				# independently of OS X versions.)

				# It does look like CMake handles the CMAKE_OSX_SYSROOT automatically.

				IF(EXISTS /Developer/SDKs/10.5.sdk)

						SET(CMAKE_OSX_ARCHITECTURES "ppc;i386;ppc64;x86_64" CACHE STRING "Build architectures for OSX" FORCE)

						SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.5 -ftree-vectorize -fvisibility-inlines-hidden" CACHE STRING "Flags used by the compiler during all build types." FORCE)

				ELSE(EXISTS /Developer/SDKs/10.5.sdk)

						IF(EXISTS /Developer/SDKs/MacOSX10.4u.sdk)

								SET(CMAKE_OSX_ARCHITECTURES "ppc;i386" CACHE STRING "Build architectures for OSX" FORCE)

								SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.4 -ftree-vectorize -fvisibility-inlines-hidden" CACHE STRING "Flags used by the compiler during all build types." FORCE)

						ELSE(EXISTS /Developer/SDKs/MacOSX10.4u.sdk)

								# No Universal Binary support

								# Should break down further to set the -mmacosx-version-min,

								# but the SDK detection is too unreliable here.

						ENDIF(EXISTS /Developer/SDKs/MacOSX10.4u.sdk)

				ENDIF(EXISTS /Developer/SDKs/10.5.sdk)

		ENDIF(NOT CONFIG_HAS_BEEN_RUN_BEFORE)

ENDIF(APPLE)

SET(JPOTRACE_VERSION "0.0.1" CACHE STRING "JPOTRACE_VERSION")

FIND_PACKAGE(JNI)

FIND_PACKAGE(POTRACE)

link_directories(${LIBRARY_OUTPUT_PATH})

add_subdirectory(src/main/native/jpotrace)

# This needs to be run very last so other parts of the scripts can take

# advantage of this.

IF(NOT CONFIG_HAS_BEEN_RUN_BEFORE)

		SET(CONFIG_HAS_BEEN_RUN_BEFORE 1 CACHE INTERNAL "Flag to track whether this is the first time running CMake or if CMake has been configured before")

ENDIF(NOT CONFIG_HAS_BEEN_RUN_BEFORE)