OPTION(K3D_INSTALL_AQSIS "Include Aqsis in the K-3D installer" OFF)
OPTION(K3D_INSTALL_BOOST "Include Boost in the K-3D installer" OFF)
OPTION(K3D_INSTALL_CGKIT "Include cgkit in the K-3D installer" OFF)
OPTION(K3D_INSTALL_GTKMM "Include gtkmm in the K-3D installer" OFF)
OPTION(K3D_INSTALL_PYGTK "Include PyGTK in the K-3D installer" OFF)
OPTION(K3D_INSTALL_PYOPENGL "Include PyOpenGL in the K-3D installer" OFF)
OPTION(K3D_INSTALL_PYTHON "Include Python in the K-3D installer" OFF)

K3D_CHECK_INSTALLED_PYTHON_DEPENDENCY(K3D_INSTALL_CGKIT)
K3D_CHECK_INSTALLED_PYTHON_DEPENDENCY(K3D_INSTALL_PYGTK)
K3D_CHECK_INSTALLED_PYTHON_DEPENDENCY(K3D_INSTALL_PYOPENGL)

#install mingwm10.dll
FIND_PROGRAM(K3D_MINGW_GCC mingw32-gcc.exe
	C:/mingw/bin
	DOC "Path to the MinGW GCC command")
MARK_AS_ADVANCED(K3D_MINGW_GCC)

GET_FILENAME_COMPONENT(K3D_MINGW_PATH ${K3D_MINGW_GCC} PATH)
INSTALL(FILES ${K3D_MINGW_PATH}/mingwm10.dll DESTINATION bin)

IF(K3D_INSTALL_AQSIS)
	FIND_PROGRAM(K3D_AQSIS_COMMAND aqsis.exe
		DOC "Path to an installed aqsis.exe."
		)
	MARK_AS_ADVANCED(K3D_AQSIS_COMMAND)

	IF(NOT K3D_AQSIS_COMMAND)
		MESSAGE(SEND_ERROR "Could not locate aqsis.exe.")
	ENDIF(NOT K3D_AQSIS_COMMAND)

	IF(NOT K3D_BUILD_BUNDLED_RENDERMAN_ENGINES_MODULE)
		MESSAGE(SEND_ERROR "K3D_INSTALL_AQSIS requires K3D_BUILD_BUNDLED_RENDERMAN_ENGINES_MODULE")
	ENDIF(NOT K3D_BUILD_BUNDLED_RENDERMAN_ENGINES_MODULE)

	EXECUTE_PROCESS(
		COMMAND ${K3D_AQSIS_COMMAND} --version
		OUTPUT_VARIABLE K3D_AQSIS_VERSION
		)
	IF(K3D_AQSIS_VERSION)
		STRING(REGEX REPLACE " \\(revision.*" "" K3D_AQSIS_VERSION ${K3D_AQSIS_VERSION})
		STRING(REGEX REPLACE "aqsis version " "" K3D_AQSIS_VERSION ${K3D_AQSIS_VERSION})
		K3D_CHECK_INSTALLED_VERSION(${K3D_AQSIS_VERSION} "Aqsis" "1.6.0")
	ELSE(K3D_AQSIS_VERSION)
		MESSAGE(SEND_ERROR "Error determining Aqsis version.")
	ENDIF(K3D_AQSIS_VERSION)

	GET_FILENAME_COMPONENT(K3D_AQSIS_PATH ${K3D_AQSIS_COMMAND} PATH)
	INSTALL(DIRECTORY ${K3D_AQSIS_PATH}/ DESTINATION bin
	    USE_SOURCE_PERMISSIONS
	    PATTERN aqsisrc EXCLUDE
		)
	# Install generic aqsisrc, omitting paths (those are set at runtime through command line options)
	INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/aqsisrc DESTINATION bin)
	#install msvcrt, needed since aqsis 1.4
	FIND_PROGRAM(VCREDIST_X86_2005 vcredist_x86_2005.exe DOC "Path to the Visual Studio C++ 2005 SP1 redistributable")
	INSTALL(FILES ${VCREDIST_X86_2005} DESTINATION redist)
	SET(CPACK_NSIS_EXTRA_INSTALL_COMMANDS
		"ExecWait '\\\"$INSTDIR\\\\redist\\\\vcredist_x86_2005.exe\\\"'")
