
###############################################################################
# the macros in charge of dispatching to the language specific macros

MACRO(WRAP_LIBRARIES_ALL_LANGUAGES)
#!  IF(WRAP_ITK_JAVA AND WRAPPER_LIBRARY_JAVA)
#!    INIT_WRAP_LIBRARY_JAVA()
#!  ENDIF(WRAP_ITK_JAVA AND WRAPPER_LIBRARY_JAVA)

  IF(WRAP_ITK_PYTHON)
    WRAP_LIBRARIES_PYTHON()
  ENDIF(WRAP_ITK_PYTHON)  
  IF(WRAP_ITK_TCL)
    WRAP_LIBRARIES_TCL()
  ENDIF(WRAP_ITK_TCL)
  IF(WRAP_ITK_JAVA)
    WRAP_LIBRARIES_JAVA()
  ENDIF(WRAP_ITK_JAVA)  
  IF(WRAP_ITK_RUBY)
    WRAP_LIBRARIES_RUBY()
  ENDIF(WRAP_ITK_RUBY)  
ENDMACRO(WRAP_LIBRARIES_ALL_LANGUAGES)

MACRO(END_WRAP_LIBRARIES_ALL_LANGUAGES)
  IF(WRAP_ITK_PYTHON)
    END_WRAP_LIBRARIES_PYTHON()
  ENDIF(WRAP_ITK_PYTHON)  
  IF(WRAP_ITK_TCL)
    END_WRAP_LIBRARIES_TCL()
  ENDIF(WRAP_ITK_TCL)  
  IF(WRAP_ITK_JAVA)
    END_WRAP_LIBRARIES_JAVA()
  ENDIF(WRAP_ITK_JAVA)  
  IF(WRAP_ITK_RUBY)
    END_WRAP_LIBRARIES_RUBY()
  ENDIF(WRAP_ITK_RUBY)  
ENDMACRO(END_WRAP_LIBRARIES_ALL_LANGUAGES)


MACRO(WRAP_LIBRARY_ALL_LANGUAGES library_name)
  IF(WRAP_ITK_GCCXML)
    WRAP_LIBRARY_GCCXML("${library_name}")
  ENDIF(WRAP_ITK_GCCXML)
  IF(WRAP_ITK_SWIGINTERFACE)
    WRAP_LIBRARY_SWIG_INTERFACE("${library_name}")
  ENDIF(WRAP_ITK_SWIGINTERFACE)
  IF(WRAP_ITK_DOC)
    WRAP_LIBRARY_DOC("${library_name}")
  ENDIF(WRAP_ITK_DOC)
  IF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
    WRAP_LIBRARY_PYTHON("${library_name}")
  ENDIF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
  IF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
    WRAP_LIBRARY_TCL("${library_name}")
  ENDIF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
  IF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
    WRAP_LIBRARY_RUBY("${library_name}")
  ENDIF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
  IF(WRAP_ITK_JAVA AND WRAPPER_LIBRARY_JAVA)
    WRAP_LIBRARY_JAVA("${library_name}")
  ENDIF(WRAP_ITK_JAVA AND WRAPPER_LIBRARY_JAVA)
ENDMACRO(WRAP_LIBRARY_ALL_LANGUAGES)

MACRO(END_WRAP_LIBRARY_ALL_LANGUAGES)
  IF(WRAP_ITK_GCCXML)
    END_WRAP_LIBRARY_GCCXML()
  ENDIF(WRAP_ITK_GCCXML)
  IF(WRAP_ITK_SWIGINTERFACE)
    END_WRAP_LIBRARY_SWIG_INTERFACE()
  ENDIF(WRAP_ITK_SWIGINTERFACE)
  IF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
    END_WRAP_LIBRARY_PYTHON()
  ENDIF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
  IF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
    END_WRAP_LIBRARY_TCL()
  ENDIF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
  IF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
    END_WRAP_LIBRARY_RUBY()
  ENDIF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
  IF(WRAP_ITK_JAVA AND WRAPPER_LIBRARY_JAVA)
    END_WRAP_LIBRARY_JAVA()
  ENDIF(WRAP_ITK_JAVA AND WRAPPER_LIBRARY_JAVA)
  IF(WRAP_ITK_DOC)
    END_WRAP_LIBRARY_DOC()
  ENDIF(WRAP_ITK_DOC)
