path: root/configure

#!/bin/sh
#
# Configures the libmeegotouch build
#
# Copyright (C) 2010 Nokia Corporation.
#
# This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
# WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

#-------------------------------------------------------------------------------
# script initialization
#-------------------------------------------------------------------------------

# the name of this script
relconf=`basename "$0"`
# the directory of this script is the "source tree"
relpath=`dirname "$0"`
relpath=`(cd "$relpath"; /bin/pwd)`
# the current directory is the "build tree" or "object tree"
outpath=`/bin/pwd`

#-------------------------------------------------------------------------------
# operating system detection
#-------------------------------------------------------------------------------

# need that throughout the script
UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown

#-----------------------------------------------------------------------------
# M version detection
#-----------------------------------------------------------------------------
cd "$relpath"
M_MAJOR_VERSION=`grep -m1 M_MAJOR_VERSION mkspecs/features/meegotouch_defines.prf.in |cut -f2 -d'='|sed 's/ //g'`
M_MINOR_VERSION=`grep -m1 M_MINOR_VERSION mkspecs/features/meegotouch_defines.prf.in |cut -f2 -d'='|sed 's/ //g'`
M_PATCH_VERSION=`grep -m1 M_PATCH_VERSION mkspecs/features/meegotouch_defines.prf.in |cut -f2 -d'='|sed 's/ //g'`
M_VERSION=$M_MAJOR_VERSION.$M_MINOR_VERSION.$M_PATCH_VERSION

if [ -z "$M_MAJOR_VERSION" ]; then
   echo "Cannot process version from src/meegotouch_defines.prf: $M_VERSION"
   echo "Cannot proceed."
   exit 1
fi

#-------------------------------------------------------------------------------
# initalize variables
#-------------------------------------------------------------------------------

# initalize internal variables
CFG_DEBUG=yes
CFG_RELEASE=no
CFG_OPENGL=yes
CFG_TESTABLE=no
CFG_COVERAGE=no
CFG_TIMESTAMPS=no
CFG_PCH=no
CFG_DEV=no
CFG_MINIMAL=no
CFG_BUILD_TESTS=no
CFG_BUILD_BENCHMARKS=no
CFG_BUILD_PLAINQT=yes

M_DEFAULT_BUILD_PARTS="libs demos"
CFG_BUILD_PARTS=""
CFG_NOBUILD_PARTS=""
CFG_ICU=auto
CFG_GCONF=auto

HAVE_ICU=no
HAVE_CONTEXTSUBSCRIBER=no
HAVE_GCONF=no
HAVE_GSTREAMER=no
HAVE_DBUS=no
HAVE_CONTENTACTION=no
HAVE_XDAMAGE=no
HAVE_N900=no

OPT_SHADOW=maybe

IS_ARMEL=no
   
# initalize variables used for installation
M_INSTALL_PREFIX=/usr/local
M_INSTALL_SYSCONFDIR=/etc
M_INSTALL_LIBDIR= # Will be $M_INSTALL_PREFIX/lib unless overriden

#-------------------------------------------------------------------------------
# parse command line arguments
#-------------------------------------------------------------------------------