ENDIF(K3D_INSTALL_AQSIS)

IF(K3D_INSTALL_BOOST)
	set(aPrevBoostLib "")
    foreach(aBoostLib ${Boost_LIBRARIES})
        if(NOT (aBoostLib STREQUAL "debug" OR aBoostLib STREQUAL "optimized" OR aPrevBoostLib STREQUAL "debug"))
            INSTALL(FILES ${aBoostLib} DESTINATION bin)
        endif()
        set(aPrevBoostLib ${aBoostLib})
    endforeach(aBoostLib)
ENDIF(K3D_INSTALL_BOOST)

IF(K3D_BUILD_COLLADA_IO_MODULE)
    INSTALL(FILES ${K3D_COLLADA_LIBRARY} DESTINATION bin)
ENDIF(K3D_BUILD_COLLADA_IO_MODULE)

IF(K3D_INSTALL_GTKMM)
	INCLUDE(K3DFindPkgConfig)
	
	PKG_CHECK_MODULES(ATK atk)
	PKG_CHECK_MODULES(ATKMM atkmm-1.6)
	PKG_CHECK_MODULES(CAIRO cairo)
	PKG_CHECK_MODULES(CAIROMM cairomm-1.0)
	PKG_CHECK_MODULES(GDK gdk-2.0)
	PKG_CHECK_MODULES(GDKGLEXT gdkglext-1.0)
	PKG_CHECK_MODULES(GDKGLEXTW gdkglext-win32-1.0)
	PKG_CHECK_MODULES(GDKMM gdkmm-2.4)
	PKG_CHECK_MODULES(GTK gtk+-2.0)
	PKG_CHECK_MODULES(GTKMM gtkmm-2.4)

	K3D_CHECK_INSTALLED_VERSION(${ATK_VERSION} "atk" "1.24.0")
	K3D_CHECK_INSTALLED_VERSION(${ATKMM_VERSION} "atkmm" "2.14.3")
	K3D_CHECK_INSTALLED_VERSION(${CAIRO_VERSION} "cairo" "1.8.6")
	K3D_CHECK_INSTALLED_VERSION(${CAIROMM_VERSION} "cairomm" "1.8.0")
	K3D_CHECK_INSTALLED_VERSION(${GDK_VERSION} "gdk" "2.14.7")
	K3D_CHECK_INSTALLED_VERSION(${GDKGLEXT_VERSION} "gdkglext" "1.2.0")
	K3D_CHECK_INSTALLED_VERSION(${GDKGLEXTW_VERSION} "gdkglext-win32" "1.2.0")
	K3D_CHECK_INSTALLED_VERSION(${GDKMM_VERSION} "gdkmm" "2.14.3")
	K3D_CHECK_INSTALLED_VERSION(${GTK_VERSION} "gtk" "2.14.7")
	K3D_CHECK_INSTALLED_VERSION(${GTKMM_VERSION} "gtkmm" "2.14.3")

	# This is an ugly hack, we should be able to detect this automatically, but I'm feeling lazy ...
	SET(K3D_GTK_DIR "c:/gtk" CACHE PATH "Root directory containing GTK/gtkmm")
	MARK_AS_ADVANCED(K3D_GTK_DIR)

	INSTALL(DIRECTORY ${K3D_GTK_DIR}/bin/ DESTINATION bin
		USE_SOURCE_PERMISSIONS
		PATTERN *.pdb EXCLUDE
		PATTERN *-config EXCLUDE
		PATTERN *glade* EXCLUDE
		PATTERN *xml++* EXCLUDE
		PATTERN atkmm-1.6d.dll EXCLUDE
		PATTERN gdkmm-2.4d.dll EXCLUDE
		PATTERN gettext.sh EXCLUDE
		PATTERN glib-gettextize EXCLUDE
		PATTERN glib-mkenums EXCLUDE
		PATTERN glibmm-2.4d.dll EXCLUDE
		PATTERN gtkaio.sh EXCLUDE
		PATTERN gtkautogen EXCLUDE
		PATTERN gtkconfigure EXCLUDE
		PATTERN gtkmm-2.4d.dll EXCLUDE
		PATTERN msg*.exe EXCLUDE
		PATTERN pangomm-1.4d.dll EXCLUDE
		PATTERN sigc-2.0d.dll EXCLUDE
		)

	INSTALL(DIRECTORY ${K3D_GTK_DIR}/etc/ DESTINATION etc
		USE_SOURCE_PERMISSIONS
		)

	INSTALL(DIRECTORY ${K3D_GTK_DIR}/lib/ DESTINATION ${K3D_LIBDIR}
		USE_SOURCE_PERMISSIONS
		PATTERN *.a EXCLUDE
		PATTERN *.lib EXCLUDE
		PATTERN *.pdb EXCLUDE
		PATTERN *glade* EXCLUDE
		PATTERN gdkmm-2.4 EXCLUDE
		PATTERN glib-2.0 EXCLUDE
		PATTERN glibmm-2.4 EXCLUDE
		PATTERN gtkglext-1.0 EXCLUDE
		PATTERN gtkmm-2.4 EXCLUDE
		PATTERN include EXCLUDE
		PATTERN libxml++-2.6 EXCLUDE
		PATTERN pkgconfig EXCLUDE
		PATTERN sigc++-2.0 EXCLUDE
		)

	# Override the default gtkrc file with our own
	INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/gtkrc DESTINATION etc/gtk-2.0)
