
####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() #######
####### Any changes to this file will be overwritten by the next CMake run ####
####### The input file was PkgLibConfig.cmake.in ########

get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)

macro(set_and_check _var _file)
set(${_var} "${_file}")
  if(NOT EXISTS "${_file}")
    message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !")
endif()
endmacro()

macro(check_required_components _NAME)
foreach(comp ${${_NAME}_FIND_COMPONENTS})
if(NOT ${_NAME}_${comp}_FOUND)
if(${_NAME}_FIND_REQUIRED_${comp})
set(${_NAME}_FOUND FALSE)
endif()
endif()
endforeach()
endmacro()

####################################################################################
set(FIND_NAMES )


set(JPEG_INCLUDE_DIR "" "")
set(JPEG_LIBRARIES "")
set(JPEG_SHARED_DEFINITIONS "")
set(JPEG_STATIC_DEFINITIONS "")
set(JPEG_COMMON_DEFINITIONS "")
set(JPEG_IS_MODULE )

# Append the found information to our local information if possible
foreach(fn ${FIND_NAMES})

	if (NOT ${fn}_FOUND)
		string(TOUPPER ${fn} fn)
	endif()

	if (NOT ${fn}_FOUND)
		string(TOLOWER ${fn} fn)
	endif()

	if (${fn}_FOUND)
		# Try to append the include directories with different names
		list(APPEND JPEG_INCLUDE_DIR 
			${${fn}_INCLUDE_DIR}
			${${fn}_INCLUDE_DIRS}
			${${fn}_INCLUDE_PATH}
			${${fn}_INCLUDES}
			"")

		# Try to append the library names with different names
		list(APPEND JPEG_LIBRARIES
			${${fn}_LIBRARIES}
			${${fn}_LIBRARY}
			"")

		# Try to append the definitions
		list(APPEND JPEG_SHARED_DEFINITIONS ${${fn}_SHARED_DEFINITIONS} "")
		list(APPEND JPEG_STATIC_DEFINITIONS ${${fn}_STATIC_DEFINITIONS} "")
		list(APPEND JPEG_COMMON_DEFINITIONS ${${fn}_COMMON_DEFINITIONS} "")
	endif()

endforeach()

#list(APPEND JPEG_INCLUDE_DIR "")
if (EXISTS "/home/hodasemi/Documents/Workspace/CGII/framework/cgv/3rd/jpeg")
	list(APPEND JPEG_INCLUDE_DIR "/home/hodasemi/Documents/Workspace/CGII/framework/cgv/3rd/jpeg")
	list(APPEND JPEG_INCLUDE_DIR "/home/hodasemi/Documents/Workspace/CGII/framework/cgv/3rd/jpeg/..")
else()
	list(APPEND JPEG_INCLUDE_DIR "${PACKAGE_PREFIX_DIR}/framework/include/libs")
	list(APPEND JPEG_INCLUDE_DIR "${PACKAGE_PREFIX_DIR}/framework/include/libs/JPEG")
endif()

# Remove duplicates from the include dirs
list(REMOVE_DUPLICATES JPEG_INCLUDE_DIR)

# For compatibility also set the JPEG_INCLUDE_DIR and JPEG_INCLUDE_PATH variable
set(JPEG_INCLUDE_DIRS "${JPEG_INCLUDE_DIR}")
set(JPEG_INCLUDES "${JPEG_INCLUDE_DIR}")
set(JPEG_INCLUDE_PATH "${JPEG_INCLUDE_DIR}")


# Make a list of all configurations 
set(CONFIGS "")
foreach(conf ${CMAKE_CONFIGURATION_TYPES})
	string(TOUPPER "${conf}" UPPER_CONF)
	list(APPEND CONFIGS "${UPPER_CONF}")
endforeach()

# On unix systems the CMAKE_CONFIGURATION_TYPES variable is not set
if (NOT CONFIGS)
	set(CONFIGS RELEASE DEBUG)
endif()

# Construct the library names
if (BUILD_SHARED_LIBS)
	set(JPEG_OUTPUT_NAME_RELEASE "JPEG")
	set(JPEG_OUTPUT_NAME_DEBUG "JPEG_d")
	if (JPEG_IS_MODULE)
		set(TARGET_POSTFIX "MODULE")
	else()
		set(TARGET_POSTFIX "SHARED")
	endif()
else()
	set(JPEG_OUTPUT_NAME_RELEASE "JPEG_static")
	set(JPEG_OUTPUT_NAME_DEBUG "JPEG_static_d")
	set(TARGET_POSTFIX "STATIC")
endif()



# See if we can go the easy way when our dependency is also a target to be built
if (TARGET JPEG)
    set(JPEG_LIBRARIES JPEG)
    set(JPEG_FOUND TRUE)
endif()

# See if the imported target already exists
if (TARGET JPEG_IMPORTED_${TARGET_POSTFIX})
    set(JPEG_LIBRARIES JPEG_IMPORTED_${TARGET_POSTFIX})
    set(JPEG_FOUND TRUE)
