gtk/configure.in

# Process this file with autoconf to produce a configure script.
# require autoconf 2.54
AC_PREREQ(2.54)

# Making releases:
#   GTK_MICRO_VERSION += 1;
#   GTK_INTERFACE_AGE += 1;
#   GTK_BINARY_AGE += 1;
# if any functions have been added, set GTK_INTERFACE_AGE to 0.
# if backwards compatibility has been broken,
# set GTK_BINARY_AGE and GTK_INTERFACE_AGE to 0.

m4_define([gtk_major_version], [2])
m4_define([gtk_minor_version], [3])
m4_define([gtk_micro_version], [1])
m4_define([gtk_version],
          [gtk_major_version.gtk_minor_version.gtk_micro_version])
m4_define([gtk_interface_age], [0])
m4_define([gtk_binary_age], [301])
# This is the X.Y used in -lgtk-FOO-X.Y
m4_define([gtk_api_version], [2.0])

# Define a string for the earliest version that this release has
# forward/backwards binary compatibility with. This is used for module
# locations. (Should this be backwards-compat instead?)
#
#GTK_BINARY_VERSION=$GTK_MAJOR_VERSION.$GTK_MINOR_VERSION.$LT_CURRENT
m4_define([gtk_binary_version], [2.2.0])

# required versions of other packages
m4_define([glib_required_version], [2.3.0])
m4_define([pango_required_version], [1.2.0])
m4_define([atk_required_version], [1.0.1])


AC_INIT([gtk+], [gtk_version],
        [http://bugzilla.gnome.org/enter_bug.cgi?product=gtk+],
	[gtk+])

AC_CONFIG_SRCDIR([gdk/gdktypes.h])

# Save this value here, since automake will set cflags later
cflags_set=${CFLAGS+set}

AM_INIT_AUTOMAKE(no-define)
AM_CONFIG_HEADER(config.h)

#
# For each of the libraries we build, we define the following
# substituted variables:
#
# foo_PACKAGES:     pkg-config packages this library requires
# foo_EXTRA_LIBS:   Libraries this module requires not pulled in by pkg-config
# foo_EXTRA_CFLAGS: cflags this module requires not pulled in by pkg-config
# foo_DEP_LIBS:     All libraries this module requires
# foo_DEP_CFLAGS:   All cflags this module requires


GTK_MAJOR_VERSION=gtk_major_version
GTK_MINOR_VERSION=gtk_minor_version
GTK_MICRO_VERSION=gtk_micro_version
GTK_INTERFACE_AGE=gtk_interface_age
GTK_BINARY_AGE=gtk_binary_age
GTK_VERSION=gtk_version
GTK_API_VERSION=gtk_api_version
GTK_BINARY_VERSION=gtk_binary_version
AC_SUBST(GTK_MAJOR_VERSION)
AC_SUBST(GTK_MINOR_VERSION)
AC_SUBST(GTK_MICRO_VERSION)
AC_SUBST(GTK_INTERFACE_AGE)
AC_SUBST(GTK_BINARY_AGE)
AC_SUBST(GTK_API_VERSION)
AC_SUBST(GTK_VERSION)
AC_SUBST(GTK_BINARY_VERSION)

# libtool versioning
#LT_RELEASE=$GTK_MAJOR_VERSION.$GTK_MINOR_VERSION
#LT_CURRENT=`expr $GTK_MICRO_VERSION - $GTK_INTERFACE_AGE`
#LT_REVISION=$GTK_INTERFACE_AGE
#LT_AGE=`expr $GTK_BINARY_AGE - $GTK_INTERFACE_AGE`
#LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE`

m4_define([lt_current], [m4_eval(100 * gtk_minor_version + gtk_micro_version - gtk_interface_age)])
m4_define([lt_revision], [gtk_interface_age])
m4_define([lt_age], [m4_eval(gtk_binary_age - gtk_interface_age)])
LT_VERSION_INFO="lt_current:lt_revision:lt_age"
LT_CURRENT_MINUS_AGE=m4_eval(lt_current - lt_age)
AC_SUBST(LT_VERSION_INFO)
AC_SUBST(LT_CURRENT_MINUS_AGE)


#
# gdk-pixbuf gets versioned separately, and for now, using standard
# libtool versioning, not GTK+-style versioning
#
GDK_PIXBUF_MAJOR=gtk_major_version
GDK_PIXBUF_MINOR=gtk_minor_version
GDK_PIXBUF_MICRO=gtk_micro_version
GDK_PIXBUF_VERSION="${GDK_PIXBUF_MAJOR}.${GDK_PIXBUF_MINOR}.${GDK_PIXBUF_MICRO}"
AC_SUBST(GDK_PIXBUF_MAJOR)
AC_SUBST(GDK_PIXBUF_MINOR)
AC_SUBST(GDK_PIXBUF_MICRO)
AC_SUBST(GDK_PIXBUF_VERSION)

GETTEXT_PACKAGE=gtk20
AC_SUBST(GETTEXT_PACKAGE)
AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE,"$GETTEXT_PACKAGE")


dnl Initialize libtool
AC_PROG_CC
AM_DISABLE_STATIC
AC_LIBTOOL_WIN32_DLL
AM_PROG_LIBTOOL

AM_PROG_AS

dnl Initialize maintainer mode
AM_MAINTAINER_MODE

AC_CANONICAL_HOST

AC_MSG_CHECKING([for some Win32 platform])
case "$host" in
  *-*-mingw*|*-*-cygwin*)
    platform_win32=yes
    ;;
  *)
    platform_win32=no
    ;;
esac
AC_MSG_RESULT([$platform_win32])
AM_CONDITIONAL(PLATFORM_WIN32, test "$platform_win32" = "yes")

MATH_LIB=-lm
AC_MSG_CHECKING([for native Win32])
case "$host" in
  *-*-mingw*)
    os_win32=yes
    MATH_LIB=
    ;;
  *)
    os_win32=no
    ;;
esac
AC_MSG_RESULT([$os_win32])
AM_CONDITIONAL(OS_WIN32, test "$os_win32" = "yes")
AM_CONDITIONAL(OS_UNIX, test "$os_win32" != "yes")

if test "$os_win32" = "yes"; then
  AC_CHECK_PROG(ms_librarian, lib.exe, yes, no)
fi
AM_CONDITIONAL(MS_LIB_AVAILABLE, test x$ms_librarian = xyes)

m4_define([debug_default],
          m4_if(m4_eval(gtk_minor_version % 2), [1], [yes], [minimum]))

dnl declare --enable-* args and collect ac_help strings
AC_ARG_ENABLE(debug,
              AC_HELP_STRING([--enable-debug=@<:@no/minimum/yes@:>@],
                             [turn on debugging @<:@default=debug_default@:>@]),,
              enable_debug=debug_default)
AC_ARG_ENABLE(shm,
              [AC_HELP_STRING([--enable-shm],
                              [support shared memory if available [default=yes]])],,
              [enable_shm="yes"])
AC_ARG_ENABLE(ansi,
              [AC_HELP_STRING([--enable-ansi],
                              [turn on strict ansi [default=no]])],,
              [enable_ansi=no])
AC_ARG_ENABLE(xkb,
              [AC_HELP_STRING([--enable-xkb],
                              [support XKB [default=maybe]])],,
              [enable_xkb="maybe"])
AC_ARG_ENABLE(rebuilds,
              [AC_HELP_STRING([--disable-rebuilds],
                              [disable all source autogeneration rules])],,
              [enable_rebuilds=yes])

AC_ARG_WITH(xinput,
            [AC_HELP_STRING([--with-xinput=@<:@no/yes@:>@], [support XInput])])

AC_ARG_WITH(wintab,
            [AC_HELP_STRING([--with-wintab=DIRECTORY],
                            [use Wintab API with win32 backend])])
AC_ARG_WITH(ie55,
            [AC_HELP_STRING([--with-ie55=DIRECTORY],
                            [IE5.5 libs and headers (for Active IMM)])])

