# create the VTK/Ruby  executable
CONFIGURE_FILE(${VTK_SOURCE_DIR}/Wrapping/Ruby/vtkRubyAppInitConfigure.h.in
               ${VTK_BINARY_DIR}/Wrapping/Ruby/vtkRubyAppInitConfigure.h)

ADD_EXECUTABLE(vtkruby vtkRubyAppInit.cxx)
IF(CMAKE_SYSTEM_NAME MATCHES "AIX")
  GET_FILENAME_COMPONENT(CMAKE_RUBY_LIB_PREFIX "${RUBY_LIBRARY}" PATH)
  FIND_FILE(CMAKE_RUBY_LIBRARY_EXPORT ruby.exp "${CMAKE_RUBY_LIB_PREFIX}")
  SET_TARGET_PROPERTIES( vtkruby PROPERTIES LINK_FLAGS
    "-Wl,-bE:${CMAKE_RUBY_LIBRARY_EXPORT}")
ENDIF(CMAKE_SYSTEM_NAME MATCHES "AIX")

IF(VTK_USE_CARBON)
  FIND_PROGRAM(VTK_APPLE_RESOURCE Rez /Developer/Tools)
  IF(VTK_APPLE_RESOURCE)
    ADD_CUSTOM_COMMAND(
      SOURCE vtkruby
      COMMAND ${VTK_APPLE_RESOURCE}
      ARGS Carbon.r -o ${VTK_EXECUTABLE_DIR}/vtkruby
      TARGET vtkruby
      )
  ENDIF(VTK_APPLE_RESOURCE)
ENDIF(VTK_USE_CARBON)


IF (APPLE)
  SET_TARGET_PROPERTIES(vtkruby PROPERTIES LINK_FLAGS "-flat_namespace -undefined suppress -u _RuMac_Error")
ENDIF (APPLE)

# Link against all the kit wrappers.
TARGET_LINK_LIBRARIES(vtkruby
  ${VTK_RUBY_LIBRARIES}
  vtksys
  vtkCommon
  vtkFiltering
  vtkIO
  vtkGraphics
  vtkImaging)

SET (vtkruby_install_depends
    vtkCommonRuby
    vtkFilteringRuby
    vtkIORuby
    vtkGraphicsRuby
    vtkImagingRuby
    )

IF(VTK_WRAP_TCL)
  TARGET_LINK_LIBRARIES(vtkruby ${VTK_TK_LIBRARIES})
ENDIF(VTK_WRAP_TCL)

IF(BORLAND)
  SET(KITS Common Filtering Graphics IO Imaging)
  IF (VTK_USE_PARALLEL)
    SET(KITS ${KITS} Parallel)
  ENDIF(VTK_USE_PARALLEL)
  IF (VTK_USE_RENDERING)
    SET(KITS ${KITS} Widgets)
    SET(KITS ${KITS} Hybrid)
    SET(KITS ${KITS} VolumeRendering)
    SET(KITS ${KITS} Rendering)
  ENDIF(VTK_USE_RENDERING)
  FOREACH(KIT ${KITS})
    WRITE_FILE(${LIBRARY_OUTPUT_PATH}/vtk${KIT}Ruby.def
               "EXPORTS\ninitvtk${KIT}Ruby=_initvtk${KIT}Ruby\n")
  ENDFOREACH(KIT)
ENDIF(BORLAND)


IF (VTK_USE_RENDERING)
  TARGET_LINK_LIBRARIES(vtkruby vtkRendering)
  TARGET_LINK_LIBRARIES(vtkruby vtkVolumeRendering)
  TARGET_LINK_LIBRARIES(vtkruby vtkHybrid)
  TARGET_LINK_LIBRARIES(vtkruby vtkWidgets)
   SET (vtkruby_install_depends
       ${vtkruby_install_depends}
       vtkRenderingRuby
       vtkVolumeRenderingRuby
       vtkHybridRuby
       vtkWidgetsRuby
       )
ENDIF (VTK_USE_RENDERING)

IF (VTK_USE_PARALLEL)
  TARGET_LINK_LIBRARIES(vtkruby vtkParallel)
   SET(vtkruby_install_depends
      ${vtkruby_install_depends}
      vtkParallelRuby
      )
ENDIF (VTK_USE_PARALLEL)

# Link to rt to prevent undefined symbol 'fdatasync'