# parse the arguments, setting things to "yes" or "no"
while [ "$#" -gt 0 ]; do
    CURRENT_OPT="$1"
    UNKNOWN_ARG=no
    case "$1" in
    #Autoconf style options
    --enable-*)
        VAR=`echo $1 | sed "s,^--enable-\(.*\),\1,"`
        VAL=yes
        ;;
    --disable-*)
        VAR=`echo $1 | sed "s,^--disable-\(.*\),\1,"`
        VAL=no
        ;;
    --*=*)
        VAR=`echo $1 | sed "s,^--\(.*\)=.*,\1,"`
        VAL=`echo $1 | sed "s,^--.*=\(.*\),\1,"`
        ;;
    --no-*)
        VAR=`echo $1 | sed "s,^--no-\(.*\),\1,"`
        VAL=no
        ;;
    --*)
        VAR=`echo $1 | sed "s,^--\(.*\),\1,"`
        VAL=yes
        ;;
    #Qt style no options
    -no-*)
        VAR=`echo $1 | sed "s,^-no-\(.*\),\1,"`
        VAL=no
        ;;
    #Qt style yes options
        -h|-help|-v|-verbose|-debug|-release|-testable|-coverage|-timestamps|-dev|-minimal|-icu|-gconf)
        VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
        VAL=yes
        ;;
    #Qt style options that pass an argument
    -prefix|-make|-nomake|-sysconfdir|-libdir)
        VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
        shift
        VAL="$1"
        ;;
    #Qt style complex options in one command
    -enable-*|-disable-*)
        VAR=`echo $1 | sed "s,^-\([^-]*\)-.*,\1,"`
        VAL=`echo $1 | sed "s,^-[^-]*-\(.*\),\1,"`
        ;;
    #Qt Builtin/System style options
    -no-*)
        VAR=`echo $1 | sed "s,^-[^-]*-\(.*\),\1,"`
        VAL=`echo $1 | sed "s,^-\([^-]*\)-.*,\1,"`
        ;;
    #Options that cannot be generalized
    -opengl)
        VAR=opengl
        # this option may or may not be followed by an argument
        if [ -z "$2" ] || echo "$2" | grep '^-' >/dev/null 2>&1; then
            VAL=yes
        else
            shift;
            VAL=$1
        fi
	;;
    -*)
        VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
        VAL="unknown"
        ;;
    *)
        UNKNOWN_ARG=yes
        ;;
    esac
    if [ "$UNKNOWN_ARG" = "yes" ]; then
        echo "$1: unknown argument"
        OPT_HELP=yes
        ERROR=yes
        shift
        continue
     fi
    shift

    UNKNOWN_OPT=no
    case "$VAR" in
    prefix)
        M_INSTALL_PREFIX="$VAL"
        ;;
    sysconfdir)
        M_INSTALL_SYSCONFDIR="$VAL"
        ;;
    libdir)
        M_INSTALL_LIBDIR="$VAL"
        ;;
    nomake)
	CFG_NOBUILD_PARTS="$CFG_NOBUILD_PARTS $VAL"
        ;;
    make)
	CFG_BUILD_PARTS="$CFG_BUILD_PARTS $VAL"
        ;;
    opengl)
        if  [ "$VAL" = "auto" ] || [ "$VAL" = "desktop" ] ||
            [ "$VAL" = "yes" ] || [ "$VAL" = "no" ] ||
            [ "$VAL" = "es1cl" ] || [ "$VAL" = "es1" ] || [ "$VAL" = "es2" ]; then
            CFG_OPENGL="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    release)
        CFG_RELEASE="$VAL"
	;;
    debug)
        CFG_DEBUG="$VAL"
        ;;
    testable)
        CFG_TESTABLE="$VAL"
        ;;
    coverage)
        CFG_COVERAGE="$VAL"
        ;;
    timestamps)
        CFG_TIMESTAMPS="$VAL"
        ;;
    pch)
        CFG_PCH="$VAL"
        ;;
    dev)
        CFG_DEV="yes"
        CFG_BUILD_TESTS="yes"
        CFG_BUILD_BENCHMARKS="yes"
        CFG_BUILD_PLAINQT="yes"
        ;;
    minimal)
        CFG_MINIMAL="yes"
        ;;
    tests)
        CFG_BUILD_TESTS="yes"
        ;;
    benchmarks)
        CFG_BUILD_BENCHMARKS="yes"
        ;;
    plainqt)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_BUILD_PLAINQT="$VAL"
        fi
        ;;
    n900)
        HAVE_N900="yes"
        ;;
    icu)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_ICU="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    gconf)
        if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then
            CFG_GCONF="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    h|help)
        if [ "$VAL" = "yes" ]; then
            OPT_HELP="$VAL"
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    v|verbose)
        if [ "$VAL" = "yes" ]; then
            if [ "$OPT_VERBOSE" = "$VAL" ]; then            # takes two verboses to turn on qmake debugs
                QMAKE_SWITCHES="$QMAKE_SWITCHES -d"
            else
                OPT_VERBOSE=yes
            fi
        elif [ "$VAL" = "no" ]; then
            if [ "$OPT_VERBOSE" = "$VAL" ] && echo "$QMAKE_SWITCHES" | grep ' -d' >/dev/null 2>&1; then
                QMAKE_SWITCHES=`echo $QMAKE_SWITCHES | sed "s, -d,,"`
            else
                OPT_VERBOSE=no
            fi
        else
            UNKNOWN_OPT=yes
        fi
        ;;
    silent)
        CFG_SILENT="$VAL"
        ;;
    esac
    if [ "$UNKNOWN_OPT" = "yes" ]; then
        echo "${CURRENT_OPT}: invalid command-line switch"
        OPT_HELP=yes
        ERROR=yes
    fi
