ParaViewMacros.cmake 16 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
# File defining miscellaneous macros

#------------------------------------------------------------------------------
# GENERATE_QT_RESOURCE_FROM_FILES can be used to generate a Qt resource file
# from a given set of files.
# ARGUMENTS:
# resource_file: IN : full pathname of the qrc file to generate. 
# resource_prefix: IN : the name used in the "prefix" attribute for the
#                       generated qrc file.
# file_list: IN : list of files to be added into the resource file.
#------------------------------------------------------------------------------
MACRO(GENERATE_QT_RESOURCE_FROM_FILES resource_file resource_prefix file_list)
  SET (pq_resource_file_contents "<RCC>\n  <qresource prefix=\"${resource_prefix}\">\n")
  GET_FILENAME_COMPONENT(current_directory ${resource_file} PATH)
  FOREACH (resource ${file_list})
    GET_FILENAME_COMPONENT(alias ${resource} NAME)
    GET_FILENAME_COMPONENT(resource ${resource} ABSOLUTE)
    FILE(RELATIVE_PATH resource "${current_directory}" "${resource}")
    FILE(TO_NATIVE_PATH "${resource}" resource)
    SET (pq_resource_file_contents
      "${pq_resource_file_contents}    <file alias=\"${alias}\">${resource}</file>\n")
  ENDFOREACH (resource)
  SET (pq_resource_file_contents
    "${pq_resource_file_contents}  </qresource>\n</RCC>\n")

  # Generate the resource file.
  FILE (WRITE "${resource_file}" "${pq_resource_file_contents}")
ENDMACRO(GENERATE_QT_RESOURCE_FROM_FILES)

#----------------------------------------------------------------------------
# PV_PARSE_ARGUMENTS is a macro useful for writing macros that take a key-word
# style arguments.
#----------------------------------------------------------------------------
MACRO(PV_PARSE_ARGUMENTS prefix arg_names option_names)
  SET(DEFAULT_ARGS)
  FOREACH(arg_name ${arg_names})    
    SET(${prefix}_${arg_name})
  ENDFOREACH(arg_name)
  FOREACH(option ${option_names})
    SET(${prefix}_${option} FALSE)
  ENDFOREACH(option)

  SET(current_arg_name DEFAULT_ARGS)
  SET(current_arg_list)
  FOREACH(arg ${ARGN})            
    SET(larg_names ${arg_names})    
    LIST(FIND larg_names "${arg}" is_arg_name)                   
    IF (is_arg_name GREATER -1)
      SET(${prefix}_${current_arg_name} ${current_arg_list})
      SET(current_arg_name ${arg})
      SET(current_arg_list)
    ELSE (is_arg_name GREATER -1)
      SET(loption_names ${option_names})    
      LIST(FIND loption_names "${arg}" is_option)            
      IF (is_option GREATER -1)
       SET(${prefix}_${arg} TRUE)
      ELSE (is_option GREATER -1)
       SET(current_arg_list ${current_arg_list} ${arg})
      ENDIF (is_option GREATER -1)
    ENDIF (is_arg_name GREATER -1)
  ENDFOREACH(arg)
  SET(${prefix}_${current_arg_name} ${current_arg_list})
ENDMACRO(PV_PARSE_ARGUMENTS)
64 65 66 67 68 69 70 71 72

#----------------------------------------------------------------------------
# Macro for setting values if a user did not overwrite them
#----------------------------------------------------------------------------
MACRO(pv_set_if_not_set name value)
  IF(NOT DEFINED "${name}")
    SET(${name} "${value}")
  ENDIF(NOT DEFINED "${name}")
ENDMACRO(pv_set_if_not_set)
73

74 75 76 77 78 79 80 81
#----------------------------------------------------------------------------
# When installing system libraries, on non-windows machines, the CMake variable
# pointing to the library may be a sym-link, in which case we don't simply want
# to install the symlink, but the actual library. This macro takes care of that.
# Use it for installing system libraries. Call this only on unix boxes.
FUNCTION (pv_install_library libpath dest component)
  IF (NOT WIN32)
    GET_FILENAME_COMPONENT(dir_tmp ${libpath} PATH)
