dnl -*- mode: Autoconf; -*-
dnl Invoke autogen.sh to produce a configure script.

# The STABLE_VERSION is used when building
# Debian packages. For prereleases (beta, alpha),
# set it to something like "0.9.2+" and the AC_INIT
# VERSION to 1.0beta1 to produce 0.9.2+1.0beta1.
#
# Starting with the 1.1 release cycle, the rpm-style
# .99 pseudo-version number is used to mark a pre-release.
AC_INIT([syncevolution], [1.2.2])
# STABLE_VERSION=1.0.1+
AC_SUBST(STABLE_VERSION)

# Default value for --enable/disable-release-mode.
# Determined by gen-autotools.sh based on versioning.
# Official, stable releases enable it, pre-releases
# disable it.
#
# SyncEvolution >= 1.1.99.5: release mode by default
define([STABLE_RELEASE], [yes])

# Minimum version of libsynthesis as defined in its
# configure script and thus .pc files:
define([SYNTHESIS_MIN_VERSION], [3.4.0.16.6])

# Line above is patched by gen-autotools.sh. Handle
# both "yes" and "no".
define([STABLE_RELEASE_HELP], ifelse(STABLE_RELEASE,yes,--disable-release-mode,--enable-release-mode))

AC_ARG_ENABLE(release-mode,
              AS_HELP_STRING([STABLE_RELEASE_HELP],
                             [Controls whether resulting binary is for end-users or
                              testers/developers. For example, stable releases automatically
                              migrate on-disk files without asking, whereas other releases
                              ask before making downgrades impossible (or difficult).
                              Default in this source code is
                              "stable release: STABLE_RELEASE"]),
              enable_release_mode="$enableval", enable_release_mode="STABLE_RELEASE")
if test "$enable_release_mode" = "yes"; then
   AC_DEFINE(SYNCEVOLUTION_STABLE_RELEASE, 1, [binary is meant for end-users])
fi

AM_INIT_AUTOMAKE([tar-ustar])
AM_MAINTAINER_MODE([enable]) # needed for nightly builds where reconfiguration fails under certain chroots
AC_CONFIG_MACRO_DIR([m4])
define([SYNTHESISSRC_REPO], [])
dnl Specify git revisions/branches without prefix, i.e., without 'origin'.
dnl We'll sort that out below.
define([SYNTHESISSRC_REVISION], [syncevolution-0.9])
AM_CONFIG_HEADER(config.h)
AC_LIBTOOL_DLOPEN

dnl check for programs.
AC_PROG_CXX
AC_PROG_LIBTOOL
AC_PROG_MAKE_SET

dnl default device type (see AC_DEFINE below)
DEVICE_TYPE=workstation

AC_ARG_WITH(synthesis-src,
            AS_HELP_STRING([--with-synthesis-src=<base directory|svn URL|git URL>],
                           [Specifies location of the Synthesis root directory.
                           Use this when the Synthesis library is to
                           be compiled as part of the SyncEvolution compilation. In release
                           versions of SyncEvolution, a copy of the Synthesis code is bundled
                           under 'src/synthesis' and compiled unless something else is
                           specified. --with-synthesis-src can be given a path to sources
                           checked out already, a Subversion repository URL or a git repository
                           URL. When given a repository URL, then the configure script
                           will checkout the sources into 'src/synthesis-workdir' or
                           update that working copy if the directory already exists.
                           Default: bundled source in src/synthesis (in released SyncEvolution sources),
                           SYNTHESISSRC_REPO otherwise.]),
            [SYNTHESISSRC="$withval"
             test "$SYNTHESISSRC" != "yes" || AC_MSG_ERROR([--with-synthesis-src requires a parameter (base directory, svn URL or git URL)])],
            [SYNTHESISSRC="$SYNTHESISSRC_DEF"; REVISION="SYNTHESISSRC_REVISION"])

AC_ARG_WITH(syncml-engines,
            AS_HELP_STRING([--with-syncml-engines=client|server|both],
                           [Determines which kind of support for SyncML is compiled and linked into SyncEvolution. Default is both. Currently has no effect.]),
            [SYNCML_ENGINES="$withval"], SYNCML_ENGINES=both)

case $SYNCML_ENGINES in both|client) AC_DEFINE(ENABLE_SYNCML_CLIENT, 1, [SyncML client support available]);; esac
case $SYNCML_ENGINES in both|server) AC_DEFINE(ENABLE_SYNCML_SERVER, 1, [SyncML server support available]);; esac
case $SYNCML_ENGINES in both|server|client) true;; *) AC_ERROR([Invalid value for --with-syncml-engines: $SYNCML_ENGINES]);; esac

AC_ARG_WITH(synthesis-username,
            AS_HELP_STRING([--with-synthesis-username=<svn username>],
                           [username to use when checking out --with-synthesis-src sources from Subversion, default 'guest']),
            [USERNAME="$withval"], [USERNAME="guest"])

AC_ARG_WITH(synthesis-revision,
            AS_HELP_STRING([--with-synthesis-revision=<git tag/branch/hash or Subversion revision>],
                           [Identifies which source revision to use from --with-synthesis-src repository, empty string stands for latest. Default for default --synthesis-src: SYNTHESISSRC_REVISION]),
            [REVISION="$withval"])

AC_ARG_ENABLE(shared,
              AS_HELP_STRING([--enable-shared],
                             [build backends as dynamically loadable modules]),
              enable_shared="$enableval", enable_shared="no")

AC_ARG_ENABLE(static,
              AS_HELP_STRING([--enable-static],
                             [build backends also as static libraries]),
              enable_static="$enableval", enable_static="no")

AC_ARG_ENABLE(unit-tests,
              AS_HELP_STRING([--enable-unit-tests],
                             [enables tests embedded in the source code of the library (changes content of executable)]),
              enable_unit_tests="$enableval", enable_unit_tests="no")