done

if [ "$CFG_SILENT" = "yes" ]; then
    QMAKE_CONFIG="$QMAKE_CONFIG silent"
fi

#-------------------------------------------------------------------------------
# tests
#-------------------------------------------------------------------------------

# Make default LIBDIR relative to prefix unless overriden
if [ -z "$M_INSTALL_LIBDIR" ]; then
    M_INSTALL_LIBDIR=$M_INSTALL_PREFIX/lib
fi

#setup the build parts
CFG_BUILD_PARTS="$CFG_BUILD_PARTS $M_DEFAULT_BUILD_PARTS"

for nobuild in $CFG_NOBUILD_PARTS; do
    CFG_BUILD_PARTS=`echo "$CFG_BUILD_PARTS" | sed "s, $nobuild,,g"`
done

if echo $CFG_BUILD_PARTS | grep -v libs >/dev/null 2>&1; then
    echo
    echo "WARNING: libs is a required part of the build."
    echo
    CFG_BUILD_PARTS="$CFG_BUILD_PARTS libs"
fi

if [ "$CFG_BUILD_TESTS" = "yes" ]; then
    CFG_BUILD_PARTS="$CFG_BUILD_PARTS tests"
else
  if echo $CFG_BUILD_PARTS | grep tests >/dev/null 2>&1; then
    CFG_BUILD_TESTS="yes"
  fi
fi

if [ "$CFG_BUILD_BENCHMARKS" = "yes" ]; then
    CFG_BUILD_PARTS="$CFG_BUILD_PARTS benchmarks"
else
  if echo $CFG_BUILD_PARTS | grep benchmarks >/dev/null 2>&1; then
    CFG_BUILD_BENCHMARKS="yes"
  fi
fi

if [ "$CFG_BUILD_PLAINQT" = "yes" ]; then
    CFG_BUILD_PARTS="$CFG_BUILD_PARTS plainqt"
else
  if echo $CFG_BUILD_PARTS | grep plainqt >/dev/null 2>&1; then
    CFG_BUILD_PLAINQT="yes"
  fi
fi

# is this a shadow build?
if [ "$OPT_SHADOW" = "maybe" ]; then
    OPT_SHADOW=no
    if [ "$relpath" != "$outpath" ] && [ '!' -f "$outpath/configure" ]; then
        if [ -h "$outpath" ]; then
            [ "$relpath" -ef "$outpath" ] || OPT_SHADOW=yes
        else
            OPT_SHADOW=yes
        fi
    fi
fi

# Test for ICU
if [ "$CFG_ICU" != "no" ]; then
    which icu-config > /dev/null
    if [ $? -eq 0 ]; then
        icu-config --exists
        if [ $? -eq 0 ]; then
            HAVE_ICU=yes
        fi
    fi
    if [ "$CFG_ICU" = "yes" -a "$HAVE_ICU" = "no" ]; then
        echo "You specified  -icu  but icu was not found."
        echo "Please install the libicu-dev package."
        exit 1
    fi
fi