ENDMACRO(END_WRAP_LIBRARY_ALL_LANGUAGES)


MACRO(WRAP_MODULE_ALL_LANGUAGES module)
  IF(WRAP_ITK_GCCXML)
    WRAP_MODULE_GCCXML("${module}")
  ENDIF(WRAP_ITK_GCCXML)
  IF(WRAP_ITK_SWIGINTERFACE)
    WRAP_MODULE_SWIG_INTERFACE("${module}")
  ENDIF(WRAP_ITK_SWIGINTERFACE)
  IF(WRAP_ITK_DOC)
    WRAP_MODULE_DOC("${module}")
  ENDIF(WRAP_ITK_DOC)
  IF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
    WRAP_MODULE_PYTHON("${module}")
  ENDIF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
  IF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
    WRAP_MODULE_TCL("${module}")
  ENDIF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
  IF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
    WRAP_MODULE_RUBY("${module}")
  ENDIF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
  IF(WRAP_ITK_JAVA AND WRAPPER_LIBRARY_JAVA)
    WRAP_MODULE_JAVA("${module}")
  ENDIF(WRAP_ITK_JAVA AND WRAPPER_LIBRARY_JAVA)
ENDMACRO(WRAP_MODULE_ALL_LANGUAGES)

MACRO(END_WRAP_MODULE_ALL_LANGUAGES module)
  IF(WRAP_ITK_GCCXML)
    END_WRAP_MODULE_GCCXML("${module}")
  ENDIF(WRAP_ITK_GCCXML)
  IF(WRAP_ITK_SWIGINTERFACE)
    END_WRAP_MODULE_SWIG_INTERFACE("${module}")
  ENDIF(WRAP_ITK_SWIGINTERFACE)
  IF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
    END_WRAP_MODULE_PYTHON("${module}")
  ENDIF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
  IF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
    END_WRAP_MODULE_TCL("${module}")
  ENDIF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
  IF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
    END_WRAP_MODULE_RUBY("${module}")
  ENDIF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
  IF(WRAP_ITK_JAVA AND WRAPPER_LIBRARY_JAVA)
    END_WRAP_MODULE_JAVA("${module}")
  ENDIF(WRAP_ITK_JAVA AND WRAPPER_LIBRARY_JAVA)
  IF(WRAP_ITK_DOC)
    END_WRAP_MODULE_DOC()
  ENDIF(WRAP_ITK_DOC)
ENDMACRO(END_WRAP_MODULE_ALL_LANGUAGES)


MACRO(WRAP_CLASS_ALL_LANGUAGES class)
ENDMACRO(WRAP_CLASS_ALL_LANGUAGES)

MACRO(WRAP_NAMED_CLASS_ALL_LANGUAGES class swig_name)
  IF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
    WRAP_NAMED_CLASS_PYTHON("${class}" "${swig_name}")
  ENDIF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
  IF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
    WRAP_NAMED_CLASS_TCL("${class}" "${swig_name}")
  ENDIF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
  IF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
    WRAP_NAMED_CLASS_RUBY("${class}" "${swig_name}")
  ENDIF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
  IF(WRAP_ITK_DOC)
    WRAP_NAMED_CLASS_DOC("${class}" "${swig_name}")
  ENDIF(WRAP_ITK_DOC)
ENDMACRO(WRAP_NAMED_CLASS_ALL_LANGUAGES class swig_name)

MACRO(END_WRAP_CLASS_ALL_LANGUAGES)
ENDMACRO(END_WRAP_CLASS_ALL_LANGUAGES)


MACRO(WRAP_NON_TEMPLATE_CLASS_ALL_LANGUAGES class)
ENDMACRO(WRAP_NON_TEMPLATE_CLASS_ALL_LANGUAGES class)


MACRO(WRAP_NAMED_NON_TEMPLATE_CLASS_ALL_LANGUAGES class)
ENDMACRO(WRAP_NAMED_NON_TEMPLATE_CLASS_ALL_LANGUAGES class)