AC_ARG_ENABLE(integration-tests,
              AS_HELP_STRING([--enable-integration-tests],
                             [enables tests outside of the library (can be used together with normal builds of the library)]),
              enable_integration_tests="$enableval", enable_integration_tests="no")

AC_ARG_ENABLE(buteo-tests,
              AS_HELP_STRING([--enable-buteo-tests],
                             [enables tests for Buteo sync framework. Not enabled when neither '--enable-unit-tests' nor '--enable-integration-tests' is specified]),
              [ if test "$enable_unit_tests" = "yes" || test "$enable_integration_tests" = "yes" ; then
                    enable_buteo_tests="$enableval"
                else
                    enable_buteo_tests="no"
                fi], enable_buteo_tests="no")
PKG_CHECK_MODULES(BUTEOSYNCPROFILE, [syncprofile], HAVE_SYNCPROFILE=yes, HAVE_SYNCPROFILE=no)
PKG_CHECK_MODULES(BUTEOSYNCCOMMON, [synccommon], HAVE_SYNCCOMMON=yes, HAVE_SYNCCOMMON=no)

AC_ARG_ENABLE(static-cxx,
              AS_HELP_STRING([--enable-static-cxx],
                             [build executables which contain libstdc++ instead of requiring suitable libstdc++.so to run]),
              enable_static_cxx="$enableval", enable_static_cxx="no")

AC_ARG_ENABLE(evolution-compatibility,
              AS_HELP_STRING([--enable-evolution-compatibility],
                             [build executables which only call Evolution via dlopen/dlsym: this avoids all hard dependencies on EDS shared objects, but might lead to crashes when their ABI changes]),
              enable_evolution_compatibility="$enableval", enable_evolution_compatibility="no")

AC_ARG_ENABLE(developer-mode, 
             AC_HELP_STRING([--enable-developer-mode], 
                            [The dynamic loadble backend libraries is loaded from current build directory instead of the standard library path]),
             enable_developer_mode="$enableval", enable_developer_mode="no")

# Maemo hacks:
# - wrap e_book_from_string() to fix invalid parameter
# - don't use UTF-8 encoding in Perl script
AC_ARG_ENABLE(maemo,
              AS_HELP_STRING([--enable-maemo],
                             [enables some hacks which work around problems with the Maemo 2.0 until at least 3.0 EDS-Dbus]),
              [AC_DEFINE(ENABLE_MAEMO, 1, [enable Maemo hacks])
               DEVICE_TYPE=Maemo
               MODIFY_SYNCCOMPARE='-e "s/use encoding/#use encoding/;" -e "s/:utf8//;"'])
AC_SUBST(MODIFY_SYNCCOMPARE)

AC_CHECK_HEADERS(signal.h dlfcn.h)

# cppunit needed?
if test $enable_unit_tests = "yes" || test $enable_integration_tests = yes; then
        CPPUNIT_CXXFLAGS=`cppunit-config --cflags` || AC_MSG_ERROR("cppunit-config --cflags failed - is it installed?")
        CPPUNIT_LDFLAGS=`cppunit-config --libs` || AC_MSG_ERROR("cppunit-config --libs failed - is it installed?")
fi
AC_SUBST(CPPUNIT_CXXFLAGS)
AC_SUBST(CPPUNIT_LDFLAGS)