# Test for pkg-config enabled dependencies
which pkg-config > /dev/null
if [ $? -eq 0 ]; then

    pkg-config --exists contextsubscriber-1.0
    if [ $? -eq 0 ]; then
        HAVE_CONTEXTSUBSCRIBER=yes
    fi

    if [ "$CFG_GCONF" != "no" ]; then
        pkg-config --exists gconf-2.0
        if [ $? -eq 0 ]; then
            HAVE_GCONF=yes
        else
            if [ "$CFG_GCONF" = "yes" ]; then
                echo "You specified  -gconf  but gconf was not found."
                echo "Please install the libgconf2-dev package."
                exit 1
            fi
        fi
    fi

    pkg-config --exists gstreamer-0.10
    if [ $? -eq 0 ]; then
	HAVE_GSTREAMER=yes
    fi

    pkg-config --exists QtDBus
    if [ $? -eq 0 ]; then
	HAVE_DBUS=yes
    fi    

    pkg-config --exists contentaction-0.1
    if [ $? -eq 0 ]; then
	#HAVE_CONTENTACTION=yes DISABLED FOR NOW
	HAVE_CONTENTACTION=no
    fi

    pkg-config --exists xdamage
    if [ $? -eq 0 ]; then
        HAVE_XDAMAGE=yes
    fi

    if [ "$SBOX_UNAME_MACHINE" = "arm" ]; then
        IS_ARMEL=yes
    fi

fi



#-------------------------------------------------------------------------------
# help - interactive parts of the script _after_ this section please
#-------------------------------------------------------------------------------

# next, emit a usage message if something failed.
if [ "$OPT_HELP" = "yes" ]; then
    [ "x$ERROR" = "xyes" ] && echo
    cat <<EOF
Usage:  $relconf [-prefix <dir>] [-release] [-debug] [-make <part>]
        [-no-make <part>]

Installation options:

    -prefix <dir> ...... This will install everything relative to <dir>
                         (default $M_INSTALL_PREFIX)
    -sysconfdir <dir> .. This will put configuration files in <dir>
                         (default $M_INSTALL_SYSCONFDIR)
    -libdir <dir> ...... This will put libraries in <dir>
                         (default $M_INSTALL_LIBDIR)

Configure options:

 The defaults (*) are usually acceptable. A plus (+) denotes a default value
 that needs to be evaluated. If the evaluation succeeds, the feature is
 included. Here is a short explanation of each option:

    -release ........... Compile and link libmeegotouch in release mode
 *  -debug ............. Compile and link libmeegotouch with debugging turned on

    -testable .......... Enable the testability plugin interface in libmeegotouch
    -timestamps ........ Enable time debug measurements in the code
    -coverage .......... Enable code coverage calculation
    -pch ............... Enable pre-compiled header

Additional options:

    -make <part> ....... Add part to the list of parts to be built at make time
                         (*libs *demos plainqt tests benchmarks)
    -nomake <part> ..... Exclude part from the list of parts to be built

    -dev ............... Compile and link with default developer options.
                         This enables the benchmarks, tests and plainqt parts.

    -tests ............. Build the tests.
    -benchmarks ........ Build the benchmarks.

    -n900 .............. Build libmeegotouch for the N900 device.

    -no-icu ............ Do not compile with ICU support.
 +  -icu ............... Compile with ICU support.

    -no-gconf .......... Do not compile with gconf support.
 +  -gconf ............. Compile with gconf support.

    -no-plainqt......... Do not build the Plain Qt style plugin.
 +  -plainqt ........... Build the Plain Qt style plugin.

EOF

exit 0

fi

#-------------------------------------------------------------------------------
# save configuration into meegotouchconfig.pri
#-------------------------------------------------------------------------------

if [ "$OPT_SHADOW" = "yes" ]; then
    if [ -f "$relpath/mkspecs/meegotouchconfig.pri" ]; then
        echo >&2 "You cannot make a shadow build from a source tree containing a previous build."
        echo >&2 "Cannot proceed."
        echo >&2 ""
        echo >&2 "Please clean your source directory by executing this command:"
        echo >&2 ""
        echo >&2 "make distclean"
        echo >&2 ""
        exit 1
    fi

    # create mkspecs/features dir in build tree
    mkdir -p "$outpath/mkspecs/features"
fi


MEEGOTOUCHCONFIG="$outpath/mkspecs/meegotouchconfig.pri"
[ -f "$MEEGOTOUCHCONFIG.tmp" ] && rm -f "$MEEGOTOUCHCONFIG.tmp"

if [ "$CFG_DEBUG" = "yes" ]; then
    MEEGOTOUCHCONFIG_CONFIG="$MEEGOTOUCHCONFIG_CONFIG debug"