GLIB_AC_DIVERT_BEFORE_HELP([
if test "$platform_win32" = yes; then
  gdktarget=win32
else
  gdktarget=x11
fi
])

AC_ARG_WITH(gdktarget, [  --with-gdktarget=[[x11/linux-fb/win32]] select GDK target [default=$gdktarget]],
	gdktarget=$with_gdktarget)

AC_SUBST(gdktarget)
case $gdktarget in
  x11|linux-fb|win32) ;;
  *) AC_MSG_ERROR([Invalid target for GDK: use x11, linux-fb or win32.]);;
esac

gdktargetlib=libgdk-$gdktarget-$GTK_API_VERSION.la
gtktargetlib=libgtk-$gdktarget-$GTK_API_VERSION.la

AC_SUBST(gdktargetlib)
AC_SUBST(gtktargetlib)

AC_ARG_ENABLE(shadowfb,
              [AC_HELP_STRING([--disable-shadowfb],
                              [disable shadowfb support for linux-fb])],,
              [enable_shadowfb=yes])

AC_ARG_ENABLE(fbmanager,
              [AC_HELP_STRING([--enable-fbmanager],
                              [enable framebuffer manager support (GtkFB)])],,
              enable_fbmanager=no)
	
if test "x$enable_debug" = "xyes"; then
  test "$cflags_set" = set || CFLAGS="$CFLAGS -g"
  GTK_DEBUG_FLAGS="-DG_ENABLE_DEBUG"
else
  if test "x$enable_debug" = "xno"; then
    GTK_DEBUG_FLAGS="-DG_DISABLE_ASSERT -DG_DISABLE_CHECKS -DG_DISABLE_CAST_CHECKS"
  else
    GTK_DEBUG_FLAGS="-DG_DISABLE_CAST_CHECKS"
  fi
fi

AC_DEFINE_UNQUOTED(GTK_COMPILED_WITH_DEBUGGING, "${enable_debug}")

			
# Build time sanity check...
AM_SANITY_CHECK

# Checks for programs.
AC_ISC_POSIX
AM_PROG_CC_STDC
AC_PROG_INSTALL
AC_PROG_MAKE_SET

changequote(,)dnl
if test "x$GCC" = "xyes"; then
  case " $CFLAGS " in
  *[\ \	]-Wall[\ \	]*) ;;
  *) CFLAGS="$CFLAGS -Wall" ;;
  esac

  if test "x$enable_ansi" = "xyes"; then
    case " $CFLAGS " in
    *[\ \	]-ansi[\ \	]*) ;;
    *) CFLAGS="$CFLAGS -ansi" ;;
    esac

    case " $CFLAGS " in
    *[\ \	]-pedantic[\ \	]*) ;;
    *) CFLAGS="$CFLAGS -pedantic" ;;
    esac
  fi
fi
changequote([,])dnl

# Ensure MSVC-compatible struct packing convention is used when
# compiling for Win32 with gcc.
# What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
# gcc2 uses "-fnative-struct".
if test x"$os_win32" = xyes; then
  if test x"$GCC" = xyes; then
    msnative_struct=''
    AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
    if test -z "$ac_cv_prog_CC"; then
      our_gcc="$CC"
    else
      our_gcc="$ac_cv_prog_CC"
    fi
    case `$our_gcc --version | sed -e 's,\..*,.,' -e q` in
      2.)
	if $our_gcc -v --help 2>/dev/null | grep fnative-struct >/dev/null; then
	  msnative_struct='-fnative-struct'
	fi
	;;
      *)
	if $our_gcc -v --help 2>/dev/null | grep ms-bitfields >/dev/null; then
	  msnative_struct='-mms-bitfields'
	fi
	;;
    esac
    if test x"$msnative_struct" = x ; then
      AC_MSG_RESULT([no way])
      AC_MSG_WARN([produced libraries might be incompatible with MSVC-compiled code])
    else
      CFLAGS="$CFLAGS $msnative_struct"
      AC_MSG_RESULT([${msnative_struct}])
    fi
  fi
fi

# Honor aclocal flags
ACLOCAL="$ACLOCAL $ACLOCAL_FLAGS"

## Initial sanity check, done here so that users get told they 
## have the wrong dependencies as early in the process as possible.
## Later on we actually use the cflags/libs from separate pkg-config
## calls. Oh, also the later pkg-config calls don't include 
## the version requirements since those make the module lists 
## annoying to construct
PKG_CHECK_MODULES(BASE_DEPENDENCIES,
  [glib-2.0 >= glib_required_version dnl
   atk >= atk_required_version dnl
   pango >= pango_required_version])

if test "$os_win32" != yes; then
    # libtool option to control which symbols are exported
    # right now, symbols starting with _ are not exported
    LIBTOOL_EXPORT_OPTIONS='-export-symbols-regex "^[[^_]].*"'
else
    # We currently use .def files on Windows (for gdk-pixbuf, gdk and gtk)
    LIBTOOL_EXPORT_OPTIONS=
fi
AC_SUBST(LIBTOOL_EXPORT_OPTIONS)

dnl ******************************************************
dnl * See whether to include shared library dependencies *
dnl ******************************************************

AC_ARG_ENABLE(explicit-deps, 
              [AC_HELP_STRING([--enable-explicit-deps=@<:@yes/no/auto@:>@],
                              [use explicit dependencies in .pc files [default=auto]])],,
              [enable_explicit_deps=auto])

AC_MSG_CHECKING([Whether to write dependencies into .pc files])
case $enable_explicit_deps in
  auto)
    deplib_check_method=`(./libtool --config; echo eval echo \\$deplib_check_method) | sh`
    if test "X$deplib_check_method" = Xnone || test "x$enable_static" = xyes ; then
      enable_explicit_deps=yes  
    else
      enable_explicit_deps=no  
    fi
  ;;
  yes|no) 
  ;;
  *) AC_MSG_ERROR([Value given to --enable-explicit-deps must be one of yes, no or auto])
  ;;
esac
AC_MSG_RESULT($enable_explicit_deps)

AM_CONDITIONAL(DISABLE_EXPLICIT_DEPS, test $enable_explicit_deps = no)

# define a MAINT-like variable REBUILD which is set if Perl
# and awk are found, so autogenerated sources can be rebuilt

AC_PATH_PROGS(PERL, perl5 perl)

# We would like indent, but don't require it.
AC_CHECK_PROG(INDENT, indent, indent)

REBUILD=\#
if test "x$enable_rebuilds" = "xyes" && \
     test -n "$PERL" && \
     $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 ; then
  REBUILD=
fi
AC_SUBST(REBUILD)

AC_CHECK_FUNCS(lstat mkstemp flockfile)

# sigsetjmp is a macro on some platforms, so AC_CHECK_FUNCS is not reliable
AC_MSG_CHECKING(for sigsetjmp)
AC_TRY_LINK([#include <setjmp.h>], [
sigjmp_buf env;
sigsetjmp(env, 0);
], gtk_ok=yes, gtk_ok=no)
AC_MSG_RESULT($gtk_ok)
if test "$gtk_ok" = "yes"; then
  AC_DEFINE(HAVE_SIGSETJMP)
fi

AC_MSG_CHECKING(whether make is GNU Make)
STRIP_BEGIN=
STRIP_END=
if $ac_make --version 2>/dev/null | grep '^GNU Make ' >/dev/null ; then
	STRIP_BEGIN='$(strip $(STRIP_DUMMY)'
	STRIP_END=')'
	AC_MSG_RESULT(yes)
else
	AC_MSG_RESULT(no)
fi
STRIP_DUMMY=
AC_SUBST(STRIP_DUMMY)
AC_SUBST(STRIP_BEGIN)
AC_SUBST(STRIP_END)