ENDIF(K3D_INSTALL_GTKMM)

IF(K3D_INSTALL_PYTHON)
	FIND_PROGRAM(K3D_PYTHON_COMMAND python.exe
		PATHS "c:/python26"
		DOC "Path to an installed python.exe."
		)
	MARK_AS_ADVANCED(K3D_PYTHON_COMMAND)
	
	IF(NOT K3D_PYTHON_COMMAND)
		MESSAGE(SEND_ERROR "Could not locate python.exe.")
	ENDIF(NOT K3D_PYTHON_COMMAND)

	FIND_PROGRAM(K3D_PYTHON_LIBRARY python26.dll
		DOC "Path to the installed python26.dll"
		)
	MARK_AS_ADVANCED(K3D_PYTHON_LIBRARY)

	IF(NOT K3D_PYTHON_LIBRARY)
		MESSAGE(SEND_ERROR "Could not locate python26.dll.")
	ENDIF(NOT K3D_PYTHON_LIBRARY)

	EXECUTE_PROCESS(
		COMMAND ${K3D_PYTHON_COMMAND} -V
		ERROR_VARIABLE K3D_PYTHON_VERSION
		)

	IF(K3D_PYTHON_VERSION)
		STRING(REGEX REPLACE "^Python ([0-9]+\\.[0-9]+\\.[0-9]+).*" "\\1" K3D_PYTHON_VERSION ${K3D_PYTHON_VERSION})
		K3D_CHECK_INSTALLED_VERSION(${K3D_PYTHON_VERSION} "Python" "2.6.1")
	ELSE(K3D_PYTHON_VERSION)
		MESSAGE(SEND_ERROR "Error determining Python version.")
	ENDIF(K3D_PYTHON_VERSION)

	INSTALL(PROGRAMS
		${K3D_PYTHON_COMMAND}
		${K3D_PYTHON_LIBRARY}
		DESTINATION bin
		)

	GET_FILENAME_COMPONENT(K3D_PYTHON_PATH ${K3D_PYTHON_COMMAND} PATH)
	FILE(GLOB K3D_PYTHON_MODULES ${K3D_PYTHON_PATH}/Lib/*.py)
	INSTALL(PROGRAMS
		${K3D_PYTHON_MODULES}
		DESTINATION ${K3D_LIBDIR}
		)

	SET(K3D_PYTHON_SITE_PACKAGES ${K3D_PYTHON_PATH}/Lib/site-packages)

	IF(K3D_INSTALL_CGKIT)
		EXECUTE_PROCESS(
			COMMAND ${K3D_PYTHON_COMMAND} -c "import cgkit.cgkitinfo;print cgkit.cgkitinfo.version"
			OUTPUT_VARIABLE K3D_CGKIT_VERSION
			)

		IF(K3D_CGKIT_VERSION)
			STRING(REGEX REPLACE "^([0-9]+\\.[0-9]+\\.[0-9]+[^ ]*).*" "\\1" K3D_CGKIT_VERSION ${K3D_CGKIT_VERSION})
			K3D_CHECK_INSTALLED_VERSION(${K3D_CGKIT_VERSION} "cgkit" "2.0.0alpha8")
		ELSE(K3D_CGKIT_VERSION)
			MESSAGE(SEND_ERROR "Error determining cgkit version.")
		ENDIF(K3D_CGKIT_VERSION)

		INSTALL(DIRECTORY
			${K3D_PYTHON_SITE_PACKAGES}/cgkit
			DESTINATION ${K3D_LIBDIR}/site-packages
			PATTERN *.pyc EXCLUDE
			PATTERN *.pyo EXCLUDE
			)
	ENDIF(K3D_INSTALL_CGKIT)

	IF(K3D_INSTALL_PYGTK)
		EXECUTE_PROCESS(
			COMMAND ${K3D_PYTHON_COMMAND} -c "import gtk;print gtk.pygtk_version"
			OUTPUT_VARIABLE K3D_PYGTK_VERSION
			)

		IF(K3D_PYGTK_VERSION)
			STRING(REGEX REPLACE ".*([0-9]+), ([0-9]+), ([0-9]+).*" "\\1.\\2.\\3" K3D_PYGTK_VERSION ${K3D_PYGTK_VERSION})
			K3D_CHECK_INSTALLED_VERSION(${K3D_PYGTK_VERSION} "PyGTK" "2.12.1")
		ELSE(K3D_PYGTK_VERSION)
			MESSAGE(SEND_ERROR "Error determining PyGTK version.")
		ENDIF(K3D_PYGTK_VERSION)

		INSTALL(DIRECTORY
			${K3D_PYTHON_SITE_PACKAGES}/cairo
			DESTINATION ${K3D_LIBDIR}/site-packages
			PATTERN *.pyc EXCLUDE
			PATTERN *.pyo EXCLUDE
			)
		INSTALL(DIRECTORY
			${K3D_PYTHON_SITE_PACKAGES}/gtk-2.0
			DESTINATION ${K3D_LIBDIR}/site-packages
			PATTERN *.pyc EXCLUDE
			PATTERN *.pyo EXCLUDE
			)
		INSTALL(PROGRAMS
			${K3D_PYTHON_SITE_PACKAGES}/pygtk.py
			DESTINATION ${K3D_LIBDIR}/site-packages
			)
	ENDIF(K3D_INSTALL_PYGTK)

	IF(K3D_INSTALL_PYOPENGL)
		EXECUTE_PROCESS(
			COMMAND ${K3D_PYTHON_COMMAND} -c "import OpenGL.version;print OpenGL.version.__version__"
			OUTPUT_VARIABLE K3D_PYOPENGL_VERSION
			)
		IF(K3D_PYOPENGL_VERSION)
			STRING(REGEX REPLACE "^([0-9]+\\.[0-9]+\\.[0-9]+).*" "\\1" K3D_PYOPENGL_VERSION ${K3D_PYOPENGL_VERSION})
			K3D_CHECK_INSTALLED_VERSION(${K3D_PYOPENGL_VERSION} "PyOpenGL" "3.0.0")
		ELSE(K3D_PYOPENGL_VERSION)
			MESSAGE(SEND_ERROR "Error determining PyOpenGL version.")
		ENDIF(K3D_PYOPENGL_VERSION)

		INSTALL(DIRECTORY
			${K3D_PYTHON_SITE_PACKAGES}/OpenGL
			DESTINATION ${K3D_LIBDIR}/site-packages
			PATTERN *.pyc EXCLUDE
			PATTERN *.pyo EXCLUDE
			)
	ENDIF(K3D_INSTALL_PYOPENGL)

	#Needed for Python 2.6
	FIND_PROGRAM(VCREDIST_X86_2008 vcredist_x86_2008.exe DOC "Path to the Visual Studio C++ 2008 SP1 redistributable")
	INSTALL(FILES ${VCREDIST_X86_2008} DESTINATION redist)
	SET(CPACK_NSIS_EXTRA_INSTALL_COMMANDS
		"${CPACK_NSIS_EXTRA_INSTALL_COMMANDS}
			ExecWait '\\\"$INSTDIR\\\\redist\\\\vcredist_x86_2008.exe\\\"'")

ENDIF(K3D_INSTALL_PYTHON)

ADD_SUBDIRECTORY(nsis)