if test "$enable_unit_tests" = "yes"; then
        AC_DEFINE(ENABLE_UNIT_TESTS, 1, [enable unit tests inside the library's source code])
fi
if test "$enable_integration_tests" = "yes"; then
        AC_DEFINE(ENABLE_INTEGRATION_TESTS, 1, [enable integration tests inside the final library])
fi
if test "$enable_buteo_tests" = "yes"; then
        AC_DEFINE(ENABLE_BUTEO_TESTS, 1, [enable buteo tests])
        need_qt_modules="$need_qt_modules dbus xml"
        AC_PATH_PROG(SQLITE3, sqlite3)
        if test -z "$SQLITE3"; then
            AC_ERROR([sqlite3 not found, is required for buteo testing])
        fi
fi
AM_CONDITIONAL([ENABLE_UNIT_TESTS], [test "$enable_unit_tests" = "yes"])
AM_CONDITIONAL([ENABLE_TESTING], [test "$enable_unit_tests" = "yes" || test "$enable_integration_tests" = "yes" ])
AM_CONDITIONAL([ENABLE_BUTEO_TESTS], [test "$enable_buteo_tests" = "yes"])

if test $enable_static_cxx = "yes"; then
        LIBS="$LIBS -L."
        CORE_LDADD_DEP=libstdc++.a
fi
AC_SUBST(CORE_LDADD_DEP)

# Check for transport layer.
# Both curl and libsoup can be enabled and disabled explicitly.
# The default is to use libsoup if available, otherwise curl.

AC_MSG_CHECKING([for libcurl])
if LIBCURL_LIBS=`sh -c 'curl-config --libs' 2>&AS_MESSAGE_LOG_FD` && \
    LIBCURL_CFLAGS=`sh -c 'curl-config --cflags' 2>&AS_MESSAGE_LOG_FD`; then
    AC_MSG_RESULT([yes])
    have_libcurl="yes"
else
    AC_MSG_RESULT([no])
    have_libcurl="no"
fi

PKG_CHECK_MODULES(LIBSOUP, libsoup-gnome-2.4,
                  [have_libsoup="yes"
                   AC_DEFINE(HAVE_LIBSOUP_SOUP_GNOME_FEATURES_H, 1, [enable GNOME specific libsoup])],
                  [PKG_CHECK_MODULES(LIBSOUP, libsoup-2.4,
                                     have_libsoup="yes",
                                     have_libsoup="no")])

PKG_CHECK_MODULES(LIBOPENOBEX, openobex, have_obex="yes", have_obex="no")
have_bluetooth="no"
if test $have_obex = "yes"; then
    PKG_CHECK_MODULES(BLUEZ, bluez, have_bluez="yes", have_bluez="no")
    if test $have_bluez = "yes"; then
        have_bluetooth="yes"
    fi
fi
AC_SUBST(LIBOPENOBEX_CFLAGS)
AC_SUBST(LIBOPENOBEX_LIBS)
AC_SUBST(BLUEZ_CFLAGS)
AC_SUBST(BLUEZ_LIBS)

TRANSPORT=
TRANSPORT_LIBS=
TRANSPORT_CFLAGS=

AC_ARG_WITH(ca-certificates,
            AS_HELP_STRING([--with-ca-certificates=<colon separated list of files>],
                           [Specifies location of one or more CA certificate files.
                           This sets the default value for the SSLServerCertificates option.
                           Default: empty when using libcurl (because it has its own default),
                           a list of paths known to work for Debian and Red Hat otherwise.]),
            [CA_CERTIFICATES="$withval"])


# choose default http transport (mirrors code in EvolutionSyncClient::createTransportAgent())
if test "$have_libsoup" = "yes"; then
   default_http_transport="libsoup"
elif test "$have_libcurl" = "yes"; then
   default_http_transport="libcurl"
fi

AC_ARG_ENABLE(libcurl,
              AC_HELP_STRING([--enable-libcurl],
                             [enable libcurl as transport layer]),
              [ if test "$enableval" = "yes"; then
                   test "$have_libcurl" = "yes" || AC_MSG_ERROR([libcurl not found])
                   TRANSPORT="$TRANSPORT libcurl"
                   TRANSPORT_LIBS="$TRANSPORT_LIBS $LIBCURL_LIBS"
                   TRANSPORT_CFLAGS="$TRANSPORT_CFLAGS $LIBCURL_CFLAGS"
                   AC_DEFINE(ENABLE_LIBCURL, 1, [enable libcurl transport])
                else
                   libcurl_disabled="yes"
                fi ],
              [ if test "$have_libcurl" = "yes" && test "$default_http_transport" = "libcurl" ; then
                   TRANSPORT="$TRANSPORT libcurl"
                   TRANSPORT_LIBS="$TRANSPORT_LIBS $LIBCURL_LIBS"
                   TRANSPORT_CFLAGS="$TRANSPORT_CFLAGS $LIBCURL_CFLAGS"
                   AC_DEFINE(ENABLE_LIBCURL, 1, [enable libcurl transport])
                fi ])

AC_ARG_ENABLE(libsoup,
              AC_HELP_STRING([--enable-libsoup],
                             [enable libsoup as transport layer]),
              [ if test "$enableval" = "yes"; then
                   test "$have_libsoup" = "yes" || AC_MSG_ERROR([libsoup not found])
                   TRANSPORT="$TRANSPORT libsoup"
                   TRANSPORT_LIBS="$TRANSPORT_LIBS $LIBSOUP_LIBS"
                   TRANSPORT_CFLAGS="$TRANSPORT_CFLAGS $LIBSOUP_CFLAGS"
                   AC_DEFINE(ENABLE_LIBSOUP, 1, [enable libsoup transport])
                else
                   libsoup_disabled="yes"
                fi ],
              [ if test "$have_libsoup" = "yes" && test "$default_http_transport" = "libsoup"; then
                   TRANSPORT="$TRANSPORT libsoup"
                   TRANSPORT_LIBS="$TRANSPORT_LIBS $LIBSOUP_LIBS"
                   TRANSPORT_CFLAGS="$TRANSPORT_CFLAGS $LIBSOUP_CFLAGS"
                   AC_DEFINE(ENABLE_LIBSOUP, 1, [enable libsoup transport])
                fi ])

# SoupTransportAgent depends on glib
case "$TRANSPORT" in *libsoup*) need_glib=yes;; esac

bluetooth_disabled=no
AC_ARG_ENABLE(bluetooth,
              AC_HELP_STRING([--enable-bluetooth],
                             [enable bluetooth transport support]),
              [ enable_bluetooth="$enableval"
                if test "$enableval" = "no"; then
                    bluetooth_disabled=yes
                fi
              ],
              [ enable_bluetooth="$have_bluetooth" ])

if test "$enable_bluetooth" = "yes"; then
   # currently we need Bluetooth and OBEX support
   test "$have_bluetooth" = "yes" || AC_MSG_ERROR([openobex or bluez not found])   

   AC_LANG(C)
   CFLAGS_old="$CFLAGS"
   CFLAGS="$CPPFLAGS $BLUEZ_CFLAGS"
   # test in this order:
   # - recent libbluetooth (no _safe variant, base function has bufsize)
   # - intermediate with _safe
   # - else assume old-style (no bufsize, no _safe)
   #
   # The source code checks the signature both by via pointer assignment and calling
   # it (better safe than sorry). One these should fail if the signature is not right.
   AC_COMPILE_IFELSE([AC_LANG_SOURCE([
                      #include <bluetooth/sdp.h>
                      #include <bluetooth/sdp_lib.h>
                      sdp_record_t *(*extract_pdu)(const uint8_t *pdata, int bufsize, int *scanned) =
                           sdp_extract_pdu;
                      void foo(void) {
                          uint8_t *pdata = NULL;
                          int scanned;
                          sdp_extract_pdu(pdata, 100, &scanned);
                      }
                     ])],
                     AC_DEFINE(HAVE_BLUEZ_BUFSIZE, 1, [base libbluetooth functions accept bufsize parameter]),
                     AC_COMPILE_IFELSE([AC_LANG_SOURCE([
                                        #include <bluetooth/sdp.h>
                                        #include <bluetooth/sdp_lib.h>
                                        sdp_record_t *(*extract_pdu)(const uint8_t *pdata, int bufsize, int *scanned) =
                                               sdp_extract_pdu_safe;
                                        void foo(void) {
                                            uint8_t *pdata = NULL;
                                            int scanned;        
                                            sdp_extract_pdu_safe(pdata, 100, &scanned);
                                        }
                                       ])],
                                       AC_DEFINE(HAVE_BLUEZ_SAFE, 1, [libbluetooth has _safe variants])))
   CFLAGS="$CFLAGS_old"

   if test "$have_obex" = "yes"; then
      AC_DEFINE(ENABLE_OBEX, 1, [define if openobex library is available])
   fi
   if test "$have_bluez" = "yes"; then
      AC_DEFINE(ENABLE_BLUETOOTH, 1, [define if bluez library is available])
   fi
fi
AM_CONDITIONAL([ENABLE_OBEX], [test "$have_obex" = "yes" && test "$enable_bluetooth" = "yes"])
AM_CONDITIONAL([ENABLE_BLUETOOTH], [test "$have_bluetooth" = "yes" && test "$enable_bluetooth" = "yes"])

if test ! "$TRANSPORT" &&
   test "$libsoup_disabled" != "yes" &&
   test "$libcurl_disabled" != "yes" &&
   test "$bluetooth_disabled" != "yes" &&
   test "$have_bluetooth" != "yes" ; then
   AC_ERROR([no transport library found, configure with --disable-libcurl --disable-libsoup --disable-bluetooth to continue anyway (only useful if users of libsyncevolution provide transport implementation)])
fi

# for libsoup we must specify the SSL certificate file outself
if test "$libsoup_disabled" != "yes" && test -z "$CA_CERTIFICATES"; then
   # Debian and Red Hat paths
   CA_CERTIFICATES="/etc/ssl/certs/ca-certificates.crt:/etc/pki/tls/certs/ca-bundle.crt:/usr/share/ssl/certs/ca-bundle.crt"
fi
AC_DEFINE_UNQUOTED(SYNCEVOLUTION_SSL_SERVER_CERTIFICATES, "$CA_CERTIFICATES", [default value for SSLServerCertificates option])

AC_SUBST(TRANSPORT_LIBS)
AC_SUBST(TRANSPORT_CFLAGS)

AC_ARG_ENABLE(ssl-certificate-check,
              AC_HELP_STRING([--disable-ssl-certificate-check],
                             [Disable SSL certificate checking in all server
                              *templates*.  Users can still choose to enable or
                              disable it in their configuration. This is necessary on
                              platforms where the transport library has problems
                              verifying the server's certificate (libsoup + Google,
                              http://bugzilla.moblin.org/show_bug.cgi?id=4551)]),
             enable_ssl_certificate_check="$enableval",
             enable_ssl_certificate_check="yes")
if test "$enable_ssl_certificate_check" = "yes"; then
   AC_DEFINE(ENABLE_SSL_CERTIFICATE_CHECK, 1, [enable SSL certificate check in server templates])
fi

# for dbus interface file mangling
AC_PATH_PROG(XSLT, xsltproc)

AC_ARG_ENABLE(gui,
              AS_HELP_STRING([--enable-gui[=gui type]],
                             [enables building the GTK+ UI that uses the SyncEvolution DBus API.
                              Options: gtk, moblin, all (builds sync-ui-gtk and sync-ui-moblin)
                              "gtk" is the default for --enable-gui without type. No GUI is
                              built when --enable-gui is not used.]),
              [ if test "$enableval" = "gtk" ; then
                    enable_gui=gtk
                elif test "$enableval" = "yes" ; then
                    enable_gui=gtk
                elif test "$enableval" = "moblin" ; then
                    enable_gui=moblin
                elif test "$enableval" = "no" ; then
                    enable_gui=no
                elif test "$enableval" = "all" ; then
                    enable_gui=all
                else
                    AC_ERROR([Unknown gui type: '$enableval'])
                fi
              ],
              [ enable_gui=no ])

AM_CONDITIONAL([COND_GUI], [test "$enable_gui" != "no"])

AC_ARG_ENABLE(core,
              AS_HELP_STRING([--enable-core],
                             [enables building the core SyncEvolution (library, backends)]),
              enable_core="$enableval",
              enable_core="yes")
AM_CONDITIONAL([COND_CORE], [test "$enable_core" = "yes"])

AC_ARG_ENABLE(dbus-service,
              AS_HELP_STRING([--enable-dbus-service],
                             [enables building the dbus service executable and all related features
                             (the DBus wrapper library, command line usage of server, etc).]),
              enable_dbus_service="$enableval",
              [if test $enable_gui = "no"; then
                  enable_dbus_service="no"
               else
                  enable_dbus_service="yes"
               fi])
AM_CONDITIONAL([COND_DBUS], [test "$enable_dbus_service" = "yes"])

PKG_CHECK_MODULES(KEYRING, [gnome-keyring-1], HAVE_KEYRING=yes, HAVE_KEYRING=no)
AC_ARG_ENABLE(gnome-keyring,
              AS_HELP_STRING([--enable-gnome-keyring],
                             [enables or disables support for the GNOME keyring; default is on if development files are available]),
              [enable_gnome_keyring="$enableval"
               test "$enable_gnome_keyring" = "yes" || test "$enable_gnome_keyring" = "no" || AC_ERROR([invalid value for --enable-gnome-keyring: $enable_gnome_keyring])
               test "$enable_gnome_keyring" = "no" || test "$HAVE_KEYRING" = "yes" || AC_ERROR([gnome-keyring-1 pkg not found, needed for --enable-gnome-keyring])],
              enable_gnome_keyring="$HAVE_KEYRING")
if test $enable_gnome_keyring = "yes"; then
    AC_DEFINE(USE_GNOME_KEYRING, 1, [define if gnome keyring should be used in dbus service])
    PKG_CHECK_MODULES([KEYRING_2_20], [gnome-keyring-1 >= 2.20 ], KEYRING220=yes, KEYRING220=no)
    if test $KEYRING220 = "yes"; then
        AC_DEFINE(GNOME_KEYRING_220, 1, [define if gnome keyring version is above 2.20])
    fi
fi


## Begin KWallet ##############################

AC_CHECK_PROGS([QMAKE], [qmake qmake-qt4])

if test "$QMAKE"; then
   KDEKWALLETFOUND=yes
   if ! test "$KDE_KWALLET_CFLAGS"; then
      KDE_KWALLET_CFLAGS="-I`kde4-config --path include` -I`kde4-config --path include`/KDE -I`$QMAKE -query QT_INSTALL_HEADERS`"
   fi
   if ! test "$KDE_KWALLET_LIBS"; then
      KDE_KWALLET_LIBS="-lkdeui -lkdecore `pkg-config --libs QtDBus`"
   fi
   AC_LANG_PUSH(C++)
   old_CPPFLAGS="$CPPFLAGS"
   CPPFLAGS="$CPPFLAGS $KDE_KWALLET_CFLAGS"
   AC_CHECK_HEADERS(kwallet.h, [], [KDEKWALLETFOUND=no])
   CPPFLAGS="$old_CPPFLAGS"
   AC_LANG_POP(C++)
else
   KDEKWALLETFOUND=no
fi

# In contrast to the GNOME KEYRING, the KWallet is
# currently considered optional. "configure" will never enable
# by default, because that is a change that might not be
# expected by traditional users.
AC_ARG_ENABLE(kwallet,
              AS_HELP_STRING([--enable-kwallet], [enable access to KWallet]),
              [use_kde_kwallet="$enableval"
              test $KDEKWALLETFOUND = "yes" || test "$use_kde_kwallet" = "no" || AC_MSG_ERROR([kwallet.pc not found. Install it to compile with the KWallet enabled.])],
              [use_kde_kwallet="no"])

if test "$use_kde_kwallet" = "yes"; then
    # conditional compilation in preprocessor
    AC_DEFINE(USE_KDE_KWALLET, 1, [KWallet available])
    # TODO: KWallet needs Qt. Enable the Qt check in
    # configure-post.in, otherwise it fails to compiler
    # when none of the backends ask for Qt.
else
    # avoid unneeded dependencies on KWallet
    KDE_KWALLET_CFLAGS=
    KDE_KWALLET_LIBS=
fi
AC_SUBST(KDE_KWALLET_LIBS)
AC_SUBST(KDE_KWALLET_CFLAGS)

# conditional compilation in make
AM_CONDITIONAL([USE_KDE_KWALLET], [test "$use_kde_kwallet" = "yes"])

## End KWallet ################################


if test $enable_dbus_service = "yes"; then
    if test -z "$XSLT"; then
       AC_ERROR([xsltproc not found, is required for D-Bus service])
    fi
    PKG_CHECK_MODULES(DBUS, dbus-1, dummy=yes,
                      AC_MSG_ERROR(libdbus-1 is required))
    AC_CHECK_LIB(dbus-1, dbus_watch_get_unix_fd, dummy=yes,
                 AC_DEFINE(NEED_DBUS_WATCH_GET_UNIX_FD, 1,
                 [Define to 1 if you need the dbus_watch_get_unix_fd() function.]))
    need_glib=yes
    # Recent libnotify releases work with gtk+-2.0 and gtk+-3.0. We
    # pick gtk+-2.0 here, to be compatible with old libnotify releases
    # which had that hard-cored and because sync-ui also depends on
    # gtk+-2.0.
    PKG_CHECK_MODULES(LIBNOTIFY, [libnotify gtk+-2.0], HAVE_LIBNOTIFY=yes, HAVE_LIBNOTIFY=no)
    AC_ARG_ENABLE(notify,
                  AS_HELP_STRING([--enable-notify],
                                 [send notifications for automatic sync events, using libnotify]),
                  [ test "$enableval" = "no" || test $HAVE_LIBNOTIFY = "yes" || AC_ERROR([required libnotify package not found]) ],
                  [ test $HAVE_LIBNOTIFY = "yes" || AC_ERROR([required libnotify package not found, use --disable-notify to compile without libnotify based notifications]) ])
    if test $HAVE_LIBNOTIFY = "yes"; then
        AC_DEFINE(HAS_NOTIFY, 1, [define if libnotify could be used in dbus service])
    fi

    AC_ARG_ENABLE(notify-compatibility,
                  AS_HELP_STRING([--enable-notify-compatibility],
                                 [increase compatibility with binary libnotify installations by loading libnotify.so.1..4 dynamically instead of linking against it]),
                                 [enable_notify_compat="$enableval"],
                                 [enable_notify_compat="no"]
                 )
    if test "$enable_notify_compat" = "yes"; then
        AC_DEFINE(NOTIFY_COMPATIBILITY, 1, [dynamically open libnotify])
        LIBNOTIFY_LIBS="`echo $LIBNOTIFY_LIBS | sed -e 's/\(-lnotify\|[^ ]*libnotify.la\)/-ldl/'`"
    fi

    # Here we're using QtGui too because mlite fails to depend on it,
    # despite using QAction.
    PKG_CHECK_MODULES(MLITE, [mlite QtGui], HAVE_MLITE=yes, HAVE_MLITE=no)
    AC_ARG_ENABLE(mlite,
                  AS_HELP_STRING([--enable-mlite],
                                 [send notifications for automatic sync events, using mlite (off by default)]),
                  [ enable_mlite="$enableval"
                    test "$enableval" = "no" || test $HAVE_MLITE = "yes" || AC_ERROR([required mlite package not found]) ],
                  [ enable_mlite="no" ])
    if test $enable_mlite = "yes"; then
        AC_DEFINE(HAS_MLITE, 1, [define if mlite could be used in dbus service])
    else
        # don't use mlite, even if found
        MLITE_CFLAGS=
        MLITE_LIBS=
    fi
    AC_DEFINE(DBUS_SERVICE, 1, [define if dbus service is enabled])
fi
AM_CONDITIONAL([NOTIFY_COMPATIBILITY], [test "$enable_notify_compat" = "yes"])

AC_SUBST(DBUS_CFLAGS)
AC_SUBST(DBUS_LIBS)
AC_SUBST(DBUS_GLIB_CFLAGS)
AC_SUBST(DBUS_GLIB_LIBS)
AC_SUBST(KEYRING_CFLAGS) 
AC_SUBST(KEYRING_LIBS) 
AC_SUBST(LIBNOTIFY_CFLAGS)
AC_SUBST(LIBNOTIFY_LIBS)
AC_SUBST(LIBEXECDIR)
AC_SUBST(BUTEOSYNCPROFILE_LIBS)
AC_SUBST(BUTEOSYNCPROFILE_CFLAGS)
AC_SUBST(BUTEOSYNCCOMMON_LIBS)
AC_SUBST(BUTEOSYNCCOMMON_CFLAGS)

DBUS_SERVICES_DIR="${datadir}/dbus-1/services"
AC_SUBST(DBUS_SERVICES_DIR)
AC_DEFINE_UNQUOTED(DBUS_SERVICES_DIR, "$DBUS_SERVICES_DIR", [Location of D-Bus services directory])

if test $enable_gui != "no" || test $enable_dbus_service = "yes"; then
    IT_PROG_INTLTOOL([0.37.1])
    GETTEXT_PACKAGE=syncevolution
    AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, "$GETTEXT_PACKAGE", [The gettext package name])
    AM_GLIB_GNU_GETTEXT
    SYNCEVOLUTION_LOCALEDIR=[${datadir}/locale]
fi

# decide which sync-ui(s) we are building:
# sync-ui (in either GTK or Moblin mode) or both (in separate binaries)
case $enable_gui in
     all) GUI_PROGRAMS='sync-ui-gtk${EXEEXT} sync-ui-moblin${EXEEXT}'; GUI_DESKTOP_FILES="sync-gtk.desktop sync-moblin.desktop";;
     gtk|moblin) GUI_PROGRAMS='sync-ui${EXEEXT}'; GUI_DESKTOP_FILES="sync.desktop";;
     no) GUI_PROGRAMS=; GUI_DESKTOP_FILES=;;
     *) AC_ERROR([Unknown enable_gui type: '$enable_gui'])
