# ------------------------------------------------------------------------
# 	Makefile for Rappture 
# ------------------------------------------------------------------------

# ------------------------------------------------------------------------
# 	C Compiler options 
# ------------------------------------------------------------------------

RAPPTURE_MAJOR_VERSION =	@RAPPTURE_MAJOR_VERSION@
RAPPTURE_MINOR_VERSION =	@RAPPTURE_MINOR_VERSION@
RAPPTURE_RELEASE_SERIAL =	@RAPPTURE_RELEASE_SERIAL@
X_INCLUDES =		@X_INCLUDES@
X_LIBRARIES =		@X_LIBRARIES@
WORDSIZE =		@WORDSIZE@
version = $(RAPPTURE_MAJOR_VERSION).$(RAPPTURE_MINOR_VERSION).$(RAPPTURE_RELEASE_SERIAL)
runtime =		$(shell cd ../rappture/runtime; pwd)
TAG =			branches/blt4

# ------------------------------------------------------------------------
# 	Source and targer installation directories 
# ------------------------------------------------------------------------

bindir =		$(exec_prefix)/bin
datadir =		@datadir@
datarootdir =		@datarootdir@
exec_prefix =		@exec_prefix@
incdir =		$(prefix)/include
includedir =		@includedir@
libdir =		@libdir@
prefix =		@prefix@
scriptdir =		$(exec_prefix)/scripts
pkgdir =		$(exec_prefix)/lib
srcdir =		$(shell cd @srcdir@; pwd)
statsdir =		@STATSDIR@

# ------------------------------------------------------------------------
# 	You don't need to edit anything beyond this point
# ------------------------------------------------------------------------

INSTALL =		@INSTALL@
INSTALL_DATA =		@INSTALL_DATA@
DESTDIR =  
RANLIB =		@RANLIB@
MAKE =			make
SHELL =			/bin/sh
AR =			ar rc
RM =			rm -f
LN_S =			@LN_S@
VPATH =			$(srcdir)
MKDIR_P =		@MKDIR_P@
CP = 			/bin/cp

WITH_R =		@WITH_R@
WITH_JAVA =		@WITH_JAVA@
WITH_MATLAB =		@WITH_MATLAB@
WITH_MKOCTFILE2 =	@WITH_MKOCTFILE2@
WITH_MKOCTFILE3 =	@WITH_MKOCTFILE3@
WITH_OCTAVE =		@WITH_OCTAVE@
WITH_PERL =		@WITH_PERL@
WITH_PYTHON =		@WITH_PYTHON@
WITH_RUBY =		@WITH_RUBY@
WITH_RUBY_SITELIBDIR =	@WITH_RUBY_SITELIBDIR@
WITH_TCL =		@WITH_TCL@
WITH_VTK =		@WITH_VTK@

common_flags =		--prefix=$(prefix) --exec_prefix=$(exec_prefix) 
x_flags = 
ifneq ("$(X_INCLUDES)", )
  x_flags += --x-includes=$(X_INCLUDES)
endif
ifneq ("$(X_LIBRARIES)", )
  x_flags += --x-includes=$(X_LIBRARIES)
endif

PATH := $(bindir):$(PATH)

targets = \
	apps blt cmake examples expat expect gui htmlwidget itcl \
	itk lang lib optimizer shape sqlitetcl tcl tcllib \
	tdom tk tkimg tls video vtk zlib  packages \

.PHONY: $(targets)

.NOTPARALLEL:

all: gui lang apps allpackages 

allpackages: packages video optimizer