fi

if [ "$CFG_RELEASE" = "yes" ]; then
    MEEGOTOUCHCONFIG_CONFIG="$MEEGOTOUCHCONFIG_CONFIG release"
fi


if [ "$CFG_TESTABLE" = "yes" ]; then
    MEEGOTOUCHCONFIG_FEATURES="$MEEGOTOUCHCONFIG_FEATURES testable"
fi

if [ "$CFG_TIMESTAMPS" = "yes" ]; then
    MEEGOTOUCHCONFIG_FEATURES="$MEEGOTOUCHCONFIG_FEATURES timestamps"
fi

if [ "$CFG_COVERAGE" = "yes" ]; then
    MEEGOTOUCHCONFIG_FEATURES="$MEEGOTOUCHCONFIG_FEATURES coverage"
fi

if [ "$CFG_PCH" = "yes" ]; then
    MEEGOTOUCHCONFIG_FEATURES="$MEEGOTOUCHCONFIG_FEATURES pch"
fi

if [ "$CFG_MINIMAL" = "yes" ]; then
    MEEGOTOUCHCONFIG_FEATURES="$MEEGOTOUCHCONFIG_FEATURES minimal"
fi


if [ "$HAVE_ICU" = "yes" ]; then
    MEEGOTOUCHCONFIG_DEPS="$MEEGOTOUCHCONFIG_DEPS HAVE_ICU"
fi

if [ "$HAVE_CONTENTACTION" = "yes" ]; then
    MEEGOTOUCHCONFIG_DEPS="$MEEGOTOUCHCONFIG_DEPS HAVE_CONTENTACTION"
fi

if [ "$HAVE_XDAMAGE" = "yes" ]; then
    MEEGOTOUCHCONFIG_DEPS="$MEEGOTOUCHCONFIG_DEPS HAVE_XDAMAGE"
fi

if [ "$HAVE_CONTEXTSUBSCRIBER" = "yes" ]; then
    MEEGOTOUCHCONFIG_DEPS="$MEEGOTOUCHCONFIG_DEPS HAVE_CONTEXTSUBSCRIBER"
fi

if [ "$HAVE_GCONF" = "yes" ]; then
    MEEGOTOUCHCONFIG_DEPS="$MEEGOTOUCHCONFIG_DEPS HAVE_GCONF"
fi

if [ "$HAVE_GSTREAMER" = "yes" ]; then
    MEEGOTOUCHCONFIG_DEPS="$MEEGOTOUCHCONFIG_DEPS HAVE_GSTREAMER"
fi

if [ "$HAVE_DBUS" = "yes" ]; then
    MEEGOTOUCHCONFIG_DEPS="$MEEGOTOUCHCONFIG_DEPS HAVE_DBUS"
fi

if [ "$HAVE_N900" = "yes" ]; then
    MEEGOTOUCHCONFIG_DEPS="$MEEGOTOUCHCONFIG_DEPS HAVE_N900"
fi

if [ "$IS_ARMEL" = "yes" ]; then
    MEEGOTOUCHCONFIG_DEPS="$MEEGOTOUCHCONFIG_DEPS IS_ARMEL"
fi                               


cat >>"$MEEGOTOUCHCONFIG.tmp" <<EOF
# Autogenerated by configure script

#build configuration
CONFIG += $MEEGOTOUCHCONFIG_CONFIG

M_BUILD_PARTS += $CFG_BUILD_PARTS

M_BUILD_FEATURES += $MEEGOTOUCHCONFIG_FEATURES

#versioning
M_VERSION = $M_VERSION

#paths
M_INSTALL_PREFIX = $M_INSTALL_PREFIX
M_INSTALL_SYSCONFDIR = $M_INSTALL_SYSCONFDIR
M_INSTALL_LIBDIR = $M_INSTALL_LIBDIR

#dependencies
DEFINES += BUILD_M $MEEGOTOUCHCONFIG_DEPS

EOF

# replace meegotouchconfig.pri if it differs from the newly created temp file
if cmp -s "$MEEGOTOUCHCONFIG.tmp" "$MEEGOTOUCHCONFIG"; then
    rm -f "$MEEGOTOUCHCONFIG.tmp"
