gnustep/libs-back
0
0
Fork 0
mirror of https://github.com/gnustep/libs-back.git synced 2025-02-22 19:31:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
libs-back/configure.ac
Eric Wasylishen 7b16c6e465 * configure.ac: Test for Xfixes 
* configure: Regenerate
* config.h.in: Regenerate
* Tools/xpbs.m: If Xfixes is available, use it to receive notifications when the
owner of an X11 selection changes.

In the future we should invalidate the list of cached pasteboard types when this
happens, so, e.g. copying text from gnome-terminal, the general pasteboard will only
have the text type, but subsequently copying text from OpenOffice.org, the general
pasteboard will have plain text and RTF types (currently we don't do this, so
you can't paste RTF contents unless it is in the clipboard when gpbs starts.)

The above problem is also why DND from X to GNUstep doesn't work - the dragging
pasteboard types are never updated.


git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/back/trunk@33708 72102866-910b-0410-8b05-ffd578937521
2011-08-07 21:38:42 +00:00

686 lines
23 KiB
Text
Raw Blame History

# configure.in for GNUstep GUI Backend
# Process this file with autoconf to produce a configure script.
#
# Copyright (C) 1996-2002 Free Software Foundation, Inc.
#
# Author: Adam Fedor <fedor@gnu.org>
#
# This file is part of the GNUstep Backend.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 3 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; see the file COPYING.LIB.
# If not, see <http://www.gnu.org/licenses/> or write to the
# Free Software Foundation, 51 Franklin Street, Fifth Floor,
# Boston, MA 02110-1301, USA.
builtin(include, pkg.m4)dnl
AC_INIT
AC_PREREQ(2.57)
AC_CONFIG_SRCDIR([back.make.in])
AC_CONFIG_HEADER(config.h)
# If GNUSTEP_MAKEFILES is undefined, try to use gnustep-config to determine it.
if test -z "$GNUSTEP_MAKEFILES"; then
GNUSTEP_MAKEFILES=`gnustep-config --variable=GNUSTEP_MAKEFILES 2>&5`
fi
if test -z "$GNUSTEP_MAKEFILES"; then
AC_MSG_ERROR([You must have the gnustep-make package installed and set up the GNUSTEP_MAKEFILES environment variable to contain the path to the makefiles directory before configuring!])
fi
#--------------------------------------------------------------------
# Use config.guess, config.sub and install-sh provided by gnustep-make
#--------------------------------------------------------------------
AC_CONFIG_AUX_DIR($GNUSTEP_MAKEFILES)
#--------------------------------------------------------------------
# Determine the host, build, and target systems
#--------------------------------------------------------------------
AC_PROG_CC
AC_CANONICAL_TARGET([])
#--------------------------------------------------------------------
# The following is so that headers and custom libraries
# in the GNUstep root are used before the standard ones
#--------------------------------------------------------------------
GRAPHIC_CFLAGS="$CPPFLAGS"
GRAPHIC_LFLAGS="$LDFLAGS"
#
# It looks like we ought to source the whole GNUstep.sh here, and even
# ask it to output all variables! That way we have access to (eg)
# GNUSTEP_SYSTEM_HEADERS below.
#
GNUSTEP_SH_EXPORT_ALL_VARIABLES=yes
. "$GNUSTEP_MAKEFILES/GNUstep.sh"
unset GNUSTEP_SH_EXPORT_ALL_VARIABLES
# For backwards compatibility, define GNUSTEP_SYSTEM_HEADERS from
# GNUSTEP_SYSTEM_ROOT if not set yet.
if test x"$GNUSTEP_SYSTEM_HEADERS" = x""; then
GNUSTEP_SYSTEM_HEADERS="$GNUSTEP_SYSTEM_ROOT/Library/Headers"
fi
if test x"$GNUSTEP_SYSTEM_LIBRARIES" = x""; then
GNUSTEP_SYSTEM_LIBRARIES="$GNUSTEP_SYSTEM_ROOT/Library/Libraries"
fi
if test "$GNUSTEP_IS_FLATTENED" = no; then
clean_target_os=`$GNUSTEP_MAKEFILES/clean_os.sh $target_os`
clean_target_cpu=`$GNUSTEP_MAKEFILES/clean_cpu.sh $target_cpu`
obj_dir=$clean_target_cpu/$clean_target_os
GNUSTEP_LDIR=$GNUSTEP_SYSTEM_LIBRARIES/$obj_dir
GNUSTEP_HDIR=$GNUSTEP_SYSTEM_HEADERS/$LIBRARY_COMBO
else
GNUSTEP_LDIR=$GNUSTEP_SYSTEM_LIBRARIES
GNUSTEP_HDIR=$GNUSTEP_SYSTEM_HEADERS
fi
CPPFLAGS="$CPPFLAGS -I$GNUSTEP_HDIR"
LDFLAGS="$LDFLAGS -L$GNUSTEP_LDIR/$LIBRARY_COMBO -L$GNUSTEP_LDIR"
#--------------------------------------------------------------------
# Add target OS directories as necessary
#--------------------------------------------------------------------
case "$target_os" in
freebsd* | openbsd* )
CPPFLAGS="$CPPFLAGS -I/usr/pkg/include"
LDFLAGS="$LDFLAGS -L/usr/pkg/lib";;
netbsd*) CPPFLAGS="$CPPFLAGS -I/usr/pkg/include"
LDFLAGS="$LDFLAGS -Wl,-R/usr/pkg/lib -L/usr/pkg/lib";;
esac
#--------------------------------------------------------------------
# These headers/functions needed by gpbs.m
#--------------------------------------------------------------------
AC_CHECK_HEADERS(syslog.h)
AC_CHECK_FUNCS(syslog)
#--------------------------------------------------------------------
# Find TIFF (Solaris requires this to find the correct library, even though
# it does not link directly to it)
#--------------------------------------------------------------------
AC_ARG_WITH(tiff_library,
[ --with-tiff-library=DIR TIFF library file are in DIR], ,
with_tiff_library=)
if test -n "$with_tiff_library"; then
GRAPHIC_LFLAGS="$GRAPHIC_LFLAGS -L$with_tiff_library"
fi
#--------------------------------------------------------------------
# Find for X windows
#--------------------------------------------------------------------
set_x_paths=yes
AC_PATH_XTRA
if test "x$no_x" = xyes; then
set_x_paths=no
fi
if test $set_x_paths = yes; then
GRAPHIC_CFLAGS="$X_CFLAGS $GRAPHIC_CFLAGS"
CPPFLAGS="$X_CFLAGS $CPPFLAGS"
# Note: Don't include $X_LIBS in LDFLAGS as it may conflict with
# other libraries installed in /sw, /sw/lib/freetyp2/lib
#GRAPHIC_LFLAGS="$X_LIBS $GRAPHIC_LFLAGS"
# But do include it here just to find the extra x libraries
LDFLAGS="$X_LIBS $LDFLAGS"
LIBS="-lX11 $X_EXTRA_LIBS $LIBS"
AC_CHECK_LIB(Xext, main)
if test "$HAVE_LIBXext" = no; then
PKG_CHECK_MODULES([XEXT], [xext])
fi
AC_CHECK_LIB(Xt, main)
if test "$HAVE_LIBXt" = no; then
PKG_CHECK_MODULES([XT], [xt])
fi
AC_CHECK_LIB(Xmu, main)
if test "$HAVE_LIBXmu" = no; then
PKG_CHECK_MODULES([XMU], [xmu])
fi
AC_CHECK_LIB(Xfixes, XFixesSelectSelectionInput,
[
LIBS="-lXfixes $LIBS"
AC_DEFINE(HAVE_XFIXES, 1, [Define to enable Xfixes support])
]
,)
AC_CHECK_LIB(Xcursor, XcursorImageCreate,
[
LIBS="-lXcursor $LIBS"
AC_DEFINE(HAVE_XCURSOR, 1, [Define to enable Xcursor support])
]
,)
LIBS="$X_LIBS $LIBS"
fi
AC_SUBST(X_PRE_LIBS)
# Old X11 support
AC_MSG_CHECKING([for X11 function prototypes])
AC_EGREP_CPP(yes,
[#include <X11/Xlib.h>
#if NeedFunctionPrototypes
yes
#endif
], have_funcproto=yes, have_funcproto=no)
AC_MSG_RESULT([$have_funcproto])
if test "$have_funcproto" = no; then
AC_DEFINE(FUNCPROTO,1,[Define if X11 doesn't automatically use prototypes])
fi
#--------------------------------------------------------------------
# Find for DPS
#--------------------------------------------------------------------
save_CPPFLAGS=${CPPFLAGS}
if test -r $x_includes/X11/DPS; then
CPPFLAGS="-I$x_includes/X11 $CPPFLAGS"
fi
AC_CHECK_HEADERS([DPS/dpsclient.h DPS/dpsNXargs.h])
if test $ac_cv_header_DPS_dpsNXargs_h = no; then
CPPFLAGS="${save_CPPFLAGS}"
fi
#--------------------------------------------------------------------
# freetype libraries
#--------------------------------------------------------------------
# Mac OS X with macports has a freetype which includes Apple's Foundation
# which we do not want
AC_ARG_WITH(freetype,
[ --without-freetype Do not check for or include freetype], ,
with_freetype=yes)
have_freetype=no
if test $with_freetype = yes; then
FREETYPE_LIBS="`freetype-config --libs`"
FREETYPE_CFLAGS="`freetype-config --cflags`"
if test x"$FREETYPE_LIBS" != x; then
save_CPPFLAGS=${CPPFLAGS}
CPPFLAGS="${CPPFLAGS} ${FREETYPE_CFLAGS}"
AC_CHECK_HEADER(ft2build.h,have_freetype=yes, have_freetype=no)
CPPFLAGS="${save_CPPFLAGS}"
fi
fi
#--------------------------------------------------------------------
# Extended font support & UTF8 support
#--------------------------------------------------------------------
PKG_XFT=no
PKG_CHECK_MODULES(XFT, xft, WITH_XFT=yes, WITH_XFT=no)
if test $WITH_XFT = no; then
# pkg-config failed for some reason, Check the old way?
save_CPPFLAGS=${CPPFLAGS}
save_LIBS=${LIBS}
if test $have_freetype = yes; then
LIBS="$FREETYPE_LIBS $LIBS"
CPPFLAGS="$FREETYPE_CFLAGS $CPPFLAGS"
fi
AC_CHECK_LIB(Xft, XftFontOpen)
AC_CHECK_HEADER(X11/Xft/Xft.h)
if test "$ac_cv_lib_Xft_XftFontOpen" = yes -a "$ac_cv_header_X11_Xft_Xft_h" = yes; then
WITH_XFT=yes
XFT_LIBS="-lXft $FREETYPE_LIBS"
XFT_CFLAGS="$FREETYPE_CFLAGS"
fi
CPPFLAGS=${save_CPPFLAGS}
LIBS=${save_LIBS}
else
WITH_XFT=yes
PKG_XFT=yes
fi
if test $WITH_XFT = yes; then
# Now add in some extra defines depending on what we have.
save_CPPFLAGS=${CPPFLAGS}
save_LIBS=${LIBS}
CPPFLAGS="$XFT_CFLAGS $CPPFLAGS"
LIBS="$XFT_LIBS $LIBS"
AC_DEFINE(HAVE_XFT,1,[Define if you have a functional XFreeType installation, including libXft.])
AC_CHECK_LIB(Xft, XftDrawStringUtf8, have_utf8=yes, have_utf8=no)
if test "$have_utf8" = yes; then
AC_DEFINE(HAVE_UTF8,1,[Define if you have XftDrawStringUtf8])
fi
AC_CHECK_LIB(Xft, XftPatternGetString, have_xftpgs=yes, have_xftpgs=no)
AC_HAVE_FUNCS(Xutf8LookupString)
AC_CHECK_LIB(fontconfig, FcPatternCreate, have_fc=yes, have_fc=no)
AC_CHECK_HEADER(fontconfig/fontconfig.h)
if test "$have_fc" = yes -a "$ac_cv_header_fontconfig_fontconfig_h" = yes; then
# fontconfig is likely to be included if we found xft via pkg-config, so
# don't include it twice
if test $PKG_XFT = no; then
XFT_LIBS="${XFT_LIBS} -lfontconfig"
fi
AC_DEFINE(HAVE_FC,1,[Define if you have FcPatternCreate])
fi
CPPFLAGS=${save_CPPFLAGS}
LIBS=${save_LIBS}
fi
AC_SUBST(WITH_XFT)
#--------------------------------------------------------------------
# GLX support
#--------------------------------------------------------------------
WITH_GLX=no
AC_ARG_ENABLE(glx,
[ --disable-glx Disable GLX support],,
enable_glx=yes)
if test "x$enable_glx" = "xyes"; then
AC_CHECK_LIB(GL, glXMakeContextCurrent, have_glx=yes, have_glx=no)
AC_CHECK_HEADER(GL/glx.h)
AC_MSG_CHECKING([for GLX_RGBA_TYPE])
AC_EGREP_CPP(yes,
[#include <GL/glx.h>
#ifdef GLX_RGBA_TYPE
yes
#endif
], have_glx_rgba=yes, have_glx_rgba=no)
AC_MSG_RESULT([$have_glx_rgba])
if test "$have_glx" = yes -a "$ac_cv_header_GL_glx_h" = yes -a "$have_glx_rgba" = yes; then
GLX_LIBS="-lGL"
GLX_FLAGS=""
WITH_GLX=yes
AC_DEFINE(HAVE_GLX,1,[Define if you have the glx library])
fi
fi
AC_SUBST(WITH_GLX)
#--------------------------------------------------------------------
# XIM support
#--------------------------------------------------------------------
AC_ARG_ENABLE(xim,
[ --disable-xim Disable XIM support],,
enable_xim=yes)
if test "x$enable_xim" = "xyes"; then
AC_DEFINE(USE_XIM,1,[Define to enable XIM support])
fi
#--------------------------------------------------------------------
# Functions
#--------------------------------------------------------------------
AC_HAVE_FUNCS(usleep)
have_xshm=no
AC_CHECK_HEADERS(X11/extensions/XShm.h,
have_xshm=yes,,
[#include <X11/Xlib.h>])
AC_CHECK_FUNCS(shmctl)
if test "$ac_cv_header_X11_extensions_XShm_h" = yes -a "$ac_cv_func_shmctl" = yes; then
AC_DEFINE(XSHM,1,[Define if you have X11 XShm extensions])
fi
AC_CHECK_LIB(X11, XInternAtoms,
AC_DEFINE([HAVE_XINTERNATOMS], 1,
[Define to 1 if you have 'XInternAtoms' function.]),
,
$X_LIBS)
#--------------------------------------------------------------------
# Window's graphics library
#--------------------------------------------------------------------
AC_CHECK_LIB(gdi32, main, have_gdi32=yes, have_gdi32=no)
if test "$have_gdi32" = yes; then
WIN32_LIBS="-lgdi32 -lm"
fi
AC_CHECK_LIB(msimg32, main, have_msimg32=yes, have_msimg32=no)
if test "$have_msimg32" = yes; then
WIN32_LIBS="${WIN32_LIBS} -lmsimg32"
fi
#--------------------------------------------------------------------
# WGL support
#--------------------------------------------------------------------
WITH_WGL=no
AC_ARG_ENABLE(wgl,
[ --disable-wgl Disable WGL support],,
enable_wgl=yes)
if test "x$enable_wgl" = "xyes"; then
AC_CHECK_LIB(opengl32, main, have_wgl=yes, have_wgl=no)
save_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="$CPPFLAGS"
AC_CHECK_HEADER(windows.h)
CPPFLAGS="$save_CPPFLAGS"
if test "$have_wgl" = yes -a "$ac_cv_header_windows_h" = yes; then
AC_MSG_CHECKING([for wgl])
WGL_LIBS="-lopengl32 -lgdi32"
WGL_CFLAGS=""
save_libs="$LIBS"
LIBS="$WGL_LIBS"
AC_TRY_LINK([#include <windows.h>], [int main() { wglCreateContext(0); }],
[use_wgl=yes], [use_wgl=no])
LIBS="$save_libs"
AC_MSG_RESULT([$use_wgl])
WITH_WGL=$use_wgl
AC_DEFINE(HAVE_WGL,1,[Define if you have the wgl library])
fi
fi
AC_SUBST(WITH_WGL)
#--------------------------------------------------------------------
# libart graphics libraries
#--------------------------------------------------------------------
AC_MSG_CHECKING([for libart2])
LIBART_VERSION="`libart2-config --version 2>/dev/null`"
if test x"$LIBART_VERSION" = x; then
LIBART_VERSION="none"
fi
AC_MSG_RESULT([$LIBART_VERSION])
LIBART_LIBS="`libart2-config --libs 2>/dev/null`"
LIBART_CFLAGS="`libart2-config --cflags 2>/dev/null`"
if test x"$LIBART_LIBS" = x; then
# No libart2-config, is there any point in checking for individual libs?
AC_CHECK_LIB(art_lgpl_2, main, have_libart=yes, have_libart=no)
if test "$have_libart" = yes; then
AC_CHECK_HEADER(libart_lgpl/libart.h,have_libart=yes, have_libart=no)
fi
if test "$have_libart" = yes; then
LIBART_LIBS="-lart_lgpl_2"
fi
else
have_libart=yes
fi
#--------------------------------------------------------------------
# Cairo graphics libraries
#--------------------------------------------------------------------
PKG_CAIRO=no
PKG_CHECK_MODULES(CAIRO, cairo, have_cairo=yes, have_cairo=no)
PKG_CAIRO_FT=no
PKG_CHECK_MODULES(CAIRO_FT, cairo-ft, have_cairo_ft=yes, have_cairo_ft=no)
PKG_CAIRO_XLIB=no
PKG_CHECK_MODULES(CAIRO_XLIB, cairo-xlib, have_cairo_xlib=yes, have_cairo_xlib=no)
PKG_CAIRO_WIN32=no
PKG_CHECK_MODULES(CAIRO_WIN32, cairo-win32, have_cairo_win32=yes, have_cairo_win32=no)
PKG_CAIRO_GLITZ=no
PKG_CHECK_MODULES(CAIRO_GLITZ, cairo-glitz, have_cairo_glitz=yes, have_cairo_glitz=no)
#--------------------------------------------------------------------
# XRender support
#--------------------------------------------------------------------
have_xrender=no
AC_CHECK_LIB(Xrender, XRenderFindVisualFormat, have_xrender=yes)
#--------------------------------------------------------------------
# Glitz libraries
#--------------------------------------------------------------------
WITH_GLITZ=no
AC_ARG_ENABLE(glitz,
[ --enable-glitz Enable Glitz support],,
enable_glitz=no)
if test "x$enable_glitz" = "xyes"; then
PKG_CHECK_MODULES(GLITZ, glitz, have_glitz=yes, have_glitz=no)
save_CPPFLAGS=$CPPFLAGS
CPPFLAGS="$CPPFLAGS $GLITZ_CFLAGS"
AC_CHECK_HEADER(glitz.h,have_glitz_h=yes, have_glitz_h=no)
CPPFLAGS=$save_CPPFLAGS
if test "$have_glitz" = yes -a "$have_glitz_h" = yes; then
if test "x$WITH_GLX" = "xyes"; then
PKG_CHECK_MODULES(GLITZ_GLX, glitz-glx, have_glitz_glx=yes, have_glitz_glx=no)
save_CPPFLAGS=$CPPFLAGS
CPPFLAGS="$CPPFLAGS $GLITZ_GLX_CFLAGS"
AC_CHECK_HEADER(glitz-glx.h,have_glitz_glx_h=yes, have_glitz_glx_h=no)
CPPFLAGS=$save_CPPFLAGS
if test "$have_glitz_glx" = yes -a "$have_glitz_glx_h" = yes; then
GLITZ_LIBS="$GLITZ_LIBS $GLITZ_GLX_LIBS"
GLITZ_CFLAGS="$GLITZ_CFLAGS $GLITZ_GLX_CFLAGS"
AC_DEFINE(HAVE_GLITZ_GLX,1,[Define if you have glitz-glx])
WITH_GLITZ=yes
fi
fi
if test "x$WITH_WGL" = "xyes"; then
PKG_CHECK_MODULES(GLITZ_WGL, glitz-wgl, have_glitz_wgl=yes, have_glitz_wgl=no)
save_CPPFLAGS=$CPPFLAGS
CPPFLAGS="$CPPFLAGS $GLITZ_WGL_CFLAGS"
AC_CHECK_HEADER(glitz-wgl.h,have_glitz_wgl_h=yes, have_glitz_wgl_h=no)
CPPFLAGS=$save_CPPFLAGS
if test "$have_glitz_wgl" = yes -a "$have_glitz_wgl_h" = yes; then
GLITZ_LIBS="$GLITZ_LIBS $GLITZ_WGL_LIBS"
GLITZ_CFLAGS="$GLITZ_CFLAGS $GLITZ_WGL_CFLAGS"
AC_DEFINE(HAVE_GLITZ_WGL,1,[Define if you have glitz-wgl])
WITH_GLITZ=yes
fi
fi
if test "$WITH_GLITZ" != "yes" ; then
AC_MSG_ERROR([Invalid glitz backend : glitz-glx or glitz-wgl required.])
AC_MSG_NOTICE([Glitz disable])
fi
AC_DEFINE(USE_GLITZ,1,[Define to enable glitz support])
fi
AC_SUBST(WITH_GLITZ)
fi
#--------------------------------------------------------------------
# Set definitions
#--------------------------------------------------------------------
WITH_WRASTER=no
AC_SUBST(WITH_WRASTER)
# Revert to previous flags (removing added GNUstep flags)
CPPFLAGS=${GRAPHIC_CFLAGS}
LDFLAGS=${GRAPHIC_LFLAGS}
#--------------------------------------------------------------------
# Which projects should we build?
#--------------------------------------------------------------------
BUILD_SERVER=x11
BUILD_GRAPHICS=cairo
case $target_os in
*mingw32* ) BUILD_SERVER=win32
BUILD_GRAPHICS=winlib;;
esac
AC_ARG_ENABLE(server,
[ --enable-server=SRV Build server type: x11, win32],,
enable_server=$BUILD_SERVER)
AC_ARG_ENABLE(graphics,
[ --enable-graphics=GPH Build graphics: xlib, xdps, winlib, art, cairo],,
enable_graphics="$BUILD_GRAPHICS")
BUILD_SERVER=$enable_server
BUILD_GRAPHICS="$enable_graphics"
AC_MSG_CHECKING(Backend Server)
AC_MSG_RESULT($BUILD_SERVER)
AC_MSG_CHECKING(Backend Graphics)
AC_MSG_RESULT($BUILD_GRAPHICS)
if test x"$BUILD_GRAPHICS" = "xcairo"; then
if test "$have_freetype" = no; then
AC_MSG_WARN([can't find freetype, required for graphics=cairo])
if test $BUILD_SERVER = win32; then
BUILD_GRAPHICS=winlib
else
BUILD_GRAPHICS=xlib
fi
AC_MSG_NOTICE([Switching to $BUILD_GRAPHICS])
elif test "$have_cairo" = no -o "$have_cairo-ft" = no ; then
AC_MSG_WARN([can't find cairo, required for graphics=cairo!])
if test $BUILD_SERVER = win32; then
BUILD_GRAPHICS=winlib
else
BUILD_GRAPHICS=art
fi
AC_MSG_NOTICE([Switching to $BUILD_GRAPHICS])
else
AC_MSG_CHECKING(Cairo backend)
CAIRO_LIBS="$CAIRO_FT_LIBS"
CAIRO_CFLAGS="$CAIRO_FT_CFLAGS"
if test "$have_xrender" = yes; then
if test $BUILD_SERVER = x11 -a "x$have_cairo_xlib" = "xyes"; then
AC_DEFINE(XRENDER,1,[Define if you have X11 XRender extension])
CAIRO_LIBS="$CAIRO_LIBS -lXrender"
fi
fi
if test "x$WITH_GLITZ" = "xyes" -a "x$have_cairo_glitz" = "xyes"; then
if test $BUILD_SERVER = win32 -a "x$have_cairo_win32" = "xyes"; then
CAIRO_GLITZ_LIBS="$CAIRO_GLITZ_LIBS $GLITZ_WGL_LIBS"
CAIRO_GLITZ_CFLAGS="$CAIRO_GLITZ_CFLAGS $GLITZ_WGL_CFLAGS"
elif test $BUILD_SERVER = x11 -a "x$have_cairo_xlib" = "xyes"; then
CAIRO_GLITZ_LIBS="$CAIRO_GLITZ_LIBS $GLITZ_GLX_LIBS"
CAIRO_GLITZ_CFLAGS="$CAIRO_GLITZ_CFLAGS $GLITZ_GLX_CFLAGS"
else
AC_MSG_ERROR([Invalid Glitz installation])
fi
CAIRO_LIBS="$CAIRO_LIBS $CAIRO_GLITZ_LIBS"
CAIRO_CFLAGS="$CAIRO_CFLAGS $CAIRO_GLITZ_CFLAGS"
AC_MSG_RESULT(glitz)
AC_MSG_WARN([**** Cairo-over-Glitz backend is highly experimental])
AC_MSG_WARN([**** You definitively shouldn't do that.])
AC_MSG_WARN([**** It actually does not work !])
AC_MSG_WARN([**** Are you a backend developer ?])
elif test $BUILD_SERVER = win32 -a "x$have_cairo_win32" = "xyes"; then
CAIRO_LIBS="$CAIRO_LIBS $CAIRO_WIN32_LIBS $WIN32_LIBS"
CAIRO_CFLAGS="$CAIRO_CFLAGS $CAIRO_WIN32_CFLAGS"
AC_MSG_RESULT(winlib)
AC_MSG_WARN([**** Cairo backend on win32 is experimental and is not supported.])
AC_MSG_WARN([**** Are you a backend developer ?])
elif test $BUILD_SERVER = x11 -a "x$have_cairo_xlib" = "xyes"; then
CAIRO_LIBS="$CAIRO_LIBS $CAIRO_XLIB_LIBS $XFT_LIBS"
CAIRO_CFLAGS="$CAIRO_CFLAGS $CAIRO_XLIB_CFLAGS"
AC_MSG_RESULT(xlib)
else
AC_MSG_ERROR([Invalid Cairo installation])
fi
LIBS="$CAIRO_LIBS $LIBS"
CPPFLAGS="$CAIRO_CFLAGS $CPPFLAGS"
fi
fi
if test x"$BUILD_GRAPHICS" = "xxdps"; then
CPPFLAGS="-I$x_includes/X11 $CPPFLAGS"
LIBS="-ldpstk -ldps -lpsres -lXt $X_PRE_LIBS $LIBS"
elif test x"$BUILD_GRAPHICS" = "xcairo"; then
: # Alread handled above
elif test x"$BUILD_GRAPHICS" = "xart"; then
if test "$have_freetype" = no; then
AC_MSG_WARN([can't find freetype, required for graphics=art])
if test $BUILD_SERVER = win32; then
BUILD_GRAPHICS=winlib
else
BUILD_GRAPHICS=xlib
fi
AC_MSG_NOTICE([Switching to $BUILD_GRAPHICS])
elif test "$have_libart" = no; then
AC_MSG_WARN([can't find libart, required for graphics=art])
if test $BUILD_SERVER = win32; then
BUILD_GRAPHICS=winlib
else
BUILD_GRAPHICS=xlib
fi
AC_MSG_NOTICE([Switching to $BUILD_GRAPHICS])
else
LIBS="$LIBART_LIBS $FREETYPE_LIBS $LIBS"
CPPFLAGS="$LIBART_CFLAGS $FREETYPE_CFLAGS $CPPFLAGS"
fi
elif test x"$BUILD_GRAPHICS" = "xxlib"; then
: # Nothing to do
elif test x"$BUILD_GRAPHICS" = "xwinlib"; then
: # Nothing to do
else
AC_MSG_ERROR([Invalid graphics backend $BUILD_GRAPHICS])
fi
if test x"$BUILD_GRAPHICS" = "xwinlib"; then
LIBS="$WIN32_LIBS $LIBS"
fi
if test x"$BUILD_GRAPHICS" = "xxlib"; then
LIBS="$XFT_LIBS $LIBS"
CPPFLAGS="$XFT_CFLAGS $CPPFLAGS"
fi
if test $BUILD_SERVER = x11; then
if test $set_x_paths = no; then
AC_MSG_ERROR([No X11 libraries/headers for building x11 server])
fi
if test "$ac_cv_lib_Xt_main" = no; then
AC_MSG_ERROR([libXt not found - required for building x11 server])
fi
if test "$ac_cv_lib_Xext" = no; then
AC_MSG_ERROR([libXext not found - required for building x11 server])
fi
if test "x$WITH_GLX" = "xyes"; then
LIBS="$LIBS $GLX_LIBS"
CPPFLAGS="$CPPFLAGS $GLX_CFLAGS"
else
AC_MSG_NOTICE([Warning : no OpenGL support for X11 backend])
fi
fi
if test $BUILD_SERVER = win32; then
if test "x$WITH_WGL" = "xyes"; then
LIBS="$LIBS $WGL_LIBS"
CPPFLAGS="$CPPFLAGS $WGL_CFLAGS"
else
AC_MSG_NOTICE([Warning : no OpenGL support for win32 backend])
fi
fi
AH_TOP([
#define SERVER_x11 1
#define SERVER_win32 2
])
AC_DEFINE_UNQUOTED(BUILD_SERVER,SERVER_$BUILD_SERVER,
[Define to type of window server to build])
AC_DEFINE_UNQUOTED(BUILD_GRAPHICS,$BUILD_GRAPHICS,
[Define to type of graphics context to build])
AC_SUBST(BUILD_GRAPHICS)
AC_SUBST(BUILD_SERVER)
#--------------------------------------------------------------------
# Check for -Wdeclaration-after-statement
#--------------------------------------------------------------------
AC_MSG_CHECKING(whether the compiler supports -Wdeclaration-after-statement)
saved_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -Wdeclaration-after-statement"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],HAS_W_DECL_AFTER_STATEMENT=yes,HAS_W_DECL_AFTER_STATEMENT=no)
CFLAGS="$saved_CFLAGS"
AC_MSG_RESULT($HAS_W_DECL_AFTER_STATEMENT)
if test x"$HAS_W_DECL_AFTER_STATEMENT" = x"yes"; then
WARN_FLAGS="-Wall -Wdeclaration-after-statement"
else
WARN_FLAGS=-Wall
fi
AC_SUBST(WARN_FLAGS)
#--------------------------------------------------------------------
# Set the name of the backend
#--------------------------------------------------------------------
AC_ARG_WITH(name,
[ --with-name=PREFIX Set the name of the backend (def=back)])
AC_MSG_CHECKING(Backend name)
if test "x$with_name" = "x"; then
BACKEND_NAME=back
else
BACKEND_NAME=${with_name}
fi
AC_MSG_RESULT($BACKEND_NAME)
AC_SUBST(BACKEND_NAME)
AC_CONFIG_FILES([back.make config.make])
AC_OUTPUT
Reference in a new issue View git blame Copy permalink