update:
	for i in $(srcdir)/runtime/*; do \
	   (cd $$i; svn update; svn status) \
	done

# Aliases for package directory names.

blt = blt4
cmake = cmake-2.8.12.2
examples = examples
expat = expat-2.1.0
expect = expect5.45
freetype = freetype-2.5.3
gui = gui
htmlwidget = htmlwidget-3a14
itcl = itcl3.4
itk = itk3.3
jpeg = jpeg-8d
libpng = libpng-1.6.15
lib = lib
openssl = openssl-1.0.1j
optimizer = optimizer
shape = shape0.4
sqlitetcl = sqlite-src-3080703
sqlitetcl = sqlite-3071502
tcl = tcl8.5.10
tcllib = tcllib-1.15
tdom = tDOM-0.8.3
tiff = tiff-4.0.3
tk = tk8.5.10
tkimg = tkimg1.4
tls = tls1.6
vtk = vtk-6.0.0
zlib = zlib
lang = lang
video = video
packages = pkgs
apps = apps

subdirs = \
	$(blt) $(cmake) $(expat) $(expect) \
	$(gui) $(htmlwidget) $(itcl) $(itk) $(lang) $(lib)  \
	$(optimizer) $(shape) \
	$(sqlitetcl) $(tcl) $(tcllib) $(tdom) $(tk) $(tkimg) \
	$(tls) $(vtk) $(zlib) $(apps)

ifneq ("$(WITH_VTK)", "no")
  vtk_timestamp = $(vtk)/timestamp
endif

clean:
	$(clean_apps)
	$(clean_blt)
	$(clean_cmake)
	$(clean_expat)
	$(clean_expect)
	$(clean_gui)
	$(clean_htmlwidget)
	$(clean_itcl)
	$(clean_itk)
	$(clean_lang)
	$(clean_lib)
	$(clean_optimizer)
	$(clean_shape)
	$(clean_sqlitetcl)
	$(clean_tcl)
	$(clean_tcllib)
	$(clean_tdom)
	$(clean_tk)
	$(clean_tkimg)
	$(clean_tls)
	$(clean_vtk)
	$(clean_zlib)

# -------------------------------------------------------------------------
#  APPS
# -------------------------------------------------------------------------

apps_flags =	\
	--enable-shared \
	$(common_flags)

apps: $(apps)/timestamp

clean-apps: 
	$(clean_apps)
fetch-apps: 
	$(fetch_apps)
configure-apps: 
	$(configure_apps)
build-apps: 
	$(build_apps)
install-apps: 
	$(install_apps)
touch-apps: 
	$(touch_apps)
force-apps: $(gui)/timestamp 
	+ $(clean_apps)
	+ $(fetch_apps)
	+ $(configure_apps)
	+ $(build_apps)
	+ $(install_apps)
	+ $(touch_apps)

define clean_apps
	$(MAKE) -C $(apps) clean
endef
define fetch_apps
endef
define configure_apps
endef
define build_apps
	$(MAKE) -C $(apps) all
endef
define install_apps
	$(MAKE) -C $(apps) install
endef
define touch_apps
	touch $(apps)/timestamp
endef

$(apps)/timestamp: $(gui)/timestamp 
	+ $(clean_apps)
	+ $(fetch_apps)
	+ $(configure_apps)
	+ $(build_apps)
	+ $(install_apps)
	+ $(touch_apps)


# -------------------------------------------------------------------------
#  BLT
# -------------------------------------------------------------------------

blt_flags =	\
		--enable-shared \
		$(common_flags)

blt: $(blt)/timestamp

clean-blt: 
	$(clean_blt)
fetch-blt: 
	$(fetch_blt)
configure-blt: 
	$(configure_blt)
build-blt: 
	$(build_blt)
install-blt: 
	$(install_blt)
touch-blt: 
	$(touch_blt)
force-blt: $(tcl)/timestamp $(tk)/timestamp
	+ $(clean_blt)
	+ $(fetch_blt)
	+ $(configure_blt)
	+ $(build_blt)
	+ $(install_blt)
	+ $(touch_blt)

define clean_blt
	$(RM) -r $(blt)
endef
define fetch_blt
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(blt)
endef
define configure_blt
	$(MKDIR_P) $(blt)
	cd $(blt); $(runtime)/$(blt)/configure $(blt_flags) 
endef
define build_blt
	$(MAKE)  -C $(blt) all
endef
define install_blt
	$(MAKE) -C $(blt) install
endef
define touch_blt
	touch $(blt)/timestamp
endef

$(blt)/timestamp: $(tcl)/timestamp $(tk)/timestamp
	+ $(clean_blt)
	+ $(fetch_blt)
	+ $(configure_blt)
	+ $(build_blt)
	+ $(install_blt)
	+ $(touch_blt)

# -------------------------------------------------------------------------
#  CMAKE
# -------------------------------------------------------------------------

cmake_flags =	\
	--prefix=$(prefix)

cmake: $(cmake)/timestamp

clean-cmake: 
	$(clean_cmake)
fetch-cmake: 
	$(fetch_cmake)
configure-cmake: 
	$(configure_cmake)
build-cmake: 
	$(build_cmake)
install-cmake: 
	$(install_cmake)
touch-cmake: 
	$(touch_cmake)
force-cmake: 
	+ $(clean_cmake)
	+ $(fetch_cmake)
	+ $(configure_cmake)
	+ $(build_cmake)
	+ $(install_cmake)
	+ $(touch_cmake)

define clean_cmake
	$(RM) -r $(cmake)
endef
define fetch_cmake
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(cmake)
endef
define configure_cmake
	$(MKDIR_P) $(cmake)
	cd $(cmake); $(runtime)/$(cmake)/configure $(cmake_flags) 
endef
define build_cmake
	$(MAKE)  -C $(cmake) all
endef
define install_cmake
	$(MAKE) -C $(cmake) install
endef
define touch_cmake
	touch $(cmake)/timestamp
endef

$(cmake)/timestamp: 
	+ $(clean_cmake)
	+ $(fetch_cmake)
	+ $(configure_cmake)
	+ $(build_cmake)
	+ $(install_cmake)
	+ $(touch_cmake)

# -------------------------------------------------------------------------
#  EXAMPLES
# -------------------------------------------------------------------------

examples_flags =	\
	--with-tclsh="$(bindir)/tclsh" \
	--enable-shared \
	$(common_flags)

examples: $(examples)/timestamp

clean-examples: 
	$(clean_examples)
fetch-examples: 
	$(fetch_examples)
configure-examples: 
	$(configure_examples)
build-examples: 
	$(build_examples)
install-examples: 
	$(install_examples)
touch-examples: 
	$(touch_examples)
force-examples: $(gui)/timestamp 
	+ $(clean_examples)
	+ $(fetch_examples)
	+ $(configure_examples)
	+ $(build_examples)
	+ $(install_examples)
	+ $(touch_examples)

define clean_examples
	$(MAKE) -C $(examples) clean
endef
define fetch_examples
endef
define configure_examples
	$(MKDIR_P) $(examples)
endef
define build_examples
	$(MAKE) -C $(examples) all
endef
define install_examples
	$(MAKE) -C $(examples) install
endef
define touch_examples
	touch $(examples)/timestamp
endef

$(examples)/timestamp: $(gui)/timestamp 
	+ $(clean_examples)
	+ $(fetch_examples)
	+ $(configure_examples)
	+ $(build_examples)
	+ $(install_examples)
	+ $(touch_examples)

# -------------------------------------------------------------------------
#  EXPAT
# -------------------------------------------------------------------------

expat_flags =	\
	--enable-shared \
	$(common_flags)

expat: $(expat)/timestamp

clean-expat: 
	$(clean_expat)
fetch-expat: 
	$(fetch_expat)
configure-expat: 
	$(configure_expat)
build-expat: 
	$(build_expat)
install-expat: 
	$(install_expat)
touch-expat: 
	$(touch_expat)
force-expat: 
	+ $(clean_expat)
	+ $(fetch_expat)
	+ $(configure_expat)
	+ $(build_expat)
	+ $(install_expat)
	+ $(touch_expat)

define clean_expat
	$(RM) -r $(expat)
endef
define fetch_expat
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(expat)
endef
define configure_expat
	$(MKDIR_P) $(expat)
	cd $(expat); $(runtime)/$(expat)/configure $(expat_flags) 
endef
define build_expat
	$(MAKE)  -C $(expat) all
endef
define install_expat
	$(MAKE) -C $(expat) install
endef
define touch_expat
	touch $(expat)/timestamp
endef

$(expat)/timestamp: 
	+ $(clean_expat)
	+ $(fetch_expat)
	+ $(configure_expat)
	+ $(build_expat)
	+ $(install_expat)
	+ $(touch_expat)

# -------------------------------------------------------------------------
#  EXPECT
# -------------------------------------------------------------------------

expect_flags =	\
	--enable-shared \
	--enable-64bit \
	--with-tcl=$(libdir) \
	--with-tclinclude=$(incdir) \
	$(common_flags)

expect: $(expect)/timestamp

clean-expect: 
	$(clean_expect)
fetch-expect: 
	$(fetch_expect)
configure-expect: 
	$(configure_expect)
build-expect: 
	$(build_expect)
install-expect: 
	$(install_expect)
touch-expect: 
	$(touch_expect)
force-expect: $(tcl)/timestamp $(tk)/timestamp
	+ $(clean_expect)
	+ $(fetch_expect)
	+ $(configure_expect)
	+ $(build_expect)
	+ $(install_expect)
	+ $(touch_expect)

define clean_expect
	$(RM) -r $(expect)
endef
define fetch_expect
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(expect)
endef
define configure_expect
	$(MKDIR_P) $(expect)
	cd $(expect); $(runtime)/$(expect)/configure $(expect_flags) 
endef
define build_expect
	$(MAKE)  -C $(expect) all
endef
define install_expect
	$(MAKE) -C $(expect) install
endef
define touch_expect
	touch $(expect)/timestamp
endef

$(expect)/timestamp: $(tcl)/timestamp $(tk)/timestamp
	+ $(clean_expect)
	+ $(fetch_expect)
	+ $(configure_expect)
	+ $(build_expect)
	+ $(install_expect)
	+ $(touch_expect)

# -------------------------------------------------------------------------
#  GUI
# -------------------------------------------------------------------------

gui_flags =	\
	$(common_flags)

gui: $(gui)/timestamp

clean-gui: 
	$(clean_gui)
fetch-gui: 
	$(fetch_gui)
configure-gui: 
	$(configure_gui)
build-gui: 
	$(build_gui)
install-gui: 
	$(install_gui)
touch-gui: 
	$(touch_gui)
force-gui: $(lib)/timestamp \
		  $(blt)/timestamp \
		  $(itk)/timestamp \
		  $(htmlwidget)/timestamp \
		  $(shape)/timestamp \
		  $(sqlitetcl)/timestamp \
		  $(vtk_timestamp)
	+ $(clean_gui)
	+ $(fetch_gui)
	+ $(configure_gui)
	+ $(build_gui)
	+ $(install_gui)
	+ $(touch_gui)

define clean_gui
	$(RM) -r $(gui)
endef
define fetch_gui
endef
define configure_gui
	$(MKDIR_P) $(gui)
	cd $(gui); $(srcdir)/$(gui)/configure $(gui_flags) 
endef
define build_gui
	$(MAKE) -C $(gui) all
endef
define install_gui
	$(MAKE) -C $(gui) install
endef
define touch_gui
	touch $(gui)/timestamp
endef

$(gui)/timestamp: $(lib)/timestamp \
		  $(blt)/timestamp \
		  $(itk)/timestamp \
		  $(htmlwidget)/timestamp \
		  $(shape)/timestamp \
		  $(tdom)/timestamp \
		  $(tcllib)/timestamp \
		  $(tls)/timestamp \
		  $(tkimg)/timestamp \
		  $(sqlitetcl)/timestamp \
		  $(vtk_timestamp)
	+ $(clean_gui)
	+ $(fetch_gui)
	+ $(configure_gui)
	+ $(build_gui)
	+ $(install_gui)
	+ $(touch_gui)

# -------------------------------------------------------------------------
#  HTMLWIDGET
# -------------------------------------------------------------------------

htmlwidget_flags = \
	--enable-shared \
	$(common_flags)

htmlwidget: $(htmlwidget)/timestamp

clean-htmlwidget: 
	$(clean_htmlwidget)
fetch-htmlwidget: 
	$(fetch_htmlwidget)
configure-htmlwidget: 
	$(configure_htmlwidget)
build-htmlwidget: 
	$(build_htmlwidget)
install-htmlwidget: 
	$(install_htmlwidget)
touch-htmlwidget: 
	$(touch_htmlwidget)
force-htmlwidget: $(tk)/timestamp
	+ $(clean_htmlwidget)
	+ $(fetch_htmlwidget)
	+ $(configure_htmlwidget)
	+ $(build_htmlwidget)
	+ $(install_htmlwidget)
	+ $(touch_htmlwidget)

define clean_htmlwidget
	$(RM) -r $(htmlwidget)
endef
define fetch_htmlwidget
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(htmlwidget)
endef
define configure_htmlwidget
	$(MKDIR_P) $(htmlwidget)
	cd $(htmlwidget); $(runtime)/$(htmlwidget)/configure $(htmlwidget_flags) 
endef
define build_htmlwidget
	$(MAKE) -C $(htmlwidget) all
endef
define install_htmlwidget
	$(MAKE) -C $(htmlwidget) install
endef
define touch_htmlwidget
	touch $(htmlwidget)/timestamp
endef

$(htmlwidget)/timestamp: $(tk)/timestamp
	+ $(clean_htmlwidget)
	+ $(fetch_htmlwidget)
	+ $(configure_htmlwidget)
	+ $(build_htmlwidget)
	+ $(install_htmlwidget)
	+ $(touch_htmlwidget)

# -------------------------------------------------------------------------
#  ITCL
# -------------------------------------------------------------------------

itcl_flags =	\
	--enable-shared \
	$(common_flags)

itcl: $(itcl)/timestamp

clean-itcl: 
	$(clean_itcl)
fetch-itcl: 
	$(fetch_itcl)
configure-itcl: 
	$(configure_itcl)
build-itcl: 
	$(build_itcl)
install-itcl: 
	$(install_itcl)
touch-itcl: 
	$(touch_itcl)
force-itcl: 
	+ $(clean_itcl)
	+ $(fetch_itcl)
	+ $(configure_itcl)
	+ $(build_itcl)
	+ $(install_itcl)
	+ $(touch_itcl)

define clean_itcl
	$(RM) -r $(itcl)
endef
define fetch_itcl
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(itcl)
endef
define configure_itcl
	$(MKDIR_P) $(itcl)
	cd $(itcl); $(runtime)/$(itcl)/configure $(itcl_flags) 
endef
define build_itcl
	$(MAKE)  -C $(itcl) all
endef
define install_itcl
	$(MAKE) -C $(itcl) install
endef
define touch_itcl
	touch $(itcl)/timestamp
endef

$(itcl)/timestamp: $(tcl)/timestamp
	+ $(clean_itcl)
	+ $(fetch_itcl)
	+ $(configure_itcl)
	+ $(build_itcl)
	+ $(install_itcl)
	+ $(touch_itcl)

# -------------------------------------------------------------------------
#  ITK
# -------------------------------------------------------------------------

itk_flags =	\
	--enable-shared \
	$(common_flags)

itk: $(itk)/timestamp

clean-itk: 
	$(clean_itk)
fetch-itk: 
	$(fetch_itk)
configure-itk: 
	$(configure_itk)
build-itk: 
	$(build_itk)
install-itk: 
	$(install_itk)
touch-itk: 
	$(touch_itk)
force-itk: $(itcl)/timestamp $(tk)/timestamp
	+ $(clean_itk)
	+ $(fetch_itk)
	+ $(configure_itk)
	+ $(build_itk)
	+ $(install_itk)
	+ $(touch_itk)

define clean_itk
	$(RM) -r $(itk)
endef
define fetch_itk
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(itk)
endef
define configure_itk
	$(MKDIR_P) $(itk)
	cd $(itk); $(runtime)/$(itk)/configure $(itk_flags) 
endef
define build_itk
	$(MAKE) -C $(itk) all
endef
define install_itk
	$(MAKE) -C $(itk) install
endef
define touch_itk
	touch $(itk)/timestamp
endef

$(itk)/timestamp: $(itcl)/timestamp $(tk)/timestamp
	+ $(clean_itk)
	+ $(fetch_itk)
	+ $(configure_itk)
	+ $(build_itk)
	+ $(install_itk)
	+ $(touch_itk)

# -------------------------------------------------------------------------
#  LANG
# -------------------------------------------------------------------------

lang_flags =	\
	--enable-shared \
	$(common_flags) \
	--with-R=${WITH_R} \
	--with-java=${WITH_JAVA} \
	--with-matlab=${WITH_MATLAB} \
	--with-mkoctfile2=${WITH_MKOCTFILE2} \
	--with-mkoctfile3=${WITH_MKOCTFILE3} \
	--with-octave=${WITH_OCTAVE} \
	--with-perl=${WITH_PERL} \
	--with-python=${WITH_PYTHON} \
	--with-ruby=${WITH_RUBY} \
	--with-ruby_sitelibdir=${WITH_RUBY_SITELIBDIR} 

lang: $(lang)/timestamp

clean-lang: 
	$(clean_lang)
fetch-lang: 
	$(fetch_lang)
configure-lang: 
	$(configure_lang)
build-lang: 
	$(build_lang)
install-lang: 
	$(install_lang)
touch-lang: 
	$(touch_lang)
force-lang: $(gui)/timestamp 
	+ $(clean_lang)
	+ $(fetch_lang)
	+ $(configure_lang)
	+ $(build_lang)
	+ $(install_lang)
	+ $(touch_lang)

define clean_lang
	$(RM) -r $(lang)
endef
define fetch_lang
endef
define configure_lang
	$(MKDIR_P) $(lang)
	cd $(lang); $(srcdir)/$(lang)/configure $(lang_flags) 
endef
define build_lang
	$(MAKE) -C $(lang) all
endef
define install_lang
	$(MAKE) -C $(lang) install
endef
define touch_lang
	touch $(lang)/timestamp
endef

$(lang)/timestamp: $(lib)/timestamp  $(tcl)/timestamp $(itcl)/timestamp
	+ $(clean_lang)
	+ $(fetch_lang)
	+ $(configure_lang)
	+ $(build_lang)
	+ $(install_lang)
	+ $(touch_lang)


# -------------------------------------------------------------------------
#  LIB
# -------------------------------------------------------------------------

lib_flags =	\
	--enable-shared \
	$(common_flags)

lib: $(lib)/timestamp

clean-lib: 
	$(clean_lib)
fetch-lib: 
	$(fetch_lib)
configure-lib: 
	$(configure_lib)
build-lib: 
	$(build_lib)
install-lib: 
	$(install_lib)
touch-lib: 
	$(touch_lib)
force-lib: 
	+ $(clean_lib)
	+ $(fetch_lib)
	+ $(configure_lib)
	+ $(build_lib)
	+ $(install_lib)
	+ $(touch_lib)

define clean_lib
	$(MAKE) -C $(lib) clean
	$(RM) $(lib)/timestamp
endef
define fetch_lib
endef
define configure_lib
endef
define build_lib
	$(MAKE) -C $(lib) all
endef
define install_lib
	$(MAKE) -C $(lib) install
	$(MKDIR_P) $(libdir)
	$(INSTALL) -m 0444 rapptureConfig.sh $(libdir)
endef
define touch_lib
	touch $(lib)/timestamp
endef

$(lib)/timestamp: 
	+ $(clean_lib)
	+ $(fetch_lib)
	+ $(configure_lib)
	+ $(build_lib)
	+ $(install_lib)
	+ $(touch_lib)

# -------------------------------------------------------------------------
#  OPTIMIZER
# -------------------------------------------------------------------------

optimizer_flags =	\
	--with-tclsh="$(bindir)/tclsh8.5" \
	--enable-shared \
	--disable-threads \
	$(common_flags)

optimizer: $(optimizer)/timestamp

clean-optimizer: 
	$(clean_optimizer)
fetch-optimizer: 
	$(fetch_optimizer)
configure-optimizer: 
	$(configure_optimizer)
build-optimizer: 
	$(build_optimizer)
install-optimizer: 
	$(install_optimizer)
touch-optimizer: 
	$(touch_optimizer)
force-optimizer: $(gui)/timestamp 
	+ $(clean_optimizer)
	+ $(fetch_optimizer)
	+ $(configure_optimizer)
	+ $(build_optimizer)
	+ $(install_optimizer)
	+ $(touch_optimizer)

define clean_optimizer
	$(RM) -r $(optimizer)
endef
define fetch_optimizer
endef
define configure_optimizer
	$(MKDIR_P) $(optimizer)
	cd $(optimizer); $(srcdir)/pkgs/$(optimizer)/configure $(optimizer_flags) 
endef
define build_optimizer
	$(MAKE) -C $(optimizer) all
endef
define install_optimizer
	$(MAKE) -C $(optimizer) install
endef
define touch_optimizer
	touch $(optimizer)/timestamp
endef

$(optimizer)/timestamp: $(gui)/timestamp 
	+ $(clean_optimizer)
	+ $(fetch_optimizer)
	+ $(configure_optimizer)
	+ $(build_optimizer)
	+ $(install_optimizer)
	+ $(touch_optimizer)


# -------------------------------------------------------------------------
#  PACKAGES
# -------------------------------------------------------------------------

packages_flags =	\
	$(common_flags)

packages: $(packages)/timestamp

clean-packages: 
	$(clean_packages)
fetch-packages: 
	$(fetch_packages)
configure-packages: 
	$(configure_packages)
build-packages: 
	$(build_packages)
install-packages: 
	$(install_packages)
touch-packages: 
	$(touch_packages)
force-packages: $(gui)/timestamp 
	+ $(clean_packages)
	+ $(fetch_packages)
	+ $(configure_packages)
	+ $(build_packages)
	+ $(install_packages)
	+ $(touch_packages)

define clean_packages
	$(RM) -r $(packages)
endef
define fetch_packages
endef
define configure_packages
	$(MKDIR_P) $(packages)
	cd $(packages); $(srcdir)/$(packages)/configure $(packages_flags)
endef
define build_packages
	$(MAKE) -C $(packages) all
endef
define install_packages
	$(MAKE) -C $(packages) install
endef
define touch_packages
	touch $(packages)/timestamp
endef

$(packages)/timestamp: $(gui)/timestamp 
	+ $(clean_packages)
	+ $(fetch_packages)
	+ $(configure_packages)
	+ $(build_packages)
	+ $(install_packages)
	+ $(touch_packages)

# -------------------------------------------------------------------------
#  SHAPE
# -------------------------------------------------------------------------

shape_flags =	\
	--enable-shared \
	--with-tclconf=$(libdir) \
	--with-tkconf=$(libdir) \
	$(common_flags)

shape: $(shape)/timestamp

clean-shape: 
	$(clean_shape)
fetch-shape: 
	$(fetch_shape)
configure-shape: 
	$(configure_shape)
build-shape: 
	$(build_shape)
install-shape: 
	$(install_shape)
touch-shape: 
	$(touch_shape)
force-shape: $(tk)/timestamp
	+ $(clean_shape)
	+ $(fetch_shape)
	+ $(configure_shape)
	+ $(build_shape)
	+ $(install_shape)
	+ $(touch_shape)

define clean_shape
	$(RM) -r $(shape)
endef
define fetch_shape
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(shape)
endef
define configure_shape
	$(MKDIR_P) $(shape)
	cd $(shape); $(runtime)/$(shape)/unix/configure $(shape_flags) 
endef
define build_shape
	$(MAKE) -C $(shape) all
endef
define install_shape
	$(MAKE) -C $(shape) install
endef
define touch_shape
	touch $(shape)/timestamp
endef

$(shape)/timestamp: $(tk)/timestamp
	+ $(clean_shape)
	+ $(fetch_shape)
	+ $(configure_shape)
	+ $(build_shape)
	+ $(install_shape)
	+ $(touch_shape)

# -------------------------------------------------------------------------
#  SQLITETCL
# -------------------------------------------------------------------------

sqlitetcl_flags = \
	--enable-shared \
	$(common_flags)

sqlitetcl: $(sqlitetcl)/timestamp

clean-sqlitetcl: 
	$(clean_sqlitetcl)
fetch-sqlitetcl: 
	$(fetch_sqlitetcl)
configure-sqlitetcl: 
	$(configure_sqlitetcl)
build-sqlitetcl: 
	$(build_sqlitetcl)
install-sqlitetcl: 
	$(install_sqlitetcl)
touch-sqlitetcl: 
	$(touch_sqlitetcl)
force-sqlitetcl: $(tcl)/timestamp
	+ $(clean_sqlitetcl)
	+ $(fetch_sqlitetcl)
	+ $(configure_sqlitetcl)
	+ $(build_sqlitetcl)
	+ $(install_sqlitetcl)
	+ $(touch_sqlitetcl)

define clean_sqlitetcl
	$(RM) -r $(sqlitetcl)
endef
define fetch_sqlitetcl
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(sqlitetcl)
endef
define configure_sqlitetcl
	$(MKDIR_P) $(sqlitetcl)
	cd $(sqlitetcl); $(runtime)/$(sqlitetcl)/tea/configure $(sqlitetcl_flags) 
endef
define build_sqlitetcl
	$(MAKE) -C $(sqlitetcl) all
endef
define install_sqlitetcl
	$(MAKE) -C $(sqlitetcl) install
endef
define touch_sqlitetcl
	touch $(sqlitetcl)/timestamp
endef

$(sqlitetcl)/timestamp: $(tcl)/timestamp
	+ $(clean_sqlitetcl)
	+ $(fetch_sqlitetcl)
	+ $(configure_sqlitetcl)
	+ $(build_sqlitetcl)
	+ $(install_sqlitetcl)
	+ $(touch_sqlitetcl)

# -------------------------------------------------------------------------
#  TCL
# -------------------------------------------------------------------------

tcl_flags =	\
	--enable-shared \
	--disable-threads \
	$(common_flags)

tcl: $(tcl)/timestamp

clean-tcl: 
	$(clean_tcl)
fetch-tcl:
	$(fetch_tcl)
configure-tcl: 
	$(configure_tcl)
build-tcl: 
	$(build_tcl)
install-tcl: 
	$(install_tcl)
touch-tcl: 
	$(touch_tcl)
force-tcl: 
	+ $(clean_tcl)
	+ $(fetch_tcl)
	+ $(configure_tcl)
	+ $(build_tcl)
	+ $(install_tcl)
	+ $(touch_tcl)

define fetch_tcl
	sh $(srcdir)/fetch.sh $(TAG) $(srcdir) $(tcl)
endef
define clean_tcl
	$(RM) -r $(tcl)
endef
define fetch_tcl
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(tcl)
endef
define configure_tcl
	$(MKDIR_P) $(tcl)
	cd $(tcl); $(srcdir)/runtime/$(tcl)/unix/configure $(tcl_flags) 
endef
define build_tcl
	$(MAKE)  -C $(tcl) all
endef
define install_tcl
	$(MAKE) -C $(tcl) install
	$(RM) $(bindir)/tclsh
	(. ${libdir}/tclConfig.sh ; cd $(bindir); $(LN_S) tclsh$${TCL_VERSION} tclsh)
endef
define touch_tcl
	touch $(tcl)/timestamp
endef

$(tcl)/timestamp: 
	+ $(clean_tcl)
	+ $(fetch_tcl)
	+ $(configure_tcl)
	+ $(build_tcl)
	+ $(install_tcl)
	+ $(touch_tcl)

# -------------------------------------------------------------------------
#  TCLLIB
# -------------------------------------------------------------------------

tcllib_flags =	\
	--enable-shared \
	$(common_flags)

tcllib: $(tcllib)/timestamp

clean-tcllib: 
	$(clean_tcllib)
fetch-tcllib: 
	$(fetch_tcllib)
configure-tcllib: 
	$(configure_tcllib)
build-tcllib: 
	$(build_tcllib)
install-tcllib: 
	$(install_tcllib)
touch-tcllib: 
	$(touch_tcllib)
force-tcllib: $(tcl)/timestamp
	+ $(clean_tcllib)
	+ $(fetch_tcllib)
	+ $(configure_tcllib)
	+ $(build_tcllib)
	+ $(install_tcllib)
	+ $(touch_tcllib)

define clean_tcllib
	$(RM) -r $(tcllib)
endef
define fetch_tcllib
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(tcllib)
endef
define configure_tcllib
	$(MKDIR_P) $(tcllib)
	cd $(tcllib); $(runtime)/$(tcllib)/configure $(tcllib_flags) 
endef
define build_tcllib
	$(MAKE) -C $(tcllib) all
endef
define install_tcllib
	$(MAKE) -C $(tcllib) install
endef
define touch_tcllib
	touch $(tcllib)/timestamp
endef

$(tcllib)/timestamp: $(tcl)/timestamp
	+ $(clean_tcllib)
	+ $(fetch_tcllib)
	+ $(configure_tcllib)
	+ $(build_tcllib)
	+ $(install_tcllib)
	+ $(touch_tcllib)

# -------------------------------------------------------------------------
#  TDOM
# -------------------------------------------------------------------------

tdom_flags =	\
	--enable-shared \
	$(common_flags)

tdom: $(tdom)/timestamp

clean-tdom: 
	$(clean_tdom)
fetch-tdom: 
	$(fetch_tdom)
configure-tdom: 
	$(configure_tdom)
build-tdom: 
	$(build_tdom)
install-tdom: 
	$(install_tdom)
touch-tdom: 
	$(touch_tdom)
force-tdom: $(tcl)/timestamp
	+ $(clean_tdom)
	+ $(fetch_tdom)
	+ $(configure_tdom)
	+ $(build_tdom)
	+ $(install_tdom)
	+ $(touch_tdom)

define clean_tdom
	$(RM) -r $(tdom)
endef
define fetch_tdom
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(tdom)
endef
define configure_tdom
	$(MKDIR_P) $(tdom)
	cd $(tdom); $(runtime)/$(tdom)/configure $(tdom_flags) 
endef
define build_tdom
	$(MAKE) -C $(tdom) all
endef
define install_tdom
	$(MAKE) -C $(tdom) install
endef
define touch_tdom
	touch $(tdom)/timestamp
endef

$(tdom)/timestamp: $(tcl)/timestamp
	+ $(clean_tdom)
	+ $(fetch_tdom)
	+ $(configure_tdom)
	+ $(build_tdom)
	+ $(install_tdom)
	+ $(touch_tdom)

# -------------------------------------------------------------------------
#  TK
# -------------------------------------------------------------------------

tk_flags =	\
	--enable-shared \
	--disable-threads \
	$(common_flags)

tk: $(tk)/timestamp

clean-tk: 
	$(clean_tk)
fetch-tk: 
	$(fetch_tk)
configure-tk: 
	$(configure_tk)
build-tk: 
	$(build_tk)
install-tk: 
	$(install_tk)
touch-tk: 
	$(touch_tk)
force-tk: $(tcl)/timestamp
	+ $(clean_tk)
	+ $(fetch_tk)
	+ $(configure_tk)
	+ $(build_tk)
	+ $(install_tk)
	+ $(touch_tk)

define clean_tk
	$(RM) -r $(tk)
endef
define fetch_tk
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(tk)
endef
define configure_tk
	$(MKDIR_P) $(tk)
	cd $(tk); $(runtime)/$(tk)/unix/configure $(tk_flags) 
endef
define build_tk
	$(MAKE)  -C $(tk) all
endef
define install_tk
	$(MAKE) -C $(tk) install
	$(RM) $(bindir)/wish
	(. $(libdir)/tkConfig.sh ; cd $(bindir); $(LN_S) wish$${TK_VERSION} wish)
endef
define touch_tk
	touch $(tk)/timestamp
endef

$(tk)/timestamp: $(tcl)/timestamp
	+ $(clean_tk)
	+ $(fetch_tk)
	+ $(configure_tk)
	+ $(build_tk)
	+ $(install_tk)
	+ $(touch_tk)

# -------------------------------------------------------------------------
#  TKING
# -------------------------------------------------------------------------

tkimg_flags =	\
	--enable-shared \
	$(common_flags)

tkimg: $(tkimg)/timestamp

clean-tkimg: 
	$(clean_tkimg)
fetch-tkimg: 
	$(fetch_tkimg)
configure-tkimg: 
	$(configure_tkimg)
build-tkimg: 
	$(build_tkimg)
install-tkimg: 
	$(install_tkimg)
touch-tkimg: 
	$(touch_tkimg)
force-tkimg: $(tk)/timestamp
	+ $(clean_tkimg)
	+ $(fetch_tkimg)
	+ $(configure_tkimg)
	+ $(build_tkimg)
	+ $(install_tkimg)
	+ $(touch_tkimg)

define clean_tkimg
	$(RM) -r $(tkimg)
endef
define fetch_tkimg
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(tkimg)
endef
define configure_tkimg
	$(MKDIR_P) $(tkimg)
	cd $(tkimg); $(runtime)/$(tkimg)/configure $(tkimg_flags) 
endef
define build_tkimg
	$(MAKE) -C $(tkimg) all
endef
define install_tkimg
	$(MAKE) -C $(tkimg) install
endef
define touch_tkimg
	touch $(tkimg)/timestamp
endef

$(tkimg)/timestamp: $(tk)/timestamp
	+ $(clean_tkimg)
	+ $(fetch_tkimg)
	+ $(configure_tkimg)
	+ $(build_tkimg)
	+ $(install_tkimg)
	+ $(touch_tkimg)

# -------------------------------------------------------------------------
#  TLS
# -------------------------------------------------------------------------

tls_flags =	\
	--enable-shared \
	$(common_flags)

tls: $(tls)/timestamp

clean-tls: 
	$(clean_tls)
fetch-tls: 
	$(fetch_tls)
configure-tls: 
	$(configure_tls)
build-tls: 
	$(build_tls)
install-tls: 
	$(install_tls)
touch-tls: 
	$(touch_tls)
force-tls: $(tcl)/timestamp
	+ $(clean_tls)
	+ $(fetch_tls)
	+ $(configure_tls)
	+ $(build_tls)
	+ $(install_tls)
	+ $(touch_tls)

define clean_tls
	$(RM) -r $(tls)
endef
define fetch_tls
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(tls)
endef
define configure_tls
	$(MKDIR_P) $(tls)
	cd $(tls); $(runtime)/$(tls)/configure $(tls_flags) 
endef
define build_tls
	$(MAKE) -C $(tls) all
endef
define install_tls
	$(MAKE) -C $(tls) install
endef
define touch_tls
	touch $(tls)/timestamp
endef

$(tls)/timestamp: $(tcl)/timestamp
	+ $(clean_tls)
	+ $(fetch_tls)
	+ $(configure_tls)
	+ $(build_tls)
	+ $(install_tls)
	+ $(touch_tls)

# -------------------------------------------------------------------------
#  VIDEO
# -------------------------------------------------------------------------

video_flags =	\
	--with-tclsh="$(bindir)/tclsh" \
	--enable-shared \
	$(common_flags)

video: $(video)/timestamp

clean-video: 
	$(clean_video)
fetch-video: 
	$(fetch_video)
configure-video: 
	$(configure_video)
build-video: 
	$(build_video)
install-video: 
	$(install_video)
touch-video: 
	$(touch_video)
force-video: #$(gui)/timestamp 
	+ $(clean_video)
	+ $(fetch_video)
	+ $(configure_video)
	+ $(build_video)
	+ $(install_video)
	+ $(touch_video)

define clean_video
	$(RM) -r $(video)
endef
define fetch_video
endef
define configure_video
	$(MKDIR_P) $(video)
	cd $(video); $(srcdir)/pkgs/$(video)/configure $(video_flags) 
endef
define build_video
	$(MAKE) -C $(video) all
endef
define install_video
	$(MAKE) -C $(video) install
endef
define touch_video
	touch $(video)/timestamp
endef

$(video)/timestamp: $(gui)/timestamp 
	+ $(clean_video)
	+ $(fetch_video)
	+ $(configure_video)
	+ $(build_video)
	+ $(install_video)
	+ $(touch_video)

# -------------------------------------------------------------------------
#  VTK
# -------------------------------------------------------------------------

vtk_flags =	\
	$(common_flags)

vtk: $(vtk)/timestamp

clean-vtk: 
	$(clean_vtk)
fetch-vtk: 
	$(fetch_vtk)
configure-vtk: 
	$(configure_vtk)
build-vtk: 
	$(build_vtk)
install-vtk: 
	$(install_vtk)
touch-vtk: 
	$(touch_vtk)
force-vtk: $(cmake)/timestamp $(tcl)/timestamp $(tk)/timestamp
	+ $(clean_vtk)
	+ $(fetch_vtk)
	+ $(configure_vtk)
	+ $(build_vtk)
	+ $(install_vtk)
	+ $(touch_vtk)

define clean_vtk
	$(RM) -r $(vtk)
endef
define fetch_vtk
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(vtk)
endef
define configure_vtk
	$(MKDIR_P) $(vtk)
	cd $(vtk); $(runtime)/$(vtk)/configure $(vtk_flags) 
endef
define build_vtk
	$(MAKE)  -C $(vtk) all
endef
define install_vtk
	$(MAKE) -C $(vtk) install
	$(INSTALL) -m 0444 $(vtk)/vtkConfig.sh $(libdir)
	$(RM) $(includedir)/vtk
	(. $(libdir)/vtkConfig.sh ; cd $(includedir); $(LN_S) vtk-$${VTK_VERSION} vtk)
	$(RM) $(libdir)/tcltk/vtk
	(. $(libdir)/vtkConfig.sh ; cd $(libdir)/tcltk; $(LN_S) vtk-$${VTK_VERSION} vtk)
endef
define touch_vtk
	touch $(vtk)/timestamp
endef

$(vtk)/timestamp: $(cmake)/timestamp $(tcl)/timestamp $(tk)/timestamp
	+ $(clean_vtk)
	+ $(fetch_vtk)
	+ $(configure_vtk)
	+ $(build_vtk)
	+ $(install_vtk)
	+ $(touch_vtk)

# -------------------------------------------------------------------------
#  ZLIB
# -------------------------------------------------------------------------

zlib_flags =	\
	--enable-shared \
	$(common_flags)

zlib: $(zlib)/timestamp

clean-zlib: 
	$(clean_zlib)
fetch-zlib: 
	$(fetch_zlib)
configure-zlib: 
	$(configure_zlib)
build-zlib: 
	$(build_zlib)
install-zlib: 
	$(install_zlib)
touch-zlib: 
	$(touch_zlib)
force-zlib: 
	+ $(clean_zlib)
	+ $(fetch_zlib)
	+ $(configure_zlib)
	+ $(build_zlib)
	+ $(install_zlib)
	+ $(touch_zlib)

define clean_zlib
	$(RM) -r $(zlib)
endef
define fetch_zlib
	sh $(srcdir)/fetch.sh $(TAG) $(runtime) $(zlib)
endef
define configure_zlib
	$(MKDIR_P) $(zlib)
	cd $(zlib); $(runtime)/$(zlib)/configure $(zlib_flags) 
endef
define build_zlib
	$(MAKE) -C $(zlib) all
endef
define install_zlib
	$(MAKE) -C $(zlib) install
endef
define touch_zlib
	touch $(zlib)/timestamp
endef

$(zlib)/timestamp: 
	+ $(clean_zlib)
	+ $(fetch_zlib)
	+ $(configure_zlib)
	+ $(build_zlib)
	+ $(install_zlib)
	+ $(touch_zlib)


TRASH = \
	./bin/bltsh30 \
	./bin/bltwish30 \
	./bin/dtplite \
	./bin/flowvis-test \
	./bin/mapviewer-test \
	./bin/nanovis-test \
	./bin/nns \
	./bin/nnsd \
	./bin/nnslog \
	./bin/page \
	./bin/tcldocstrip \
	./bin/vtkglyphs-test \
	./bin/vtkheightmap-test \
	./bin/vtkisosurface-test \
	./bin/vtkstreamlines-test \
	./bin/vtkviewer-test \
	./bin/vtkvolume-test \
	./lib/bltConfig.sh \
	./lib/itclConfig.sh \
	./lib/jpegtclConfig.sh \
	./lib/libBltTcl30.so \
	./lib/libBltTk30.so \
	./lib/pngtclConfig.sh \
	./lib/tdomConfig.sh \
	./lib/tifftclConfig.sh \
	./lib/tkConfig.sh \
	./lib/tkimgConfig.sh \
	./lib/zlibtclConfig.sh \
	./man \
	./share 

installdir =	rappture_install
tmpdir =	/tmp/$(installdir)
arch =		$(shell uname -m)
package: 
	$(RM) -r $(tmpdir)
	$(MKDIR_P) $(tmpdir)
	tar -C $(DESTDIR)$(exec_prefix) -clf - . | tar -C $(tmpdir) -xpf - 
	for i in $(TRASH); do \
	   $(RM) -r $(tmpdir)/$$i ; \
	done
	$(bindir)/bltsh30 fixrunpaths.tcl $(tmpdir)
	tar -C /tmp -zclf rappture$(version)-linux-$(arch).tar.gz $(installdir)
	$(RM) -r $(tmpdir)