else
    mv -f "$MEEGOTOUCHCONFIG.tmp" "$MEEGOTOUCHCONFIG"
fi

# now try to create a .qmake.cache file to be able to find the build root
M_QMAKE_CACHE="$outpath/.qmake.cache"
[ -f "$M_QMAKE_CACHE.tmp" ] && rm -f "$M_QMAKE_CACHE.tmp"

cat >>"$M_QMAKE_CACHE.tmp" <<EOF
# Autogenerated by configure script
M_BUILD_TREE = \$\$quote($outpath)
M_SOURCE_TREE = \$\$quote($relpath)

EOF

# replace .qmake.cache if it differs from the newly created temp file
if cmp -s "$M_QMAKE_CACHE.tmp" "$M_QMAKE_CACHE"; then
    rm -f "$M_QMAKE_CACHE.tmp"
else
    mv -f "$M_QMAKE_CACHE.tmp" "$M_QMAKE_CACHE"
fi

MEEGOTOUCH_DEFINES_PRF="$outpath/mkspecs/features/meegotouch_defines.prf"

# and now we generate a meegotouch_defines.prf that will contain the right
# install prefix
cat "$relpath/mkspecs/features/meegotouch_defines.prf.in" \
| sed -e "s,@@M_UNIX_INSTALL_PREFIX@@,$M_INSTALL_PREFIX,g" \
| sed -e "s,@@M_UNIX_INSTALL_SYSCONFDIR@@,$M_INSTALL_SYSCONFDIR,g" \
| sed -e "s,@@M_UNIX_INSTALL_LIBDIR@@,$M_INSTALL_LIBDIR,g" \
> "$MEEGOTOUCH_DEFINES_PRF.tmp"

# replace meegotouch_defines.prf if it differs from the newly created temp file
if cmp -s "$MEEGOTOUCH_DEFINES_PRF.tmp" "$MEEGOTOUCH_DEFINES_PRF"; then
    rm -f "$MEEGOTOUCH_DEFINES_PRF.tmp"
else
    mv -f "$MEEGOTOUCH_DEFINES_PRF.tmp" "$MEEGOTOUCH_DEFINES_PRF"
fi

# substitute prefix in .pc files
MEEGOTOUCH_PC_DIR="$outpath/src/data"
MEEGOTOUCH_PC_FILES="meegotouch
meegotouchcore
meegotouchsettings
"

# make sure the directory exists
if [ ! -d $MEEGOTOUCH_PC_DIR ]; then
    mkdir -p $MEEGOTOUCH_PC_DIR
fi

for i in $MEEGOTOUCH_PC_FILES
do
   pc_file="$MEEGOTOUCH_PC_DIR/$i.pc"
   pc_in="$relpath/src/data/$i.pc.in"

   cat "$pc_in" \
   | sed -e "s,@@M_UNIX_INSTALL_PREFIX@@,$M_INSTALL_PREFIX,g" \
   > "$pc_file.tmp"

  # replace meegotouch_defines.prf if it differs from the newly created temp file
  if cmp -s "$pc_file.tmp" "$pc_file"; then
      rm -f "$pc_file.tmp"
  else
      mv -f "$pc_file.tmp" "$pc_file"
  fi

done

#-------------------------------------------------------------------------------
# build makefiles based on the configuration
#-------------------------------------------------------------------------------

#echo "Finding project files. Please wait..."
#"qmake" -r "${relpath}/projects.pro"
#if [ -f "${relpath}/projects.pro" ]; then
#    mkfile="${outpath}/Makefile"
#    [ -f "$mkfile" ] && chmod +w "$mkfile"
#fi

if [ -z "$QTDIR" ]; then
    which qmake > /dev/null
    if [ $? -eq 0 ]; then
        QMAKE_BIN=`which qmake`
    else
        echo "qmake was not found in your path\n"
    fi
elif [ -f "$QTDIR/bin/qmake" ]; then
    QMAKE_BIN="$QTDIR/bin/qmake"
else
    echo "QTDIR variable was set but could not find $QTDIR/bin/qmake\n"
fi