esac

if test $enable_gui != "no"; then
    PKG_CHECK_MODULES(DBUS_GLIB, dbus-glib-1 glib-2.0)
    AC_PATH_PROG(DBUS_BINDING_TOOL, dbus-binding-tool)
    AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal)

    gui_modules="glib-2.0 dbus-glib-1 >= 0.60 gtk+-2.0 libglade-2.0 gio-2.0"
    if test $enable_gui = "moblin"; then
        AC_DEFINE(USE_MOBLIN_UX, 1, [Use Moblin UI widgets])
    fi
    if test $enable_gui = "moblin" -o $enable_gui = "all"; then
        gui_modules="$guimodules mx-gtk-1.0"

        PKG_CHECK_MODULES(MX_GTK_0_99_1, mx-gtk-1.0 >= 0.99.1,
                          have_mx_gtk_0_99_1="yes",
                          have_mx_gtk_0_99_1="no")
        if test $have_mx_gtk_0_99_1 = "yes"; then
            AC_DEFINE(MX_GTK_0_99_1, 1, [we have Mx-Gtk 0.99.1 or better])
        fi
    fi

    PKG_CHECK_MODULES(UNIQUE, unique-1.0,
                      have_unique="yes",
                      have_unique="no")
    if test $have_unique = "yes"; then
        gui_modules="$gui_modules unique-1.0" 
        AC_DEFINE(ENABLE_UNIQUE, 1, [enable single-app-instance functionality])
    fi

    PKG_CHECK_MODULES(GTK_2_18, gtk+-2.0 >= 2.18,
                      have_gtk_2_18="yes",
                      have_gtk_2_18="no")
    if test $have_gtk_2_18 = "yes"; then
        AC_DEFINE(GTK_2_18, 1, [we have GTK+ 2.18 or better])
    fi

    PKG_CHECK_MODULES(GUI, $gui_modules)

    AC_PATH_PROG([GTK_BUILDER_CONV], gtk-builder-convert)