IF(CMAKE_SYSTEM MATCHES "SunOS.*")
  IF(NOT CMAKE_COMPILER_IS_GNUCXX)
    FIND_LIBRARY(VTK_SUNCC_RT_LIBRARY rt /usr/lib)
    IF(VTK_SUNCC_RT_LIBRARY)
      TARGET_LINK_LIBRARIES(vtkruby ${VTK_SUNCC_RT_LIBRARY})
    ENDIF(VTK_SUNCC_RT_LIBRARY)
  ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX)
ENDIF(CMAKE_SYSTEM MATCHES "SunOS.*")

# Create the pvtkruby Ruby wrapper executable with MPI support.
IF (VTK_USE_PARALLEL)
  IF (VTK_USE_MPI)
    ADD_EXECUTABLE(pvtkruby vtkParaRubyAppInit.cxx)
    IF(CMAKE_SYSTEM_NAME MATCHES "AIX")
      SET_TARGET_PROPERTIES( pvtkruby PROPERTIES LINK_FLAGS
        "-Wl,-bE:${CMAKE_RUBY_LIBRARY_EXPORT}")
    ENDIF(CMAKE_SYSTEM_NAME MATCHES "AIX")
    IF(VTK_USE_CARBON)
      FIND_PROGRAM(VTK_APPLE_RESOURCE Rez /Developer/Tools)
      IF(VTK_APPLE_RESOURCE)
        ADD_CUSTOM_COMMAND(
          SOURCE pvtkruby
          COMMAND ${VTK_APPLE_RESOURCE}
          ARGS Carbon.r -o ${VTK_EXECUTABLE_DIR}/pvtkruby
          TARGET pvtkruby
          )
      ENDIF(VTK_APPLE_RESOURCE)
    ENDIF(VTK_USE_CARBON)

    TARGET_LINK_LIBRARIES (pvtkruby
      ${VTK_RUBY_LIBRARIES}
      vtksys
      vtkCommon
      vtkFiltering
      vtkIO
      vtkGraphics
      vtkImaging
      vtkParallel
    )
    IF (VTK_USE_RENDERING)
      TARGET_LINK_LIBRARIES(pvtkruby vtkVolumeRendering)
      TARGET_LINK_LIBRARIES(pvtkruby vtkHybrid)
      TARGET_LINK_LIBRARIES(pvtkruby vtkWidgets)
    ENDIF (VTK_USE_RENDERING)
    IF(NOT VTK_INSTALL_NO_RUNTIME)
      INSTALL_TARGETS(${VTK_INSTALL_BIN_DIR} pvtkruby)
    ENDIF(NOT VTK_INSTALL_NO_RUNTIME)
  ENDIF (VTK_USE_MPI)
ENDIF (VTK_USE_PARALLEL)

IF(NOT VTK_INSTALL_NO_RUNTIME)
  INSTALL_TARGETS(${VTK_INSTALL_BIN_DIR} vtkruby)
ENDIF(NOT VTK_INSTALL_NO_RUNTIME)

# Handle out-of-source builds correctly.
#
#  1. Create a list of Ruby files to be installed/copied.
#  2. Copy them to ruby directory
#
# *** Step 1 has to be done carefully to avoid missing out files ***

IF(RUBY_EXECUTABLE)
# Make the necessary directories.
  FOREACH(dir
    ${VTK_BINARY_DIR}/Wrapping/Ruby/vtk/tk
    ${VTK_BINARY_DIR}/Wrapping/Ruby/vtk/gtk
    ${VTK_BINARY_DIR}/Wrapping/Ruby/vtk/util
    )
    MAKE_DIRECTORY(${dir})
  ENDFOREACH(dir)

# Now create a list of Ruby files.

# vtk/util package
  SET(VTK_RUBY_FILES
    vtk
    vtk/common
    vtk/filtering
    vtk/genericfiltering
    vtk/graphics
    vtk/hybrid
    vtk/imaging
    vtk/io
    vtk/parallel
    vtk/rendering
    vtk/volumerendering
    vtk/widgets
  )

  SET(VTK_RUBY_FILES
    ${VTK_RUBY_FILES}
    vtk/util
    vtk/util/misc
    vtk/util/vtkConstants
    vtk/util/vtkImageExportToArray
    vtk/util/vtkImageImportFromArray
    vtk/util/colors
    )

# vtk/gtk package
  SET(VTK_RUBY_FILES
    ${VTK_RUBY_FILES}
    vtk/gtk
    vtk/gtk/GtkVTKRenderWindow
    vtk/gtk/GtkVTKRenderWindowInteractor
    vtk/gtk/GtkGLExtVTKRenderWindow
    vtk/gtk/GtkGLExtVTKRenderWindowInteractor
    )