82 83 84 85 86 87 88 89 90 91 92
    SET(name_tmp)
    # libs symlinks are always named lib.*.dylib on mac
    # libs symlinks are always named lib.so.* on linux
    IF (APPLE)
      GET_FILENAME_COMPONENT(name_tmp ${libpath} NAME_WE)
      FILE(GLOB lib_list "${dir_tmp}/${name_tmp}*")
    ELSE (APPLE)
      GET_FILENAME_COMPONENT(dir_tmp ${libpath} PATH)
      GET_FILENAME_COMPONENT(name_tmp ${libpath} NAME)
      FILE(GLOB lib_list RELATIVE "${dir_tmp}" "${libpath}*")
    ENDIF (APPLE)
93 94 95 96 97 98 99 100
    INSTALL(CODE "
          MESSAGE(STATUS \"Installing ${name_tmp}\")
          EXECUTE_PROCESS (WORKING_DIRECTORY ${dir_tmp}
               COMMAND tar c ${lib_list}
               COMMAND tar -xC \${CMAKE_INSTALL_PREFIX}/${dest})
               " COMPONENT ${component})
  ENDIF (NOT WIN32)
ENDFUNCTION (pv_install_library)
101

102 103 104 105 106 107 108 109 110 111
#########################################################################
# Function to compile a proto file to generate a .h and .cc file
# Arguments:
# out_cpp_file_variable: variable that gets set with the full path to output file
# in_proto_file: full path to input file (e.g. ${CMAKE_CURRENT_SOURCE_DIR}/foo.pb)

FUNCTION (protobuf_generate out_cpp_file in_proto_file)
  GET_FILENAME_COMPONENT(basename ${in_proto_file} NAME_WE)
  GET_FILENAME_COMPONENT(absolute ${in_proto_file} ABSOLUTE)
  GET_FILENAME_COMPONENT(path ${absolute} PATH)
112
  SET (out_file ${CMAKE_CURRENT_BINARY_DIR}/${basename}.pb.h)
113
  SET(${out_cpp_file}  ${out_file} PARENT_SCOPE)
114
  ADD_CUSTOM_COMMAND(
115
    OUTPUT ${out_file}
116
    COMMAND protoc_compiler
117
      --cpp_out=dllexport_decl=VTK_PROTOBUF_EXPORT:${CMAKE_CURRENT_BINARY_DIR}
118
      --proto_path ${path} ${absolute}
119 120 121
    DEPENDS ${in_proto_file} protoc_compiler
  )
ENDFUNCTION (protobuf_generate)
122

123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
#########################################################################
# Function to generate header file from any file(s). Support ASCII as well as
# binary files.
# Usage:
# generate_header(name
#                 [PREFIX prefix_text]
#                 [SUFFIX suffix_text]
#                 [VARIABLE variablename]
#                 [BINARY]
#                 FILES <list-of-files>
# name :- name of the header file e.g. ${CMAKE_CURRENT_BINARY_DIR}/FooBar.h
# PREFIX :- (optional) when specified, used as the prefix for the generated
#           function/variable names.
# SUFFIX :- (optional) when specified, used as the suffix for the generated
#           function/variable names.
# BINARY :-(optional) when specified, all files are treated as binary and
#           encoded using base64.
# VARIABLE :- (optional) when specified, all the generate functions used to
#             access the compiled files are listed.
# FILES   :- list of files to compile in.
143
#------------------------------------------------------------------------------
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
function(generate_header name)
  pv_parse_arguments(arg
    "PREFIX;SUFFIX;VARIABLE;FILES"
    "BINARY"
    ${ARGN}
    )

  set (function_names)
  set (input_files)
  set (have_xmls)
  foreach (input_file ${arg_FILES})
    get_filename_component(absolute_file "${input_file}" ABSOLUTE)
    get_filename_component(file_name "${absolute_file}" NAME_WE)
    list (APPEND function_names "${arg_PREFIX}${file_name}${arg_SUFFIX}")
    list (APPEND input_files "${absolute_file}")
    set (have_xmls TRUE)
  endforeach()

  set (base_64)
  if (arg_BINARY)
    set (base_64 "-base64")
  endif()

  if (have_xmls)
    add_custom_command(
      OUTPUT "${name}"
170
      COMMAND kwProcessXML
171 172 173 174 175 176 177
              ${base_64}
              ${name}
              \"${arg_PREFIX}\" 
              \"${arg_SUFFIX}\"
              \"${arg_SUFFIX}\"
              ${input_files}
      DEPENDS ${arg_FILES}
178
              kwProcessXML 
179 180 181 182 183 184 185 186 187
     ) 
  endif ()

  if (DEFINED arg_VARIABLE)
    set (${arg_VARIABLE} ${function_names} PARENT_SCOPE)
  endif()
endfunction()


Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
188
# GENERATE_HTMLS_FROM_XMLS can be used to generate HTML files for
189 190
# from a given list of xml files that correspond to server manager xmls.
# ARGUMENTS:
Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
191
# output_files: OUT: variables set to the output files
192 193 194
# xmls: IN : full pathnames to xml files.
# output_dir : IN : full path to output directory where to generate the htmls.
#------------------------------------------------------------------------------
195
function (generate_htmls_from_xmls output_files xmls gui_xmls output_dir)
196
  # create a string from the xmls list to pass
197 198 199
  # since this list needs to be passed as an argument, we cannot escape the ";".
  # generate_proxydocumentation.cmake has code to convert these strings back to
  # lists.
200
  set (xmls_string "")
201
  foreach (xml ${xmls})
202
    get_filename_component(xml "${xml}" ABSOLUTE)
203 204 205
    set (xmls_string "${xmls_string}${xml}+")
  endforeach()
  
206
  set (gui_xmls_string "")
207
  foreach (gui_xml ${gui_xmls})
208
    get_filename_component(gui_xml "${gui_xml}" ABSOLUTE)
209 210
    set (gui_xmls_string "${gui_xmls_string}${gui_xml}+")
  endforeach()
211

212 213 214 215 216
  set (all_xmls ${xmls} ${gui_xmls})
  list (GET all_xmls 0 first_xml)
  if (NOT first_xml)
    message(FATAL_ERROR "No xml specified!!!")
  endif()
217 218 219 220
  
  # extract the name from the first xml file. This is the name for temporary
  # file we use.
  get_filename_component(first_xml "${first_xml}" NAME)
221 222 223 224 225 226 227 228 229 230 231

  find_program(QT_XMLPATTERNS_EXECUTABLE
    xmlpatterns
    PATHS "${QT_BINARY_DIR}"
    DOC "xmlpatterns used to generate html from Proxy documentation.")
  mark_as_advanced(QT_XMLPATTERNS_EXECUTABLE)

  if (NOT EXISTS ${QT_XMLPATTERNS_EXECUTABLE})
    message(WARNING "Valid QT_XMLPATTERNS_EXECUTABLE not specified.")
  endif()

232
  add_custom_command(
233
    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${first_xml}.xml"
234

235
    # process each html file to sperate it out into files for each proxy.
236 237 238 239
    COMMAND ${CMAKE_COMMAND}
            -Dxmlpatterns:FILEPATH=${QT_XMLPATTERNS_EXECUTABLE}
            -Dxml_to_xml_xsl:FILEPATH=${ParaView_CMAKE_DIR}/smxml_to_xml.xsl
            -Dxml_to_html_xsl:FILEPATH=${ParaView_CMAKE_DIR}/xml_to_html.xsl
240
            -Dxml_to_wiki_xsl:FILEPATH=${ParaView_CMAKE_DIR}/xml_to_wiki.xsl.in
241 242 243 244 245
            -Dinput_xmls:STRING=${xmls_string}
            -Dinput_gui_xmls:STRING=${gui_xmls_string}
            -Doutput_dir:PATH=${output_dir}
            -Doutput_file:FILEPATH=${CMAKE_CURRENT_BINARY_DIR}/${first_xml}.xml
            -P ${ParaView_CMAKE_DIR}/generate_proxydocumentation.cmake
246

247
    DEPENDS ${xmls}
248 249 250
            ${ParaView_CMAKE_DIR}/smxml_to_xml.xsl
            ${ParaView_CMAKE_DIR}/xml_to_html.xsl
            ${ParaView_CMAKE_DIR}/generate_proxydocumentation.cmake
251

252
    WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
253

254
    COMMENT "Generating Documentation HTMLs from xmls")
255

256
    set (dependencies ${dependencies}
257
          "${CMAKE_CURRENT_BINARY_DIR}/${first_xml}.xml")
258 259
  set (${output_files} ${dependencies} PARENT_SCOPE)
endfunction()
260

261
#------------------------------------------------------------------------------
262 263
# Function used to build a qhp (and qch) file. Adds a custom command to generate
# a ${DESTINATION_DIRECTORY}/${name}.qch.
264
# build_help_project(name 
265 266
#                    DESTINATION_DIRECTORY directory
#                    [DOCUMENTATION_SOURCE_DIR directory]
267 268
#                    [NAMESPACE namespacename (default:${name}.org)]
#                    [FOLDER virtualfoldername (default:${name})]
269 270 271 272
#                    [TABLE_OF_CONTENTS toc]
#                    [TABLE_OF_CONTENTS_FILE toc_file_name]
#                    [FILES relative filenames/wildcard-expressions]
#                   )
273
# name :- specifies the name for the qhp. The generated qhp file will be
274 275 276 277 278
#         ${DESTINATION_DIRECTORY}/${name}.qhp
# DESTINATION_DIRECTORY :- output-directory for the qhp file.
# DOCUMENTATION_SOURCE_DIR :- (optional) when specified, all files in this
#                             directory are copied over to the
#                             DESTINATION_DIRECTORY.
279 280 281 282 283 284
# NAMESPACE :- (optional; default=${name}.org") Namespace to use in qhp file.
# FOLDER :- (optional; default=${name}") virtual folder in qhp file.
# TABLE_OF_CONTENTS :- (optional) XML string <toc>..</toc> (see qhp file
#                      documentation). Used only when TABLE_OF_CONTENTS_FILE is
#                      not specified.
# TABLE_OF_CONTENTS_FILE :- file to read in to obtain the TABLE_OF_CONTENTS
285
# FILEPATTERNS :- (optional: default="*.*") list of files (names or wildcards) to list
286
#          in the qhp file. Note that these files/paths are relative to the
287 288
#          DESTINATION_DIRECTORY.
# DEPENDS :- (optional) targets or files that the qch generation target depends on.
289 290 291
#
# If neither TABLE_OF_CONTENTS or TABLE_OF_CONTENTS_FILE is specified, then the
# TOC is auto-generated.
292
#------------------------------------------------------------------------------
293 294
function(build_help_project name)
  pv_parse_arguments(arg
295
    "DESTINATION_DIRECTORY;DOCUMENTATION_SOURCE_DIR;NAMESPACE;FOLDER;TABLE_OF_CONTENTS;TABLE_OF_CONTENTS_FILE;FILEPATTERNS;DEPENDS"
296 297 298 299
    ""
    ${ARGN}
    )

300 301
  if (NOT DEFINED arg_DESTINATION_DIRECTORY)
    message(FATAL_ERROR "No DESTINATION_DIRECTORY specified in build_help_project()")
302 303
  endif()

304 305 306 307 308 309 310 311 312 313
  find_program(QT_HELP_GENERATOR
    qhelpgenerator
    PATHS "${QT_BINARY_DIR}"
    DOC "qhelpgenerator used to compile Qt help project files")
  mark_as_advanced(QT_HELP_GENERATOR)

  if (NOT EXISTS ${QT_HELP_GENERATOR})
    message(WARNING "Valid QT_HELP_GENERATOR not specified.")
  endif()

314 315
  # set default values for optional arguments.
  pv_set_if_not_set(arg_FILEPATTERNS "*.*")
316 317
  pv_set_if_not_set(arg_NAMESPACE "${name}.org")
  pv_set_if_not_set(arg_FOLDER "${name}")
318
  pv_set_if_not_set(arg_DEPENDS "")
319 320 321 322 323 324 325

  # if filename is specified, it takes precendence.
  # setup toc variable to refer to the TOC xml dom.
  if (DEFINED arg_TABLE_OF_CONTENTS_FILE)
    file(READ ${arg_TABLE_OF_CONTENTS_FILE} arg_TABLE_OF_CONTENTS)
  endif()

326
  set (qhp_filename ${arg_DESTINATION_DIRECTORY}/${name}.qhp)
327 328

  set (extra_args)
329
  if (arg_DOCUMENTATION_SOURCE_DIR)
330 331 332 333 334 335 336 337 338
    set (extra_args
      # copy all htmls from source to destination directory (same location where the
      # qhp file is present.
      COMMAND ${CMAKE_COMMAND} -E copy_directory
              "${arg_DOCUMENTATION_SOURCE_DIR}"
              "${arg_DESTINATION_DIRECTORY}"
      )
  endif()

339 340 341 342 343 344 345
  if (NOT DEFINED arg_TABLE_OF_CONTENTS)
    # sanitize arg_FILEPATTERNS since we pass it as a command line argument.
    string (REPLACE ";" "+" arg_FILEPATTERNS "${arg_FILEPATTERNS}")
    set (extra_args ${extra_args}

    # generate the toc at run-time.
    COMMAND ${CMAKE_COMMAND}
346 347 348 349 350
            -Doutput_file:FILEPATH=${qhp_filename}
            -Dfile_patterns:STRING="${arg_FILEPATTERNS}"
            -Dnamespace:STRING="${arg_NAMESPACE}"
            -Dfolder:PATH=${arg_FOLDER}
            -Dname:STRING="${name}"
351 352 353 354 355 356 357 358 359 360 361 362 363 364
            -P "${ParaView_CMAKE_DIR}/generate_qhp.cmake"
    )
  else ()
    # toc is provided, we'll just configure the file.
    set (files)
    foreach(filename ${arg_FILEPATTERNS})
      set (files "${files}<file>${filename}</file>\n")
    endforeach()

    configure_file(${ParaView_CMAKE_DIR}/build_help_project.qhp.in
      ${qhp_filename})
    list (APPEND arg_DEPENDS ${qhp_filename})
  endif()

365
  ADD_CUSTOM_COMMAND(
366
    OUTPUT ${arg_DESTINATION_DIRECTORY}/${name}.qch
367
    DEPENDS ${arg_DEPENDS}
368
            ${ParaView_CMAKE_DIR}/generate_qhp.cmake
369 370
  
    ${extra_args}
371

372 373
    # Now, compile the qhp file to generate the qch.
    COMMAND ${QT_HELP_GENERATOR}
374 375
            ${qhp_filename}
            -o ${arg_DESTINATION_DIRECTORY}/${name}.qch
376 377
  
    COMMENT "Compiling Qt help project ${name}.qhp"
378 379

    WORKING_DIRECTORY "${arg_DESTINATION_DIRECTORY}"
380
  )
381
endfunction(build_help_project)
382 383 384 385 386 387 388 389 390

macro(pv_set_link_interface_libs target)
  # if not lion then we need to set LINK_INTERFACE_LIBRARIES to reduce the number
  # of libraries we link against there is a limit of 253.
  if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND CMAKE_SYSTEM_VERSION VERSION_LESS 11.0) 
    set_property(TARGET ${target}
      PROPERTY LINK_INTERFACE_LIBRARIES "${ARGN}")
  endif()
endmacro()
391 392

#------------------------------------------------------------------------------
393
# Function used to add install rules for executables.
394 395 396
#------------------------------------------------------------------------------
function (pv_executable_install name exe_suffix)
  if (exe_suffix)
397 398 399 400 401
    # we have two executables to install, one in the bin dir and another in the
    # lib dir

    # install the real-binary in the lib-dir
    install(TARGETS ${name}
402 403 404
            DESTINATION ${VTK_INSTALL_LIBRARY_DIR}
            COMPONENT Runtime)
  endif()
405 406 407 408 409 410

  # install the launcher binary in the binary dir. When exe_suffix is empty, the
  # launcher binary is same as the real binary.
  install(TARGETS ${name}${exe_suffix}
          DESTINATION ${VTK_INSTALL_RUNTIME_DIR}
          COMPONENT Runtime)
411
endfunction()