endif()

# If our variable is not set then we generate a new target
# where we collect names for every configuration
if (NOT JPEG_FOUND)
	set(FIND_PATHS "${PACKAGE_PREFIX_DIR}/framework/lib/unix" 
				   "${PACKAGE_PREFIX_DIR}/framework/bin/unix" 
				   "${PACKAGE_PREFIX_DIR}/build/bin/unix"
				   "${PACKAGE_PREFIX_DIR}/build/lib/unix")
	
	# Try to find libraries for all configurations
	if (JPEG_IS_MODULE AND BUILD_SHARED_LIBS AND WIN32)
		foreach(conf ${CONFIGS})
			find_file(JPEG_LIB_${conf}  ${JPEG_OUTPUT_NAME_${conf}}.dll PATHS ${FIND_PATHS})
		endforeach()
	else()
		foreach(conf ${CONFIGS})
			find_library(JPEG_LIB_${conf} ${JPEG_OUTPUT_NAME_${conf}} PATHS ${FIND_PATHS})
		endforeach()
	endif()
		
	# Check if all library types could be found
	set(ALL_LIBS_FOUND TRUE)
	foreach(conf ${CONFIGS})
		if (NOT JPEG_LIB_${conf})
			set(ALL_LIBS_FOUND FALSE)
			break()
		endif()
	endforeach()
	
	# If some libraries could not be found then substitute their name with the
	# first library name that could be found
	if (NOT ALL_LIBS_FOUND)	
		set(FIRST_FOUND_NAME FALSE)
	
		foreach(conf ${CONFIGS})
			if(JPEG_LIB_${conf})
				set(FIRST_FOUND_NAME ${JPEG_LIB_${conf}})
				break()
			endif()
		endforeach()
		
		# If no library was found then we failed
		if (NOT FIRST_FOUND_NAME)
			# FIXME: add better error handling here
			message(FATAL_ERROR "Could not find library JPEG")
			set(JPEG_FOUND FALSE)
			return()
		endif()
		
		# Set all library names that were not found
		foreach(conf ${CONFIGS})
			if(NOT JPEG_LIB_${conf})
				set(JPEG_LIB_${conf} ${FIRST_FOUND_NAME})
			endif()
		endforeach()
    endif()

    # Generate an imported target which each location for different configurations set accordingly
	add_library(JPEG_IMPORTED_${TARGET_POSTFIX} ${TARGET_POSTFIX} IMPORTED GLOBAL)

    foreach(conf ${CONFIGS})
	    set_target_properties(JPEG_IMPORTED_${TARGET_POSTFIX} PROPERTIES
		    IMPORTED_LINK_INTERFACE_LANGUAGES_${conf} "CXX"
		    IMPORTED_LINK_INTERFACE_LIBRARIES_${conf} "${JPEG_LIBRARIES}"
		    IMPORTED_LOCATION_${conf} "${JPEG_LIB_${conf}}"
		    IMPORTED_IMPLIB_${conf} "${JPEG_LIB_${conf}}")
    endforeach()

    # Also add definitions if no build type was specified. Set this to be the release type
    set_target_properties(JPEG_IMPORTED_${TARGET_POSTFIX} PROPERTIES
	    IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
	    IMPORTED_LINK_INTERFACE_LIBRARIES "${JPEG_LIBRARIES}"
	    IMPORTED_LOCATION "${JPEG_LIB_RELEASE}"
	    IMPORTED_IMPLIB "${JPEG_LIB_RELEASE}")

    # Finally set the libraries info to be exported
    set(JPEG_LIBRARIES "JPEG_IMPORTED_${TARGET_POSTFIX}")
    set(JPEG_FOUND TRUE)
endif()



# Set definitions
set(JPEG_NEW_SHARED_DEFINITIONS "JPEG_DLL")
set(JPEG_NEW_STATIC_DEFINITIONS "JPEG_STATIC;CGV_FORCE_STATIC")
set(JPEG_NEW_COMMON_DEFINITIONS "JPEG_STATIC;CGV_FORCE_STATIC")

list(APPEND JPEG_COMMON_DEFINITIONS "${JPEG_NEW_COMMON_DEFINITIONS}")
list(APPEND JPEG_STATIC_DEFINITIONS "${JPEG_COMMON_DEFINITIONS}${JPEG_NEW_STATIC_DEFINITIONS}")
list(REMOVE_DUPLICATES JPEG_COMMON_DEFINITIONS)
list(REMOVE_DUPLICATES JPEG_STATIC_DEFINITIONS)


if (BUILD_SHARED_LIBS)
	set(JPEG_DEFINITIONS "${JPEG_COMMON_DEFINITIONS};${JPEG_NEW_SHARED_DEFINITIONS}")
else()
	set(JPEG_DEFINITIONS "${JPEG_STATIC_DEFINITIONS}")
endif()