# vtk/ttk package
  SET(VTK_RUBY_FILES
    ${VTK_RUBY_FILES}
    vtk/tk
    vtk/tk/vtkLoadRubyTkWidgets
    vtk/tk/vtkTkRenderWidget
    vtk/tk/vtkTkRenderWindowInteractor
    vtk/tk/vtkTkImageViewerWidget
    vtk/tk/vtkTkPhotoImage
    )

# Done listing of files.

# Now copy these files if necessary.
  SET(VTK_RUBY_SOURCE_FILES)
  SET(VTK_RUBY_OUTPUT_FILES)
  FOREACH(file ${VTK_RUBY_FILES})
    SET(src "${VTK_BINARY_DIR}/Wrapping/Ruby/${file}.rb")
    SET(VTK_RUBY_SOURCE_FILES ${VTK_RUBY_SOURCE_FILES} ${src})
  ENDFOREACH(file)

  IF ("${VTK_BINARY_DIR}" MATCHES "^${VTK_SOURCE_DIR}$")
    #MESSAGE("In source build -- no need to copy Ruby files")
  ELSE ("${VTK_BINARY_DIR}" MATCHES "^${VTK_SOURCE_DIR}$")
    FOREACH(file ${VTK_RUBY_FILES})
      SET(src "${VTK_SOURCE_DIR}/Wrapping/Ruby/${file}.rb")
      SET(tgt "${VTK_BINARY_DIR}/Wrapping/Ruby/${file}.rb")
      ADD_CUSTOM_COMMAND(DEPENDS ${src}
                         COMMAND ${CMAKE_COMMAND}
                         ARGS -E copy ${src} ${tgt}
                         OUTPUT ${tgt}
                         COMMENT "source copy")
    ENDFOREACH(file)
  ENDIF ("${VTK_BINARY_DIR}" MATCHES "^${VTK_SOURCE_DIR}$")

  # Dummy command
  IF ("${VTK_BINARY_DIR}" MATCHES "^${VTK_SOURCE_DIR}$")
  ELSE ("${VTK_BINARY_DIR}" MATCHES "^${VTK_SOURCE_DIR}$")
    SET(src "${VTK_SOURCE_DIR}/Wrapping/Ruby/vtk_dummy.rb")
    SET(tgt "${VTK_BINARY_DIR}/Wrapping/Ruby/vtk_dummy.rb")
    ADD_CUSTOM_COMMAND(DEPENDS ${src}
                       COMMAND ${CMAKE_COMMAND}
                       ARGS -E copy ${src} ${tgt}
                       OUTPUT ${tgt}
                       COMMENT "vtk_dummy.rb copy")
  ENDIF ("${VTK_BINARY_DIR}" MATCHES "^${VTK_SOURCE_DIR}$")
  ADD_CUSTOM_COMMAND(
    COMMAND ${RUBY_EXECUTABLE}
    ARGS ${VTK_BINARY_DIR}/Wrapping/Ruby/vtk_dummy.rb
    DEPENDS ${VTK_RUBY_SOURCE_FILES} ${VTK_BINARY_DIR}/Wrapping/Ruby/vtk_dummy.rb
    OUTPUT "${VTK_BINARY_DIR}/Wrapping/Ruby/vtk_dummy_complete"
    )
  ADD_CUSTOM_TARGET(vtkruby_install ALL echo "..."
    DEPENDS "${VTK_BINARY_DIR}/Wrapping/Ruby/vtk_dummy_complete")
  ADD_DEPENDENCIES(vtkruby_install
      vtkruby
      ${vtkruby_install_depends})

  # If no runtime is to be installed then do not install ruby modules.
  IF(VTK_INSTALL_NO_RUNTIME)
    SET(VTK_INSTALL_NO_RUBY 1)
  ENDIF(VTK_INSTALL_NO_RUNTIME)

  # Add a rule to use ruby distutils to install the ruby wrappers.
  IF(NOT VTK_INSTALL_NO_RUBY)
    SET(DOLLAR "$")

    # Create default python setup arguments if they are not set.
    IF(DEFINED VTK_RUBY_SETUP_ARGS)
    ELSE(DEFINED VTK_RUBY_SETUP_ARGS)
      SET(VTK_RUBY_SETUP_ARGS "--prefix=\"\""
        CACHE STRING "Arguments passed to \"ruby setup.rb install ...\" during installation.")
      MARK_AS_ADVANCED(VTK_RUBY_SETUP_ARGS)
    ENDIF(DEFINED VTK_RUBY_SETUP_ARGS)

    IF(DEFINED VTK_RUBY_LIB_DIR)
    ELSE(DEFINED VTK_RUBY_LIB_DIR)
      SET(VTK_RUBY_LIB_DIR "")
      MARK_AS_ADVANCED(VTK_RUBY_LIB_DIR)
    ENDIF(DEFINED VTK_RUBY_LIB_DIR)

    IF(DEFINED VTK_RUBY_ARCH_DIR)
    ELSE(DEFINED VTK_RUBY_ARCH_DIR)
      SET(VTK_RUBY_ARCH_DIR "")
      MARK_AS_ADVANCED(VTK_RUBY_ARCH_DIR)
    ENDIF(DEFINED VTK_RUBY_ARCH_DIR)

    # If there are multiple configurations then add a BUILD_TYPE=...
    # argument to the ruby setup.rb call.  The build type to use is set
    # in the CMake variable BUILD_TYPE while running the install script.
    IF(CMAKE_CONFIGURATION_TYPES)
      SET(VTK_RUBY_SETUP_BUILD_TYPE "BUILD_TYPE=${DOLLAR}{BUILD_TYPE}")
    ELSE(CMAKE_CONFIGURATION_TYPES)
      SET(VTK_RUBY_SETUP_BUILD_TYPE)
    ENDIF(CMAKE_CONFIGURATION_TYPES)


    # Configure the post-install script to run ruby on setup.rb.
    CONFIGURE_FILE(${VTK_SOURCE_DIR}/Wrapping/Ruby/RubyInstall.cmake.in
                   ${VTK_BINARY_DIR}/Wrapping/Ruby/RubyInstall.cmake
                   @ONLY IMMEDIATE)
    SET_TARGET_PROPERTIES(vtkruby_install PROPERTIES POST_INSTALL_SCRIPT
      ${VTK_BINARY_DIR}/Wrapping/Ruby/RubyInstall.cmake
      )



  ENDIF(NOT VTK_INSTALL_NO_RUBY)