# i18n stuff
ALL_LINGUAS="am ar az be bg ca cs cy da de el en_GB es et eu fa fi fr ga gl he hi hr hu ia id it ja ko li lt lv mk ml mn ms ne nl nn no pl pt pt_BR ro ru sk sl sq sr sr@Latn sv ta th tr uk uz uz@Cyrl vi wa yi zh_CN zh_TW"
AM_GLIB_GNU_GETTEXT
LIBS="$LIBS $INTLLIBS"

AM_GLIB_DEFINE_LOCALEDIR(GTK_LOCALEDIR)

dnl The DU4 header files don't provide library prototypes unless 
dnl -std1 is given to the native cc.
AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])

gtk_save_LIBS=$LIBS
LIBS="$LIBS -lm"
AC_TRY_RUN([#include <math.h>
             int main (void) { return (log(1) != log(1.)); }],
     AC_MSG_RESULT(none needed),
     gtk_save_CFLAGS="$CFLAGS"
     CFLAGS="$CFLAGS -std1"
     AC_TRY_RUN([#include <math.h>
	         int main (void) { return (log(1) != log(1.)); }],
         AC_MSG_RESULT(-std1),
         AC_MSG_RESULT()
         CFLAGS="$gtk_save_CFLAGS"
         AC_MSG_WARN(
                [No ANSI prototypes found in library. (-std1 didn't work.)]),
	 true
     ),
     AC_MSG_RESULT(none needed)
)
LIBS=$gtk_save_LIBS

AC_MSG_CHECKING(for the BeOS)
case $host in
  *-*-beos*)
    AC_MSG_RESULT(yes)
    MATH_LIB=
  ;;
  *)
    AC_MSG_RESULT(no)
  ;;
esac

dnl NeXTStep cc seems to need this
AC_MSG_CHECKING([for extra flags for POSIX compliance])
AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
  AC_MSG_RESULT(none needed),
  gtk_save_CFLAGS="$CFLAGS"
  CFLAGS="$CFLAGS -posix"
  AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
    AC_MSG_RESULT(-posix),
    AC_MSG_RESULT()
    CFLAGS="$gtk_save_CFLAGS"
    AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))

#
# Run AM_PATH_GLIB_2_0 to make sure that GLib is installed and working
# 

GLIB_PACKAGES="gobject-2.0 gmodule-2.0"