if [ -z "$QMAKE_BIN" ]; then
    echo "If your Qt is in a nonstandard location, try:"
    echo "QTDIR=<path to your Qt directory> ./$relconf"
    exit 1
fi

# now check for qt version
QT_MAJOR_VERSION_NEEDED=4
QT_MINOR_VERSION_NEEDED=7

QT_VERSION=`$QMAKE_BIN -version | tail -1`

QT_MAJOR_VERSION=0
QT_MINOR_VERSION=0
QT_PATCH_VERSION=0
if [ -n "$QT_VERSION" ]; then
   QT_VERSION=`echo $QT_VERSION | sed 's,^ *Using *Qt *version *\([^ ]*\) *in .*$,\1,'`
   MAJOR=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\1,'`
   if [ -n "$MAJOR" ]; then
     MINOR=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\2,'`
      PATCH=`echo $QT_VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\3,'`
      QT_MAJOR_VERSION="$MAJOR"
      [ -z "$MINOR" ] || QT_MINOR_VERSION="$MINOR"
      [ -z "$PATCH" ] || QT_PATCH_VERSION="$PATCH"
   fi
fi

if [ -z "$QT_MAJOR_VERSION" ]; then
   echo "Cannot process version from qglobal.h: $QT_VERSION"
   echo "Cannot proceed."
   exit 1
fi

if [ "$QT_MAJOR_VERSION" -lt "$QT_MAJOR_VERSION_NEEDED" ] \
    || [ "$QT_MINOR_VERSION" -lt "$QT_MINOR_VERSION_NEEDED" ]; then
    echo "Your Qt version is too old: $QT_VERSION"
    echo "You need at least version $QT_MAJOR_VERSION_NEEDED.$QT_MINOR_VERSION_NEEDED.0"
    echo "Cannot proceed."
    exit 1
fi

# set special options for mac build
if [ "$UNAME_SYSTEM" = "Darwin" ]; then
    QMAKE_SWITCHES="$QMAKE_SWITCHES -spec macx-g++"
fi


#Run qmake
cd "$outpath"
$QMAKE_BIN "$relpath/projects.pro" $QMAKE_CONFIG $QMAKE_SWITCHES

#-------------------------------------------------------------------------------
# give feedback on configuration
#-------------------------------------------------------------------------------

echo ""
echo ""
echo "Optional build dependencies found:"

echo "ICU ...................... $HAVE_ICU"
echo "Context Subscriber 1.0 ... $HAVE_CONTEXTSUBSCRIBER"
echo "Content Action 0.1 ....... $HAVE_CONTENTACTION"
echo "GConf 2.0 ................ $HAVE_GCONF"
echo "GStreamer 0.10 ........... $HAVE_GSTREAMER"
echo "DBus (incl. QtDBus) ...... $HAVE_DBUS"
echo "XDamage .................. $HAVE_XDAMAGE"


if [ "$CFG_DEV" = "yes" ]; then
    echo ""
    echo ""
    echo "Enabling MeeGo Touch UI developer's build"
    echo ""
else
    echo ""
    echo ""
fi

echo "MeeGo Touch UI framework build configuration:"
echo "Version ............. $M_VERSION"
echo "Build ............... $CFG_BUILD_PARTS"
echo "Extra features ...... $MEEGOTOUCHCONFIG_FEATURES"
echo "Release ............. $CFG_RELEASE"
echo "Debug ............... $CFG_DEBUG"

echo
echo "Benchmarks .......... $CFG_BUILD_BENCHMARKS"
echo "Plain Qt support .... $CFG_BUILD_PLAINQT"
echo "Tests ............... $CFG_BUILD_TESTS"

if [ "$HAVE_N900" = "yes" ]; then
    echo ""
    echo "Building for Maemo 5 on N900"
fi

echo ""
echo libmeegotouch is now configured for building. Just run \'make\'.
if [ "$relpath" = "$M_INSTALL_PREFIX" ]; then
    echo Once everything is built, libmeegotouch is installed.
    echo You should not run \'make install\'.
else
    echo Once everything is built, you can run \'make install\'.
    echo libmeegotouch will be installed into $M_INSTALL_PREFIX
fi

echo ""
echo ""