MACRO(WRAP_INCLUDE_ALL_LANGUAGES inc)
  IF(WRAP_ITK_GCCXML)
    WRAP_INCLUDE_GCCXML("${inc}")
  ENDIF(WRAP_ITK_GCCXML)
  IF(WRAP_ITK_SWIGINTERFACE)
    WRAP_INCLUDE_SWIG_INTERFACE("${inc}")
  ENDIF(WRAP_ITK_SWIGINTERFACE)
ENDMACRO(WRAP_INCLUDE_ALL_LANGUAGES inc)

MACRO(WRAP_TEMPLATE_ALL_LANGUAGES name types)
  IF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
    WRAP_TEMPLATE_PYTHON("${name}" "${types}")
  ENDIF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
  IF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
    WRAP_TEMPLATE_TCL("${name}" "${types}")
  ENDIF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
  IF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
    WRAP_TEMPLATE_RUBY("${name}" "${types}")
  ENDIF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
ENDMACRO(WRAP_TEMPLATE_ALL_LANGUAGES)


MACRO(ADD_ONE_TYPEDEF_ALL_LANGUAGES wrap_method wrap_class swig_name template_params)
  IF(WRAP_ITK_GCCXML)
    ADD_ONE_TYPEDEF_GCCXML("${wrap_method}" "${wrap_class}" "${swig_name}" "${template_params}")
  ENDIF(WRAP_ITK_GCCXML)
  IF(WRAP_ITK_SWIGINTERFACE)
    ADD_ONE_TYPEDEF_SWIG_INTERFACE("${wrap_method}" "${wrap_class}" "${swig_name}" "${template_params}")
  ENDIF(WRAP_ITK_SWIGINTERFACE)
  IF(WRAP_ITK_DOC)
    ADD_ONE_TYPEDEF_DOC("${wrap_method}" "${wrap_class}" "${swig_name}" "${template_params}")
  ENDIF(WRAP_ITK_DOC)
  IF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
    ADD_ONE_TYPEDEF_PYTHON("${wrap_method}" "${wrap_class}" "${swig_name}" "${template_params}")
  ENDIF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
  IF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
    ADD_ONE_TYPEDEF_TCL("${wrap_method}" "${wrap_class}" "${swig_name}" "${template_params}")
  ENDIF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
  IF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
    ADD_ONE_TYPEDEF_RUBY("${wrap_method}" "${wrap_class}" "${swig_name}" "${template_params}")
  ENDIF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
  IF(WRAP_ITK_JAVA AND WRAPPER_LIBRARY_JAVA)
    ADD_ONE_TYPEDEF_JAVA("${wrap_method}" "${wrap_class}" "${swig_name}" "${template_params}")
  ENDIF(WRAP_ITK_JAVA AND WRAPPER_LIBRARY_JAVA)
ENDMACRO(ADD_ONE_TYPEDEF_ALL_LANGUAGES)


MACRO(ADD_SIMPLE_TYPEDEF_ALL_LANGUAGES wrap_class swig_name)
  IF(WRAP_ITK_GCCXML)
    ADD_SIMPLE_TYPEDEF_GCCXML("${wrap_class}" "${swig_name}")
  ENDIF(WRAP_ITK_GCCXML)
  IF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
    ADD_SIMPLE_TYPEDEF_PYTHON("${wrap_class}" "${swig_name}")
  ENDIF(WRAP_ITK_PYTHON AND WRAPPER_LIBRARY_PYTHON)
  IF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
    ADD_SIMPLE_TYPEDEF_TCL("${wrap_class}" "${swig_name}")
  ENDIF(WRAP_ITK_TCL AND WRAPPER_LIBRARY_TCL)
  IF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
    ADD_SIMPLE_TYPEDEF_RUBY("${wrap_class}" "${swig_name}")
  ENDIF(WRAP_ITK_RUBY AND WRAPPER_LIBRARY_RUBY)
  IF(WRAP_ITK_JAVA AND WRAPPER_LIBRARY_JAVA)
    ADD_SIMPLE_TYPEDEF_JAVA("${wrap_class}" "${swig_name}")
  ENDIF(WRAP_ITK_JAVA AND WRAPPER_LIBRARY_JAVA)