AM_PATH_GLIB_2_0(glib_required_version, :,
  AC_MSG_ERROR([
*** GLIB glib_required_version or better is required. The latest version of 
*** GLIB is always available from ftp://ftp.gtk.org/pub/gtk/.]),
  gobject gmodule gthread)

dnl
dnl Check for bind_textdomain_codeset, including -lintl if GLib brings it in.
dnl
gtk_save_LIBS=$LIBS
LIBS="$LIBS $GLIB_LIBS"
AC_CHECK_FUNCS(bind_textdomain_codeset)
LIBS=$gtk_save_LIBS

AC_CHECK_HEADERS(pwd.h, AC_DEFINE(HAVE_PWD_H))
AC_CHECK_HEADERS(sys/time.h, AC_DEFINE(HAVE_SYS_TIME_H))
AC_CHECK_HEADERS(unistd.h, AC_DEFINE(HAVE_UNISTD_H))

if test "${with_ie55+set}" = set && test $with_ie55 != no; then
  AC_MSG_CHECKING([for dimm.h])
  saved_CFLAGS="$CFLAGS"
  CFLAGS="$CFLAGS -idirafter $with_ie55/Include"
  AC_TRY_COMPILE([/* The w32api imm.h clashes a bit with the IE5.5 dimm.h */
#ifdef __GNUC__
#define IMEMENUITEMINFOA hidden_IMEMENUITEMINFOA
#define IMEMENUITEMINFOW hidden_IMEMENUITEMINFOW
#endif
#include <windows.h>
#include <objbase.h>
#include <imm.h>
#ifdef __GNUC__
#undef IMEMENUITEMINFOA
#undef IMEMENUITEMINFOW
#endif
#include <dimm.h>
],
   [],
   [AC_MSG_RESULT(yes)
    AC_MSG_CHECKING([for IE55 uuid.lib])
    if test -f $with_ie55/Lib/uuid.lib ; then
      AC_MSG_RESULT(yes)
      have_ie55=yes
      AC_DEFINE(HAVE_DIMM_H)
      IE55_UUID_LIB="$with_ie55/Lib/uuid.lib"
      AC_SUBST(IE55_UUID_LIB)
    else
      AC_MSG_RESULT(no)
      CFLAGS="$saved_CFLAGS"
      have_ie55=no
    fi
    ],
   [AC_MSG_RESULT(no)
    CFLAGS="$saved_CFLAGS"
    have_ie55=no])
fi
AM_CONDITIONAL(HAVE_IE55, test x$have_ie55 = xyes)

if test "${with_wintab+set}" = set && test $with_wintab != no; then
  AC_MSG_CHECKING([for wintab.h])
  saved_CFLAGS="$CFLAGS"
  CFLAGS="$CFLAGS -I$with_wintab/include"
  AC_TRY_COMPILE([#include <windows.h>
#include <wintab.h>], 
   [],
   [AC_MSG_RESULT(yes)
    AC_MSG_CHECKING([for wntab32x.lib])
    if test -f $with_wintab/lib/i386/wntab32x.lib ; then
      AC_MSG_RESULT(yes)
      have_wintab=yes
      AC_DEFINE(HAVE_WINTAB)
      WINTAB_LIB="$with_wintab/lib/i386/wntab32x.lib"
      AC_SUBST(WINTAB_LIB)
    else
      AC_MSG_RESULT(no)
      CFLAGS="$saved_cflags"
      have_wintab=no
    fi
    ],
   [AC_MSG_RESULT(no)
    CFLAGS="$saved_cflags"
    have_wintab=no])
fi
AM_CONDITIONAL(HAVE_WINTAB, test x$have_wintab = xyes)

saved_cflags="$CFLAGS"
saved_ldflags="$LDFLAGS"


# Checks for header files.
AC_HEADER_STDC

# Checks for typedefs, structures, and compiler characteristics.
AC_C_CONST

# Checks for library functions.
AC_TYPE_SIGNAL
AC_FUNC_MMAP

AC_CHECK_FUNCS(getresuid)
AC_TYPE_UID_T

# Check if <sys/select.h> needs to be included for fd_set
AC_MSG_CHECKING([for fd_set])
AC_TRY_COMPILE([#include <sys/types.h>],
        [fd_set readMask, writeMask;], gtk_ok=yes, gtk_ok=no)
if test $gtk_ok = yes; then
    AC_MSG_RESULT([yes, found in sys/types.h])
else
    AC_HEADER_EGREP(fd_mask, sys/select.h, gtk_ok=yes)
    if test $gtk_ok = yes; then
        AC_DEFINE(HAVE_SYS_SELECT_H)
        AC_MSG_RESULT([yes, found in sys/select.h])
    else
	AC_DEFINE(NO_FD_SET)
	AC_MSG_RESULT(no)
    fi
fi

# `widechar' tests for gdki18n.h
AC_MSG_CHECKING(for wchar.h)
AC_TRY_CPP([#include <wchar.h>], gdk_wchar_h=yes, gdk_wchar_h=no)
if test $gdk_wchar_h = yes; then
   AC_DEFINE(HAVE_WCHAR_H,1,[Have wchar.h include file])
fi
AC_MSG_RESULT($gdk_wchar_h)

# Check for wctype.h (for iswalnum)
AC_MSG_CHECKING(for wctype.h)
AC_TRY_CPP([#include <wctype.h>], gdk_wctype_h=yes, gdk_wctype_h=no)
if test $gdk_wctype_h = yes; then
   AC_DEFINE(HAVE_WCTYPE_H,1,[Have wctype.h include file])
fi
AC_MSG_RESULT($gdk_wctype_h)

# in Solaris 2.5, `iswalnum' is in -lw
GDK_WLIBS=
AC_CHECK_FUNC(iswalnum,,[AC_CHECK_LIB(w,iswalnum,GDK_WLIBS=-lw)])

oLIBS="$LIBS"
LIBS="$LIBS $GDK_WLIBS"
# The following is necessary for Linux libc-5.4.38
AC_MSG_CHECKING(if iswalnum() and friends are properly defined)
AC_TRY_LINK([#include <stdlib.h>],[
#if (defined(HAVE_WCTYPE_H) || defined(HAVE_WCHAR_H))
#  ifdef HAVE_WCTYPE_H
#    include <wctype.h>
#  else
#    ifdef HAVE_WCHAR_H
#      include <wchar.h>
#    endif
#  endif
#else
#  define iswalnum(c) ((wchar_t)(c) <= 0xFF && isalnum(c))
#endif
iswalnum((wchar_t) 0);
], gdk_working_wctype=yes, gdk_working_wctype=no)
LIBS="$oLIBS"

if test $gdk_working_wctype = no; then
   AC_DEFINE(HAVE_BROKEN_WCTYPE,1,[Is the wctype implementation broken])
   GDK_WLIBS=
fi
AC_MSG_RESULT($gdk_working_wctype)
AC_SUBST(GDK_WLIBS)


##################################################
# Checks for gdk-pixbuf
##################################################

dnl ********************************************************
dnl * See whether we need to load our modules as .la files *
dnl ********************************************************

use_la_modules=false
case $host in
  *-aix*) use_la_modules=true
esac

if $use_la_modules ; then
   AC_DEFINE(USE_LA_MODULES, 1, [Whether to load modules via .la files rather than directly])
fi


AC_MSG_CHECKING(whether to build gmodulized gdk-pixbuf)

AC_ARG_ENABLE(modules,
              [AC_HELP_STRING([--disable-modules],
                              [disable dynamic module loading])])

dynworks=false
deps=
if test x$enable_modules = xno; then
    AC_MSG_RESULT(no)
else
    AC_MSG_RESULT(yes)
    AC_MSG_CHECKING(whether dynamic modules work)
    ## for loop is to strip newline 
    tmp=`$PKG_CONFIG --variable=gmodule_supported gmodule-2.0`
    for I in $tmp; do
        dynworks=$I
    done

    dnl Now we check to see if our libtool supports shared lib deps
    dnl (in a rather ugly way even)
    if $dynworks; then
        pixbuf_libtool_config="${CONFIG_SHELL-/bin/sh} ./libtool --config"
        pixbuf_deplibs_check=`$pixbuf_libtool_config | \
            grep '^[[a-z_]]*check[[a-z_]]*_method=[['\''"]]' | \
            sed 's/.*[['\''"]]\(.*\)[['\''"]]$/\1/'`
        if test "x$pixbuf_deplibs_check" = "xnone" || \
           test "x$pixbuf_deplibs_check" = "xunknown" || \
           test "x$pixbuf_deplibs_check" = "x"; then
            dynworks=false
        fi
    fi

    if $dynworks; then
        AC_DEFINE(USE_GMODULE)
        AC_MSG_RESULT(yes)
    else
        AC_MSG_RESULT(no)
    fi
fi

dnl We allow people to disable image loaders explicitely, but if they don't we error
dnl out so that people don't accidentally build without them.

AC_ARG_WITH(libpng,
            [AC_HELP_STRING([--without-libpng],
                            [disable PNG loader for gdk-pixbuf])])
AC_ARG_WITH(libjpeg,
            [AC_HELP_STRING([--without-libjpeg],
                            [disable JPEG loader for gdk-pixbuf])])
AC_ARG_WITH(libtiff,
            [AC_HELP_STRING([--without-libtiff],
                            [disable TIFF loader for gdk-pixbuf])])

dnl Test for libtiff
  if test x$with_libtiff != xno && test -z "$LIBTIFF"; then
    AC_CHECK_LIB(tiff, TIFFReadScanline,
      [AC_CHECK_HEADER(tiffio.h,
        TIFF='tiff'; LIBTIFF='-ltiff',
        AC_MSG_WARN(*** TIFF loader will not be built (TIFF header files not found) ***))],
      [AC_CHECK_LIB(tiff, TIFFWriteScanline,
        [AC_CHECK_HEADER(tiffio.h,
          TIFF='tiff'; LIBTIFF='-ltiff -ljpeg -lz',
          AC_MSG_WARN(*** TIFF loader will not be built (TIFF header files not found) ***))],
        [AC_CHECK_LIB(tiff34, TIFFFlushData,
          [AC_CHECK_HEADER(tiffio.h,
            TIFF='tiff'; LIBTIFF='-ltiff34 -ljpeg -lz',
            AC_MSG_WARN(*** TIFF loader will not be built (TIFF header files not found) ***))],
        AC_MSG_WARN(*** TIFF plug-in will not be built (TIFF library not found) ***), -ljpeg -lz -lm)], -ljpeg -lz -lm)], -lm)
  fi

  if test x$with_libtiff != xno && test -z "$LIBTIFF"; then
     AC_MSG_ERROR([
*** Checks for TIFF loader failed. You can build without it by passing 
*** --without-libtiff to configure but some programs using GTK+ may
*** not work properly])
  fi

dnl Test for libjpeg
  if test x$with_libjpeg != xno && test -z "$LIBJPEG"; then
    AC_CHECK_LIB(jpeg, jpeg_destroy_decompress,
      jpeg_ok=yes,
      jpeg_ok=no
      AC_MSG_WARN(*** JPEG loader will not be built (JPEG library not found) ***))
    if test "$jpeg_ok" = yes; then
      AC_MSG_CHECKING([for jpeglib.h])
      AC_TRY_CPP(
[#include <stdio.h>
#undef PACKAGE
#undef VERSION
#undef HAVE_STDLIB_H
#include <jpeglib.h>],
        jpeg_ok=yes,
        jpeg_ok=no)
      AC_MSG_RESULT($jpeg_ok)
      if test "$jpeg_ok" = yes; then
        LIBJPEG='-ljpeg'
        AC_CHECK_LIB(jpeg, jpeg_simple_progression,     
          AC_DEFINE(HAVE_PROGRESSIVE_JPEG),
          AC_MSG_WARN(JPEG library does not support progressive saving.))
      else
          AC_MSG_WARN(*** JPEG loader will not be built (JPEG header file not found) ***)
      fi
    fi
  fi

  if test x$with_libjpeg != xno && test -z "$LIBJPEG"; then
     AC_MSG_ERROR([
*** Checks for JPEG loader failed. You can build without it by passing 
*** --without-libjpeg to configure but some programs using GTK+ may
*** not work properly])
  fi

dnl Test for libpng
  if test x$with_libpng != xno && test -z "$LIBPNG"; then
    AC_MSG_CHECKING(for libpng12)
    if $PKG_CONFIG --exists libpng12 ; then
        AC_MSG_RESULT(yes)
        PNG='png'
	PNG_DEP_CFLAGS_PACKAGES=libpng12
	LIBPNG=`$PKG_CONFIG --libs libpng12`
    else
      AC_MSG_RESULT(no)
      AC_CHECK_LIB(png, png_read_info,
        [AC_CHECK_HEADER(png.h,
          png_ok=yes,
          png_ok=no)],
        AC_MSG_WARN(*** PNG loader will not be built (PNG library not found) ***), -lz -lm)
      if test "$png_ok" = yes; then
        AC_MSG_CHECKING([for png_structp in png.h])
        AC_TRY_COMPILE([#include <png.h>],
          [png_structp pp; png_infop info; png_colorp cmap; png_create_read_struct;],
          png_ok=yes,
          png_ok=no)
        AC_MSG_RESULT($png_ok)
        if test "$png_ok" = yes; then
          PNG='png'; LIBPNG='-lpng -lz'
        else
          AC_MSG_WARN(*** PNG loader will not be built (PNG library is too old) ***)
        fi
      else
       AC_MSG_WARN(*** PNG loader will not be built (PNG header file not found) ***)
      fi
    fi
  fi

  if test x$with_libpng != xno && test -z "$LIBPNG"; then
     AC_MSG_ERROR([
*** Checks for PNG loader failed. You can build without it by passing 
*** --without-libpng to configure but many programs using GTK+ will
*** not work properly. The PNG loader is also needed if you are compiling
*** from CVS.])
  fi

AC_SUBST(LIBTIFF)
AC_SUBST(LIBJPEG)
AC_SUBST(LIBPNG)

AM_CONDITIONAL(BUILD_DYNAMIC_MODULES, $dynworks)

#
# Allow building some or all gdk-pixbuf loaders included
#
AC_MSG_CHECKING(pixbuf loaders to build)

dnl due to an autoconf bug, commas in the first arg to
dnl AC_HELP_STRING cause problems.
dnl AC_HELP_STRING([--with-included-loaders=LOADER1 LOADER2 ...],
dnl                [build the specified loaders into gdk-pixbuf (only used if module loading disabled)])
AC_ARG_WITH(included_loaders,
[  --with-included-loaders=LOADER1,LOADER2,...
                          build the specified loaders into gdk-pixbuf (only
                          used if module loading disabled)])

if $dynworks; then 
        :
else
   ## if the option was specified, leave it; otherwise disable included loaders
   if test x$with_included_loaders = xno; then
           with_included_loaders=yes
   fi
fi

all_loaders="png,bmp,wbmp,gif,ico,ani,jpeg,pnm,ras,tiff,xpm,tga,pcx"
included_loaders=""
# If no loaders specified, include all
if test "x$with_included_loaders" = xyes ; then
  included_loaders="$all_loaders"
else
  included_loaders="$with_included_loaders"
fi

AC_MSG_RESULT($included_loaders)

INCLUDED_LOADER_OBJ=
INCLUDED_LOADER_DEFINE=

IFS="${IFS= 	}"; gtk_save_ifs="$IFS"; IFS=","
for loader in $included_loaders; do
 if echo "$all_loaders" | egrep "(^|,)$loader(\$|,)" > /dev/null; then
   :
 else
   AC_MSG_ERROR([the specified loader $loader does not exist])
 fi

 INCLUDED_LOADER_OBJ="$INCLUDED_LOADER_OBJ libpixbufloader-static-$loader.la"
 INCLUDED_LOADER_DEFINE="$INCLUDED_LOADER_DEFINE -DINCLUDE_$loader"
done
IFS="$gtk_save_ifs"
AC_SUBST(INCLUDED_LOADER_OBJ)
AC_SUBST(INCLUDED_LOADER_DEFINE)

AC_HEADER_SYS_WAIT

AC_TYPE_SIGNAL

AM_CONDITIONAL(HAVE_TIFF, test "x$LIBTIFF" != x)
AM_CONDITIONAL(HAVE_PNG, test "x$LIBPNG" != x)
AM_CONDITIONAL(HAVE_JPEG, test "x$LIBJPEG" != x)

if $dynworks ; then
  STATIC_LIB_DEPS=
  if echo "$included_loaders" | egrep '(^|,)tiff($|,)' > /dev/null; then
    STATIC_LIB_DEPS="$STATIC_LIB_DEPS $LIBTIFF"
  fi
  if echo "$included_loaders" | egrep '(^|,)jpeg($|,)' > /dev/null; then
    STATIC_LIB_DEPS="$STATIC_LIB_DEPS $LIBJPEG"
  fi
  if echo "$included_loaders" | egrep '(^|,)png($|,)' > /dev/null; then
    STATIC_LIB_DEPS="$STATIC_LIB_DEPS $LIBPNG"
  fi
else
  STATIC_LIB_DEPS="$LIBTIFF $LIBJPEG $LIBPNG"
fi

# Checks to see if we should compile in MMX support (there will be
# a runtime test when the code is actually run to see if it should
# be used - this just checks if we can compile it.)
#
# This code is partially taken from Mesa
#
AC_MSG_CHECKING(for x86 platform)
case $host_cpu in
  i386|i486|i586|i686|i786|k6|k7)
	use_x86_asm=yes
        ;;
   *)
  	use_x86_asm=no
esac
AC_MSG_RESULT($use_x86_asm)

use_mmx_asm=no
if test $use_x86_asm = yes; then
    save_ac_ext=$ac_ext
    ac_ext=S
    
    AC_MSG_CHECKING(compiler support for MMX)
    cp $srcdir/gdk-pixbuf/pixops/scale_line_22_33_mmx.S conftest.S
    if AC_TRY_EVAL(ac_compile); then
        use_mmx_asm=yes
    fi

    rm -rf conftest*

    ac_ext=$save_ac_ext
    if test $use_mmx_asm = yes; then
      AC_DEFINE(USE_MMX)
      AC_MSG_RESULT(yes)
    else
      AC_MSG_RESULT(no)
    fi
fi

AM_CONDITIONAL(USE_MMX, test x$use_mmx_asm = xyes)

REBUILD_PNGS=
if test -z "$LIBPNG"; then
  REBUILD_PNGS=#
fi

dnl Look for a host system's gdk-pixbuf-csource if we are cross-compiling

AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)

if test $cross_compiling = yes; then
  AC_PATH_PROG(GDK_PIXBUF_CSOURCE, gdk-pixbuf-csource, no)
  if test x$GDK_PIXBUF_CSOURCE = xno; then
    REBUILD_PNGS=#
  fi
fi

if test ! -f $srcdir/gtk/stock-icons/gtkstockpixbufs.h && 
   test "x$REBUILD_PNGS" = "x#" ; then
     AC_MSG_ERROR([
*** gtkstockpixbufs.h is not in the tree, and cannot be built
*** because you don't have libpng, or (when cross-compiling) you 
*** don't have a prebuilt gdk-pixbuf-csource on the host system.])
fi

AC_SUBST(REBUILD_PNGS)

GDK_PIXBUF_PACKAGES="gmodule-2.0 gobject-2.0"
GDK_PIXBUF_EXTRA_LIBS="$STATIC_LIB_DEPS $MATH_LIB"
GDK_PIXBUF_EXTRA_CFLAGS= 
GDK_PIXBUF_DEP_LIBS="`$PKG_CONFIG --libs $GDK_PIXBUF_PACKAGES` $GDK_PIXBUF_EXTRA_LIBS"
GDK_PIXBUF_DEP_CFLAGS="`$PKG_CONFIG --cflags  gthread-2.0 $GDK_PIXBUF_PACKAGES $PNG_DEP_CFLAGS_PACKAGES` $GDK_PIXBUF_EXTRA_CFLAGS"

AC_SUBST(GDK_PIXBUF_PACKAGES)
AC_SUBST(GDK_PIXBUF_EXTRA_LIBS)
AC_SUBST(GDK_PIXBUF_EXTRA_CFLAGS)
AC_SUBST(GDK_PIXBUF_DEP_LIBS)
AC_SUBST(GDK_PIXBUF_DEP_CFLAGS)


########################################
# Windowing system checks
########################################

GDK_EXTRA_LIBS=$GDK_WLIBS
GDK_EXTRA_CFLAGS= 
GTK_DEP_LIBS_FOR_X=

FREETYPE_LIBS=
FREETYPE_CFLAGS=
if test "x$gdktarget" = "xlinux-fb" || test "x$gdktarget" = "xx11" ; then
  #
  # Checks for FreeType
  #
  have_freetype=false
  AC_PATH_PROG(FREETYPE_CONFIG, freetype-config, no)
  if test "x$FREETYPE_CONFIG" != "xno" ; then
    FREETYPE_CFLAGS=`$FREETYPE_CONFIG --cflags`
    FREETYPE_LIBS=`$FREETYPE_CONFIG --libs`

    gtk_save_LIBS="$LIBS"
    LIBS="$FREETYPE_LIBS $LIBS"
    AC_TRY_LINK_FUNC(FT_New_Face, have_freetype=true,:)
    LIBS="$gtk_save_LIBS"

    if $have_freetype ; then
      gtk_save_cppflags="$CPPFLAGS"
      CPPFLAGS="$CPPFLAGS $FREETYPE_CFLAGS"

      AC_MSG_CHECKING([For sufficiently new FreeType (at least 2.0.1)])
      AC_TRY_COMPILE([
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_ERRORS_H
    ],
	             [(void)1;],:,have_freetype=false)
      if $have_freetype ; then
        AC_MSG_RESULT(yes)
      else
        AC_MSG_RESULT(no)
      fi

      CPPFLAGS="$gtk_save_cppflags"
    fi
  fi
  AC_SUBST(FREETYPE_LIBS)
  AC_SUBST(FREETYPE_CFLAGS)
fi

if test "x$gdktarget" = "xx11"; then
  # We start off with the libraries from Pango

  ## be sure we also have Pango built with Xft2 support
  if $PKG_CONFIG --exists 'pangoxft >= 1.2.0' ; then
    if $have_freetype ; then
      :
    else
      AC_MSG_ERROR([Xft Pango backend found but did not find freetype libraries])
    fi
  else
    AC_MSG_ERROR([Pango 1.2.0 and Xft backend is required for x11 target])
  fi

  if $PKG_CONFIG --exists xft ; then : ; else
    AC_MSG_ERROR([Xft version 2 is required for x11 target])
  fi

  #
  # If Pango included the shared library dependencies from X11 in
  # the pkg-config output, then we use that (to avoid duplicates).
  # but if they were omitted to avoid binary compatibility problems,
  # then we need to repeat the checks.
  #
  x_libs="`$PKG_CONFIG --libs pangoxft`"
  case "$x_libs" in
    *-lX11*) pango_omitted_x_deps=no ;;
    *)       pango_omitted_x_deps=yes ;;
  esac

  x_cflags="`$PKG_CONFIG --cflags pangoxft`"
  x_extra_libs=

  AC_PATH_XTRA
  if test x$no_x = xyes ; then
    AC_MSG_ERROR([X development libraries not found])
  fi
  
  if test $pango_omitted_x_deps = yes ; then
    # Old versions of Xft didn't necessarily include -lX11 in the output
    x_libs="`pkg-config --libs xft` -lX11 $X_EXTRA_LIBS"
  fi    	

  ## Strip the .la files
 
  x_libs_for_checks=""
  for I in $x_libs ; do
    case $I in 
      *.la) ;;
      *) x_libs_for_checks="$x_libs_for_checks $I" ;;
    esac
  done

  # Sanity check for the X11 library
  AC_CHECK_LIB(X11, XOpenDisplay, :,
            AC_MSG_ERROR([*** libX11 not found. Check 'config.log' for more details.]),
            $x_libs_for_checks)

  if test "x$enable_shm" = "xyes"; then
    # Check for the Xext library (needed for XShm extention)
    AC_CHECK_LIB(Xext, XShmAttach,
        [GTK_ADD_LIB(x_extra_libs,Xext)],
        # On AIX, it is in XextSam instead, but we still need -lXext
        [AC_CHECK_LIB(XextSam, XShmAttach, 
            [GTK_ADD_LIB(x_extra_libs,Xext)
             GTK_ADD_LIB(x_extra_libs,XextSam)
            ], , -lXext $x_libs_for_checks)],
        $x_libs_for_checks)
  fi

  GDK_PIXBUF_XLIB_EXTRA_CFLAGS="$x_cflags"
  # Don't ever pull in the pangoxft libraries for gdk-pixbuf-x11
  GDK_PIXBUF_XLIB_EXTRA_LIBS="$X_LIBS -lX11 $x_extra_libs $X_EXTRA_LIBS"

  # GTK+ uses some X calls, so needs to link against X directly
  if test $enable_explicit_deps != yes ; then
    GTK_DEP_LIBS_FOR_X="$X_LIBS -lX11 $X_EXTRA_LIBS"
  fi

  # Check for Xinerama extension (Solaris impl or Xfree impl)

  gtk_save_cppflags="$CPPFLAGS"
  CPPFLAGS="$CPPFLAGS $x_cflags"

  case "$host" in
      *-*-solaris*)
          # Check for solaris
	  use_solaris_xinerama=yes
	  AC_CHECK_LIB(Xext, XineramaGetInfo,
			use_solaris_xinerama=yes, use_solaris_xinerama=no)
	  if test "x$use_solaris_xinerama" = "xyes"; then
	      AC_CHECK_HEADER(X11/extensions/xinerama.h,
	        [GTK_ADD_LIB(x_extra_libs,Xext)
		AC_DEFINE(HAVE_SOLARIS_XINERAMA)
		AC_DEFINE(HAVE_XINERAMA)], use_solaris_xinerama=no, -lXext $x_libs_for_checks)
	  fi	
	  AC_MSG_CHECKING(for Xinerama support on Solaris)
	  AC_MSG_RESULT($use_solaris_xinerama);
	  ;;
      *)
	  # Check for XFree
	  use_xfree_xinerama=yes
	  AC_CHECK_LIB(Xinerama, XineramaQueryExtension,
	      [AC_CHECK_HEADER(X11/extensions/Xinerama.h, 
	          [GTK_ADD_LIB(x_extra_libs,Xext)
	          GTK_ADD_LIB(x_extra_libs,Xinerama)
		  AC_DEFINE(HAVE_XFREE_XINERAMA)
		  AC_DEFINE(HAVE_XINERAMA)], 
		  use_xfree_xinerama=no,
                  [#include <X11/Xlib.h>])],
	      use_xfree_xinerama=no, -lXext $x_libs_for_checks)
	  AC_MSG_CHECKING(for Xinerama support on XFree86)
	  AC_MSG_RESULT($use_xfree_xinerama);	    
          ;;
  esac

  CPPFLAGS="$gtk_save_cppflags"

  # Check for shaped window extension

  AC_CHECK_LIB(Xext, XShapeCombineMask,
      [GTK_ADD_LIB(x_extra_libs,Xext)
       AC_DEFINE(HAVE_SHAPE_EXT)],
      ,
      $x_libs_for_checks)

  # Check for XConvertCase (X11R6 specific)

  AC_CHECK_LIB(X11, XConvertCase,
      AC_DEFINE(HAVE_XCONVERTCASE),
      ,
      $x_libs_for_checks)

  # Generic X11R6 check needed for XIM support; we could
  # probably use this to replace the above, but we'll
  # leave the separate XConvertCase check for clarity

  have_x11r6=false
  AC_CHECK_LIB(X11, XAddConnectionWatch,
      have_x11r6=true,
      ,
      $x_libs_for_checks)

  if $have_x11r6; then
    AC_DEFINE(HAVE_X11R6,1,[Define if we have X11R6])
  fi
  AM_CONDITIONAL(HAVE_X11R6, $have_x11r6)

  # Check for XKB support.

  if test "x$enable_xkb" = "xyes"; then
        AC_MSG_WARN(XKB support explicitly enabled)
        AC_DEFINE(HAVE_XKB)
  elif test "x$enable_xkb" = "xmaybe"; then
        AC_CHECK_LIB(X11, XkbQueryExtension,
                     AC_DEFINE(HAVE_XKB),
	             ,
	             $x_libs_for_checks)
  else
        AC_MSG_WARN(XKB support explicitly disabled)
  fi

  x_cflags="$X_CFLAGS"
  x_ldflags="$X_LDFLAGS"

  # set up things for XInput

  if test "x$with_xinput" = "xxfree" || test "x$with_xinput" = "xyes"; then
    AC_DEFINE(XINPUT_XFREE)
    GTK_ADD_LIB(x_extra_libs, Xi)
  else
    AC_DEFINE(XINPUT_NONE)
  fi

  AM_CONDITIONAL(XINPUT_XFREE, test x$with_xinput = xxfree || test x$with_xinput = xyes)

  # Check for the RANDR extension

  AC_CHECK_LIB(Xrandr, XRRUpdateConfiguration,
      [AC_CHECK_HEADER(X11/extensions/Xrandr.h,
          # RANDR requires RENDER
          [GTK_ADD_LIB(x_extra_libs, Xrender)
          GTK_ADD_LIB(x_extra_libs, Xrandr)
	  AC_DEFINE(HAVE_RANDR, 1, Have the Xrandr extension library)],
	  :, [#include <X11/Xlib.h>])], : ,
       $X_LIBS -lXrandr -lXrender -lX11 $X_EXTRA_LIBS)

  # Checks for Xcursor library
  
  have_xcursor=false
  PKG_CHECK_MODULES(XCURSOR, xcursor, have_xcursor=true, :)

  if $have_xcursor ; then
    AC_DEFINE(HAVE_XCURSOR, 1, Have the Xcursor library)
    XCURSOR_PACKAGES="xcursor"
  else
    XCURSOR_PACKAGES=
  fi
    
  # Xshm checks

  if test "x$enable_shm" = "xyes"; then
    # Check for shared memory
    AC_CHECK_HEADER(sys/ipc.h, AC_DEFINE(HAVE_IPC_H), no_sys_ipc=yes)
    AC_CHECK_HEADER(sys/shm.h, AC_DEFINE(HAVE_SHM_H), no_sys_shm=yes)

    # Check for the X shared memory extension header file
    have_xshm=no 
    AC_MSG_CHECKING(X11/extensions/XShm.h)
    if test "x$no_xext_lib" = "xyes"; then
      :
    else
      gtk_save_CFLAGS="$CFLAGS"
      CFLAGS="$CFLAGS $x_cflags"
      AC_TRY_COMPILE([
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/extensions/XShm.h>
], [XShmSegmentInfo *x_shm_info;], have_xshm=yes)
      CFLAGS="$gtk_save_CFLAGS"
    fi
    AC_MSG_RESULT($have_xshm)
    if test $have_xshm = yes ; then
      AC_DEFINE(HAVE_XSHM_H)
    fi
  fi

  GDK_EXTRA_CFLAGS=
  if test $pango_omitted_x_deps = yes ; then
    GDK_EXTRA_LIBS="$X_LIBS $x_extra_libs $x_libs $GDK_EXTRA_LIBS"
  else
    GDK_EXTRA_LIBS="$X_LIBS $x_extra_libs $GDK_EXTRA_LIBS"
  fi

  AM_CONDITIONAL(USE_X11, true)
else
  AM_CONDITIONAL(XINPUT_XFREE, false)
  AM_CONDITIONAL(USE_X11, false)
  AM_CONDITIONAL(HAVE_X11R6, false)
fi

if test "x$gdktarget" = "xwin32"; then
  # We start off with the libraries from Pango

  if test x$have_wintab = xyes; then
    GDK_WIN32_EXTRA_CFLAGS="-I $with_wintab/include"
    AC_SUBST(GDK_WIN32_EXTRA_CFLAGS)
  fi

  GDK_EXTRA_LIBS="$GDK_EXTRA_LIBS -lgdi32 -user32 -limm32 -lshell32 -lole32 -luuid"
  AM_CONDITIONAL(USE_WIN32, true)
else
  AM_CONDITIONAL(USE_WIN32, false)
fi

GDK_PIXBUF_XLIB_PACKAGES=
GDK_PIXBUF_XLIB_DEP_LIBS="`$PKG_CONFIG --libs $GDK_PIXBUF_PACKAGES $GDK_PIXBUF_XLIB_PACKAGES` $GDK_PIXBUF_XLIB_EXTRA_LIBS $GDK_PIXBUF_EXTRA_LIBS"
GDK_PIXBUF_XLIB_DEP_CFLAGS="`$PKG_CONFIG --cflags  gthread-2.0 $GDK_PIXBUF_PACKAGES $GDK_PIXBUF_XLIB_PACKAGES` $GDK_PIXBUF_EXTRA_CFLAGS $GDK_PIXBUF_XLIB_EXTRA_CFLAGS"

AC_SUBST(GDK_PIXBUF_XLIB_PACKAGES)
AC_SUBST(GDK_PIXBUF_XLIB_EXTRA_LIBS)
AC_SUBST(GDK_PIXBUF_XLIB_EXTRA_CFLAGS)
AC_SUBST(GDK_PIXBUF_XLIB_DEP_LIBS)
AC_SUBST(GDK_PIXBUF_XLIB_DEP_CFLAGS)

if test "x$gdktarget" = "xlinux-fb"; then
  if $have_freetype ; then
    :
  else
    AC_MSG_ERROR([Using linux-fb backend but freetype was not found])
  fi

  ft2_libs="`$PKG_CONFIG --libs pangoft2`"
  case "$ft2_libs" in
    *-lfreetype*) pango_omitted_ft2_deps=no ;;
    *)            pango_omitted_ft2_deps=yes ;;
  esac

  CFLAGS="$CFLAGS $FREETYPE_CFLAGS"

  if test x$enable_shadowfb = xyes ; then
    AC_DEFINE(ENABLE_SHADOW_FB)
  fi

  if test x$enable_fbmanager = xyes ; then
    AC_DEFINE(ENABLE_FB_MANAGER)
    AM_CONDITIONAL(ENABLE_FB_MANAGER, true)
  else
    AM_CONDITIONAL(ENABLE_FB_MANAGER, false)
  fi
  
  GDK_EXTRA_CFLAGS=""
  if test $pango_omitted_ft2_deps = yes ; then
    GDK_EXTRA_LIBS="$FREETYPE_LIBS $GDK_EXTRA_LIBS"
  fi

  AM_CONDITIONAL(USE_LINUX_FB, true)
else
  AM_CONDITIONAL(USE_LINUX_FB, false)
  AM_CONDITIONAL(ENABLE_FB_MANAGER, false)
fi

#
# Pick correct Pango packages to use
#

if test "x$gdktarget" = "xx11"; then
        PANGO_PACKAGES=pangoxft
	
        # We no longer use pangox, but if we find it, we link to it 
	# for binary compatibility.
	if $PKG_CONFIG --exists pangox ; then
		PANGO_PACKAGES="$PANGO_PACKAGES pangox"
	fi
elif test "x$gdktarget" = "xwin32"; then
        PANGO_PACKAGES=pangowin32
elif test "x$gdktarget" = "xlinux-fb"; then
        PANGO_PACKAGES=pangoft2
else
        PANGO_PACKAGES=pango
fi

# Check for Pango flags

AC_MSG_CHECKING(Pango flags)
if $PKG_CONFIG --exists $PANGO_PACKAGES ; then
        PANGO_CFLAGS=`$PKG_CONFIG --cflags $PANGO_PACKAGES`
        PANGO_LIBS=`$PKG_CONFIG --libs $PANGO_PACKAGES`

        AC_MSG_RESULT($PANGO_CFLAGS $PANGO_LIBS)
else
        AC_MSG_ERROR([
*** Pango not found. Pango is required to build GTK+.
*** See http://www.pango.org for Pango information.
*** For the framebuffer target, you will need to build 
*** Pango with freetype support.
])
fi

CFLAGS="$CFLAGS $PANGO_CFLAGS"

if $PKG_CONFIG --uninstalled $PANGO_PACKAGES; then
        :
else
	gtk_save_LIBS="$LIBS"
        LIBS="$PANGO_LIBS $LIBS"
        AC_TRY_LINK_FUNC(pango_context_new, :, AC_MSG_ERROR([
*** Can't link to Pango. Pango is required to build
*** GTK+. For more information see http://www.pango.org]))
        LIBS="$gtk_save_LIBS"
fi

CFLAGS="$saved_cflags"
LDFLAGS="$saved_ldflags"

GDK_PACKAGES="$XCURSOR_PACKAGES $PANGO_PACKAGES"
GDK_DEP_LIBS="$GDK_EXTRA_LIBS `$PKG_CONFIG --libs $GDK_PIXBUF_PACKAGES $GDK_PACKAGES` $GDK_PIXBUF_EXTRA_LIBS"
GDK_DEP_CFLAGS="`$PKG_CONFIG --cflags  gthread-2.0 $GDK_PIXBUF_PACKAGES $GDK_PACKAGES` $GDK_PIXBUF_EXTRA_CFLAGS $GDK_EXTRA_CFLAGS"

#
# If we aren't writing explicit dependencies, then don't put the extra libraries we need
# into the pkg-config files
#
if test $enable_explicit_deps != yes ; then
  GDK_EXTRA_LIBS=
fi

AC_SUBST(GDK_PACKAGES)
AC_SUBST(GDK_EXTRA_LIBS)
AC_SUBST(GDK_EXTRA_CFLAGS)
AC_SUBST(GDK_DEP_LIBS)
AC_SUBST(GDK_DEP_CFLAGS)


########################################
# Check for Accessibility Toolkit flags
########################################

ATK_PACKAGES=atk
AC_MSG_CHECKING(ATK flags)
if $PKG_CONFIG --exists $ATK_PACKAGES ; then
        ATK_CFLAGS=`$PKG_CONFIG --cflags $ATK_PACKAGES`
        ATK_LIBS=`$PKG_CONFIG --libs $ATK_PACKAGES`

        AC_MSG_RESULT($ATK_CFLAGS $ATK_LIBS)
else
        AC_MSG_ERROR([
*** Accessibility Toolkit not found. Accessibility Toolkit is required
*** to build GTK+.
])
fi

if $PKG_CONFIG --uninstalled $ATK_PACKAGES; then
        :
else
	gtk_save_LIBS="$LIBS"
        LIBS="$ATK_LIBS $LIBS"
        AC_TRY_LINK_FUNC(atk_object_get_type, : , AC_MSG_ERROR([
                *** Cannot link to Accessibility Toolkit. Accessibility Toolkit is required
                *** to build GTK+]))
        LIBS="$gtk_save_LIBS"
fi

GTK_PACKAGES=atk
GTK_EXTRA_LIBS=
GTK_EXTRA_CFLAGS= 
GTK_DEP_LIBS="$GDK_EXTRA_LIBS $GTK_DEP_LIBS_FOR_X `$PKG_CONFIG --libs $GDK_PIXBUF_PACKAGES $GDK_PACKAGES $GTK_PACKAGES` $GTK_EXTRA_LIBS $GDK_PIXBUF_EXTRA_LIBS"
GTK_DEP_CFLAGS="`$PKG_CONFIG --cflags  gthread-2.0 $GDK_PIXBUF_PACKAGES $GDK_PACKAGES $GTK_PACKAGES` $GDK_PIXBUF_EXTRA_CFLAGS $GDK_EXTRA_CFLAGS $GTK_EXTRA_CFLAGS"

AC_SUBST(GTK_PACKAGES)
AC_SUBST(GTK_EXTRA_LIBS)
AC_SUBST(GTK_EXTRA_CFLAGS)
AC_SUBST(GTK_DEP_LIBS)
AC_SUBST(GTK_DEP_CFLAGS)


AC_SUBST(GTK_DEBUG_FLAGS)
AC_SUBST(GTK_XIM_FLAGS)

##################################################
# Checks for gtk-doc and docbook-tools
##################################################

GTK_DOC_CHECK([1.0])

AC_CHECK_PROG(DB2HTML, db2html, true, false)
AM_CONDITIONAL(HAVE_DOCBOOK, $DB2HTML)

AC_ARG_ENABLE(man,
              [AC_HELP_STRING([--enable-man],
                              [regenerate man pages from Docbook [default=no]])],enable_man=yes,
              enable_man=no)

dnl
dnl Check for xsltproc
dnl
AC_PATH_PROG([XSLTPROC], [xsltproc])
if test -z "$XSLTPROC"; then
  enable_man=no
fi

dnl check for DocBook DTD and stylesheets in the local catalog.
JH_CHECK_XML_CATALOG([-//OASIS//DTD DocBook XML V4.1.2//EN],
   [DocBook XML DTD V4.1.2],,enable_man=no)
JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
   [DocBook XSL Stylesheets],,enable_man=no)
AM_CONDITIONAL(ENABLE_MAN, test x$enable_man != xno)

##################################################
# Output commands
##################################################

AC_CONFIG_COMMANDS([gdk/gdkconfig.h], [
	outfile=gdkconfig.h-tmp
	cat > $outfile <<\_______EOF
/* gdkconfig.h
 *
 * This is a generated file.  Please modify `configure.in'
 */

#ifndef GDKCONFIG_H
#define GDKCONFIG_H

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

_______EOF

	cat >>$outfile <<_______EOF
$gdk_windowing
$gdk_wc
_______EOF

	cat >>$outfile <<_______EOF

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* GDKCONFIG_H */
_______EOF


	if cmp -s $outfile gdk/gdkconfig.h; then
          AC_MSG_NOTICE([gdk/gdkconfig.h is unchanged])
	  rm -f $outfile
	else
	  mv $outfile gdk/gdkconfig.h
	fi
],[
if test "x$gdktarget" = "xx11" ; then
  gdk_windowing='
#define GDK_WINDOWING_X11'
elif test "x$gdktarget" = "xwin32" ; then
  gdk_windowing='
#define GDK_WINDOWING_WIN32'
elif test "x$gdktarget" = "xlinux-fb" ; then
  gdk_windowing='
#define GDK_WINDOWING_FB
#define GDK_NATIVE_WINDOW_POINTER'
fi

if test x$gdk_wchar_h = xyes; then
  gdk_wc='
#define GDK_HAVE_WCHAR_H 1'
fi
if test x$gdk_wctype_h = xyes; then
  gdk_wc="\$gdk_wc
#define GDK_HAVE_WCTYPE_H 1"
fi
if test x$gdk_working_wctype = xno; then
  gdk_wc="\$gdk_wc
#define GDK_HAVE_BROKEN_WCTYPE 1"
fi


])

AC_PATH_PROG(SGML2HTML, sgml2html, no)
AM_CONDITIONAL(HAVE_SGML2HTML, test x$SGML2HTML != xno)

AC_CONFIG_FILES([
config.h.win32
gtk-zip.sh
Makefile
gdk-pixbuf-2.0.pc
gdk-2.0.pc
gtk+-2.0.pc
gdk-pixbuf-2.0-uninstalled.pc
gdk-2.0-uninstalled.pc
gtk+-2.0-uninstalled.pc
m4macros/Makefile
po/Makefile.in
build/Makefile
build/win32/Makefile
build/win32/dirent/Makefile
demos/Makefile
demos/gtk-demo/Makefile
demos/gtk-demo/geninclude.pl
tests/Makefile
docs/Makefile
docs/reference/Makefile
docs/reference/gdk-pixbuf/Makefile
docs/reference/gdk-pixbuf/version.xml
docs/reference/gdk/Makefile
docs/reference/gdk/version.xml
docs/reference/gtk/Makefile
docs/reference/gtk/version.xml
docs/faq/Makefile
docs/tutorial/Makefile
gdk-pixbuf/Makefile
gdk-pixbuf/gdk_pixbuf.rc
gdk-pixbuf/gdk-pixbuf-features.h
gdk-pixbuf/pixops/Makefile
gdk/Makefile
gdk/x11/Makefile
gdk/win32/Makefile
gdk/win32/rc/Makefile
gdk/win32/rc/gdk.rc
gdk/linux-fb/Makefile
gtk/Makefile
gtk/makefile.msc
gtk/gtkversion.h
gtk/gtk-win32.rc
gtk/stock-icons/Makefile
gtk/theme-bits/Makefile
gtk/xdgmime/Makefile
modules/Makefile
modules/input/Makefile
contrib/Makefile
contrib/gdk-pixbuf-xlib/Makefile
contrib/gdk-pixbuf-xlib/gdk-pixbuf-xlib-2.0.pc
])

AC_OUTPUT