elif test "$enable_dbus_service" = "yes"; then
    # syncevo-dbus-server needs localization
    :
else
    INTLTOOL_UPDATE="true"
    USE_NLS="no"
fi
AC_SUBST(SYNCEVOLUTION_LOCALEDIR)
AC_SUBST(GETTEXT_PACKAGE)
AC_SUBST(GUI_CFLAGS)
AC_SUBST(GUI_LIBS)
AC_SUBST(GUI_PROGRAMS)
AC_SUBST(GUI_DESKTOP_FILES)


# Boost headers: boost/foreach.hpp is needed (1.33/Debian Etch
# doesn't have it, 1.34/Ubuntu 8.10 Hardy does). 1.35 is available
# as Debian Etch backport.
AX_BOOST_BASE(1.34)

# need rst2man for man pages
AC_ARG_WITH(rst2man,
            AS_HELP_STRING([--with-rst2man=<path to reStructuredText to man converter>],
                           [Specifies an explicit path to the utility if not found in PATH.
                            An explicit --without-rst2man or not having it installed turn off
                            building of man pages.]),
            [RST2MAN=$withval
             if test "$RST2MAN" = "yes"; then
                 AC_PATH_PROG(RST2MAN, rst2man, "no")
             fi
             test "$RST2MAN" = "no" || test -x "$RST2MAN" || AC_ERROR([--with-rst2man=$RST2MAN: tool not found])],
            [AC_PATH_PROG(RST2MAN, rst2man, "no")])