ENDMACRO(ADD_SIMPLE_TYPEDEF_ALL_LANGUAGES wrap_class swig_name)



###############################################################################
# ccache management. This option is shared by most of languages, so put it here.
OPTION(WRAP_ITK_USE_CCACHE "Use ccache to cache swig/gccxml/... output and speedup the rebuild." OFF)
MARK_AS_ADVANCED(WRAP_ITK_USE_CCACHE)
IF(WRAP_ITK_USE_CCACHE)
  FIND_PROGRAM(CCACHE_EXECUTABLE NAMES ccache-swig ccache DOC "ccache executable.")
ENDIF(WRAP_ITK_USE_CCACHE)



###############################################################################
# build the languages list

IF(EXTERNAL_WRAP_ITK_PROJECT)
  # languages there have been turned on while building wrapitk
  SET(default ON)
ELSE(EXTERNAL_WRAP_ITK_PROJECT)
  # set some of them to on by default
  OPTION(WRAP_ITK_GCCXML "Build gccxml files." ON)
  OPTION(WRAP_ITK_SWIGINTERFACE "Build swig interfaces." ON)
  SET(default OFF)
ENDIF(EXTERNAL_WRAP_ITK_PROJECT)

SET(WRAP_ITK_LANGUAGES CACHE INTERNAL "Internal languages list.")
SET(WRAP_ITK_UNUSED_LANGUAGES CACHE INTERNAL "Internal unused languages list.")
FILE(GLOB local_files *)
# filter and reorder the list
SET(languages )
FOREACH(f ${local_files})
  FILE(RELATIVE_PATH lang "${CMAKE_CURRENT_SOURCE_DIR}" "${f}")
  IF(IS_DIRECTORY "${f}" AND NOT "${lang}" MATCHES "CVS" AND NOT "${lang}" MATCHES ".svn")
    IF("${lang}" MATCHES "^GccXML$|^SwigInterface$|^Doc$")
      # put those languages before the others
      SET(languages ${lang} ${languages})
    ELSE("${lang}" MATCHES "^GccXML$|^SwigInterface$|^Doc$")
      SET(languages ${languages} ${lang})
    ENDIF("${lang}" MATCHES "^GccXML$|^SwigInterface$|^Doc$")
  ENDIF(IS_DIRECTORY "${f}" AND NOT "${lang}" MATCHES "CVS" AND NOT "${lang}" MATCHES ".svn")
ENDFOREACH(f)

FOREACH(lang ${languages})
  STRING(TOUPPER "${lang}" lang_upper)
  
  # add the language to the options
  OPTION(WRAP_ITK_${lang_upper} "Build swig ${lang} wrapper support." ${default})
  
  # add the language to the list, if the user have turn it on, and include
  # the subdirectory
  IF(WRAP_ITK_${lang_upper})
    SET(WRAP_ITK_LANGUAGES ${WRAP_ITK_LANGUAGES} "${lang}")
    ADD_SUBDIRECTORY("${lang}")
    GET_DIRECTORY_PROPERTY(inc DIRECTORY "${lang}" INCLUDE_DIRECTORIES)
    INCLUDE_DIRECTORIES(${inc})
  ELSE(WRAP_ITK_${lang_upper})
    SET(WRAP_ITK_UNUSED_LANGUAGES ${WRAP_ITK_UNUSED_LANGUAGES} "${lang}")
  ENDIF(WRAP_ITK_${lang_upper})
ENDFOREACH(lang)
SET(WRAP_ITK_LANGUAGES ${WRAP_ITK_LANGUAGES} CACHE INTERNAL "Internal languages list.")
SET(WRAP_ITK_UNUSED_LANGUAGES ${WRAP_ITK_UNUSED_LANGUAGES} CACHE INTERNAL "Internal unused languages list.")

# MESSAGE("WRAP_ITK_LANGUAGES: ${WRAP_ITK_LANGUAGES}")

IF(NOT EXTERNAL_WRAP_ITK_PROJECT)
  INSTALL(FILES CMakeLists.txt itk.i
    DESTINATION "${WRAP_ITK_INSTALL_PREFIX}/Configuration/Languages"
  )
ENDIF(NOT EXTERNAL_WRAP_ITK_PROJECT)