ENDIF(RUBY_EXECUTABLE)


# Create the setup.rb file.
IF(CMAKE_CONFIGURATION_TYPES)
  # The build has multiple configuration types.  If CMAKE_BUILD_TYPE
  # is set use it as the default BUILD_TYPE for setup.rb to install.
  SET(VTK_RUBY_HAS_CONFIG_TYPES 1)
  IF(CMAKE_BUILD_TYPE)
    SET(VTK_RUBY_BUILD_TYPE "\"${CMAKE_BUILD_TYPE}\"")
  ELSE(CMAKE_BUILD_TYPE)
    SET(VTK_RUBY_BUILD_TYPE "[]")
  ENDIF(CMAKE_BUILD_TYPE)
ELSE(CMAKE_CONFIGURATION_TYPES)
  # The build has one configuration type.  The build type does not
  # affect installation.
  SET(VTK_RUBY_HAS_CONFIG_TYPES 0)
  SET(VTK_RUBY_BUILD_TYPE "[]")
ENDIF(CMAKE_CONFIGURATION_TYPES)
IF(VTK_USE_RENDERING)
  SET(VTK_RUBY_USE_RENDERING 1)
ELSE(VTK_USE_RENDERING)
  SET(VTK_RUBY_USE_RENDERING 0)
ENDIF(VTK_USE_RENDERING)
IF(VTK_USE_PARALLEL)
  SET(VTK_RUBY_USE_PARALLEL 1)
ELSE(VTK_USE_PARALLEL)
  SET(VTK_RUBY_USE_PARALLEL 0)
ENDIF(VTK_USE_PARALLEL)
IF(VTK_USE_MPI)
  SET(VTK_RUBY_USE_MPI 1)
ELSE(VTK_USE_MPI)
  SET(VTK_RUBY_USE_MPI 0)
ENDIF(VTK_USE_MPI)
CONFIGURE_FILE(${VTK_SOURCE_DIR}/Wrapping/Ruby/setup.rb.in
               ${VTK_BINARY_DIR}/Wrapping/Ruby/setup.rb @ONLY IMMEDIATE)


# Allow the user to customize their build with some local options
#
INCLUDE (${VTK_BINARY_DIR}/Wrapping/Tcl/LocalUserOptions.cmake OPTIONAL)
INCLUDE (${VTK_SOURCE_DIR}/Wrapping/Tcl/LocalUserOptions.cmake OPTIONAL)