AM_CONDITIONAL([COND_MAN_PAGES], [test "$RST2MAN" != "no"])

# need rst2html for HTML version of README
AC_ARG_WITH(rst2html,
            AS_HELP_STRING([--with-rst2html=<path to reStructuredText to HTML converter>],
                           [Specifies an explicit path to the utility if not found in PATH.
                            An explicit --without-rst2html or not having it installed turn off
                            building of README in HTML format.]),
            [RST2HTML=$withval
             if test "$RST2HTML" = "yes"; then
                 AC_PATH_PROG(RST2HTML, rst2html, "no")
             fi
             test "$RST2HTML" = "no" || test -x "$RST2HTML" || AC_ERROR([--with-rst2html=$RST2HTML: tool not found])],
            [AC_PATH_PROG(RST2HTML, rst2html, "no")])
AM_CONDITIONAL([COND_HTML_README], [test "$RST2HTML" != "no"])

# absolute patch to source of Synthesis client library
SYNTHESIS_SRC=no-synthesis-source
AC_SUBST(SYNTHESIS_SRC)
if test "$SYNTHESISSRC" && test "$SYNTHESISSRC" != "none"; then
    # default: checkout a copy of the sources, remove it during maintainer-clean and distclean
    CLEAN_CLIENT_SRC=synthesis-workdir
    SYNTHESIS_SRC=$PWD/src/synthesis-workdir

    AC_MSG_NOTICE( [updating the content of $SYNTHESIS_SRC from $SYNTHESISSRC] )
    case "$SYNTHESISSRC" in
        *.git) protocol=git;;
        *://*) protocol="`echo $SYNTHESISSRC | sed -e 's;://.*;;'`";;
        *) protocol="file";;
    esac

    mkdir -p src
    case $protocol in
        file)
            # use existing copy of the sources
            CLEAN_CLIENT_SRC=
            case "$SYNTHESISSRC" in
                 /*) SYNTHESIS_SRC="$SYNTHESISSRC";;
                 *) SYNTHESIS_SRC="$PWD/$SYNTHESISSRC";;
            esac
            ;;
        *svn*|*http*)
            SYNTHESISSRCREV="$SYNTHESISSRC"
            if test "$REVISION"; then
                revarg="-r $REVISION "
                if `echo $SYNTHESISSRC | grep '@[0123456789]*'` >/dev/null; then
                    :
                else
                    SYNTHESISSRCREV="$SYNTHESISSRC@$REVISION"
                fi
            fi
            if test -d $SYNTHESIS_SRC ; then
                ( set -x; cd $SYNTHESIS_SRC && svn --username=$USERNAME switch $revarg "$SYNTHESISSRC" ) || AC_ERROR([updating from $SYNTHESISSRC failed])
            else
                (set -x; svn --username=$USERNAME checkout $revarg "$SYNTHESISSRCREV" $SYNTHESIS_SRC ) || AC_ERROR([checking out $SYNTHESISSRC failed])
            fi
            ;;
        *)
            if test -d $SYNTHESIS_SRC ; then
                ( set -x; cd $SYNTHESIS_SRC && git fetch "$SYNTHESISSRC" ) || AC_ERROR([updating from $SYNTHESISSRC failed])
            else
                ( set -x; git clone "$SYNTHESISSRC" $SYNTHESIS_SRC ) || AC_ERROR([cloning $SYNTHESISSRC failed])
            fi
            if test "$REVISION"; then
                # git 1.6 finds tags and branches without explicit prefix, 1.4.4.4 doesn't
                ( set -x; cd $SYNTHESIS_SRC &&
                  (git checkout "$REVISION" ||
                   git checkout "tags/$REVISION" ||
                   git checkout "origin/$REVISION") ) || AC_ERROR([checking out $SYNTHESISSRC failed])
            fi
            ;;
    esac
elif test "$SYNTHESISSRC" != "none" && test -d $srcdir/src/synthesis; then
    # use existing copy of the sources; beware of
    # out-of-tree compilation
    case $srcdir in
         /*) SYNTHESIS_SRC="$srcdir/src/synthesis";;
         *) SYNTHESIS_SRC="$PWD/$srcdir/src/synthesis";;
    esac
elif test "$enable_shared" = "no"; then
    # link against engine
    PKG_CHECK_MODULES([SYNTHESIS], [synthesis >= 3.4])
    SYNTHESIS_ENGINE="$SYNTHESIS_LIBS -lsynthesis"
else
    # link against SDK alone, except in client-test
    #PKG_CHECK_MODULES(SYNTHESIS, "synthesis-sdk")
    #SYNTHESIS_ENGINE="`echo $SYNTHESIS_LIBS | sed -e 's/-lsynthesisstubs/-lsynthesis/'`"

    # can't use the SDK alone because of sysync::SySyncDebugPuts()
    PKG_CHECK_MODULES([SYNTHESIS], [synthesis >= SYNTHESIS_MIN_VERSION])
    SYNTHESIS_ENGINE="$SYNTHESIS_LIBS"
fi

if test $SYNTHESIS_SRC != "no-synthesis-source"; then
    ( cd $SYNTHESIS_SRC && ( test -f configure || sh autogen.sh ) ) || AC_MSG_ERROR([--with-synthesis-src=$SYNTHESIS_SRC: no Synthesis configure script found in that directory])

    SYNTHESIS_CONFIGURE="$SYNTHESIS_SRC/configure"
    chmod u+x $SYNTHESIS_SRC/configure $SYNTHESIS_SRC/config.sub $SYNTHESIS_SRC/config.guess

    # use local copy of the sources, with dependencies
    # to trigger building the synthesis library
    SYNTHESIS_SUBDIR=$PWD/src/build-synthesis
    SYNTHESIS_CFLAGS="-I$SYNTHESIS_SUBDIR/src"
    SYNTHESIS_LIBS="$SYNTHESIS_SUBDIR/src/libsynthesissdk.la"

    if test "$enable_core" = "no" && test "$enable_gui" != "no"; then
       # SYNTHESIS_SUBDIR is ignored, at least build headers for GUI
       SYNTHESIS_SUBDIR_INCLUDES=synthesis-includes
    fi

    if test "$enable_shared" = "no"; then
        # link against the engines that were enabled
        case $SYNCML_ENGINES in both|client|server) SYNTHESIS_LIBS="$SYNTHESIS_LIBS $SYNTHESIS_SUBDIR/src/libsynthesis.la";; esac
        AC_DEFINE(ENABLE_SYNCML_LINKED, 1, [SyncML engines are linked directly])
    else
        # It would be nice if we could avoid linking against libsynthesis.la here.
        # This doesn't work at the moment because sysync::SySyncDebugPuts()
        # is called directly by the libsynthesissdk instead of going through
        # the normal C function pointer lookup.
        SYNTHESIS_LIBS="$SYNTHESIS_LIBS $SYNTHESIS_SUBDIR/src/libsynthesis.la"
    fi
    SYNTHESIS_DEP=$SYNTHESIS_LIBS

    # for linking client-test
    SYNTHESIS_ENGINE="$SYNTHESIS_SUBDIR/src/libsynthesis.la"

    AC_MSG_NOTICE( [configuring the Synthesis library] )
    if (set -x; mkdir -p $SYNTHESIS_SUBDIR && cd $SYNTHESIS_SUBDIR && eval "\$SHELL \"\$SYNTHESIS_CONFIGURE\" $ac_configure_args \"--srcdir=\$SYNTHESIS_SRC\" " ); then true; else
        AC_MSG_ERROR( [configuring Synthesis library failed] )
    fi

    # do the version check with the .pc files prepared by the configure step above
    export PKG_CONFIG_PATH=$SYNTHESIS_SUBDIR:$PKG_CONFIG_PATH
    PKG_CHECK_MODULES([WITH_SYNTHESIS_SRC], [synthesis >= SYNTHESIS_MIN_VERSION],
                      [],
                      [AC_MSG_ERROR([need at least libsynthesis >= SYNTHESIS_MIN_VERSION; the latest libsynthesis for SyncEvolution is the one from http://meego.gitorious.org/meego-middleware/libsynthesis])])

fi

AC_SUBST(SYNTHESIS_CFLAGS)
AC_SUBST(SYNTHESIS_LIBS)
AC_SUBST(SYNTHESIS)
AC_SUBST(SYNTHESIS_SUBDIR)
AC_SUBST(SYNTHESIS_SUBDIR_INCLUDES)
AC_SUBST(SYNTHESIS_DEP)
AC_SUBST(SYNTHESIS_ENGINE)
AC_SUBST(SYNTHESIS_LIB)
AC_SUBST(SYNTHESISSRC)

dnl select backends
BACKENDS=""

# AC_ARG_ENABLE_BACKEND(BACKEND, DIR, HELP-STRING, [ACTION-IF-GIVEN],
#                       [ACTION-IF-NOT-GIVEN])
#
# Same as AC_ARG_ENABLE(), but also tells configure that the
# backend exists.
#
# BACKEND = name of modules built in that dir as .la files without the
#           obligatory sync prefix, e.g. "ebook"
# DIR = name of the directory inside src/backends, e.g., "evolution"
AC_DEFUN([AC_ARG_ENABLE_BACKEND],
[
        AC_ARG_ENABLE($1, $3, $4, $5)
        BACKENDS="$BACKENDS $1"
        BACKEND_DEFINES="$BACKEND_DEFINES ENABLE_`echo $1 | tr a-z A-Z`"
        for source in $2; do
            SYNCSOURCES="$SYNCSOURCES backends/$2/sync$1.la"
        done
])
AC_SUBST(SYNCSOURCES)
AC_SUBST(BACKEND_DEFINES)

BACKEND_CPPFLAGS="$SYNTHESIS_CFLAGS $EPACKAGE_CFLAGS $EBOOK_CFLAGS $ECAL_CFLAGS $GLIB_CFLAGS $BOOST_CPPFLAGS"
AC_SUBST(BACKEND_CPPFLAGS)

# GNOME Bluetooth Panel plugin
PKG_CHECK_MODULES(GNOMEBLUETOOTH, [gnome-bluetooth-1.0 >= 2.27.6],
                  [have_gbt="yes"
                   GNOMEBLUETOOTH_DIR=`$PKG_CONFIG --variable=libdir gnome-bluetooth-1.0 2>/dev/null`/gnome-bluetooth],
                   have_gbt="no")
AC_SUBST(GNOMEBLUETOOTH_CFLAGS)
AC_SUBST(GNOMEBLUETOOTH_DIR)

AC_ARG_ENABLE(gnome-bluetooth-panel-plugin, 
        AC_HELP_STRING([--enable-gnome-bluetooth-panel-plugin],
                       [GNOME Bluetooth panel plugin adding a "sync" button for paired devices (off by default)]),
                       [enable_gnome_bluetooth_panel="$enableval"],
        [enable_gnome_bluetooth_panel="no"]
        )
if test "$enable_gnome_bluetooth_panel" = "yes"; then
   test "$have_gbt" = "yes" || AC_MSG_ERROR([--enable-gnome-bluetooth-panel requires
           pkg-config information for gnome-bluetooth-1.0 >= 2.27.6 which was not found])
fi
AC_CONFIG_FILES(src/gnome-bluetooth/Makefile)
AM_CONDITIONAL([ENABLE_GNOME_BLUETOOTH_PANEL], [test "$have_gbt" = "yes" && test "$enable_gnome_bluetooth_panel" = "yes"])

AC_ARG_ENABLE(doc,
              AC_HELP_STRING([--enable-doc],
                             [generate backend and DBus API documentation]),
              enable_doc="$enableval", enable_doc="no")
            
AM_CONDITIONAL([COND_DOC], [test "$enable_doc" != "no"])

dnl src/backends/*/configure-sub.in and configure-post.in follow
