path: root/util/scripts/mac-binary/package/mkpackage

#!/bin/sh 

#options
export MACOSX_DEPLOYMENT_TARGET=10.3
OUTPUT_DIR=`pwd`/outputs
cd `dirname $0` #now we live in the mkpackage location
USE_SEPARATE=no
TMP_DIR=/tmp/qt-stuff
PACKAGE_DIR=`(cd ../install && pwd)`
PACKAGE_OPTIONS=
PACKAGES=
COMMAND_PAX="/System/Library/PrivateFrameworks/Installation.framework/Resources/pax" #yes that pax, don't ask!
README=
LICENSE_EMBEDDED=
LICENSE_EMBEDDED_US=
LICENSE_ALLOS=
LICENSE_ALLOS_US=
LICENSE=          # This is now the Desktop License (or Open Source)
LICENSE_US=  # Also abused for GPL3
LICENSETYPE=
MAKE_META=
MAKE_IMAGE=
DO_CLEANUP=yes

#versioning
QT_SET_VERSION=no
QT_MAJOR_VERSION=4
QT_MINOR_VERSION=0
QT_PATCH_VERSION=0
QT_VERSION_STRING=${QT_MAJOR_VERSION}.${QT_MINOR_VERSION}.${QT_PATCH_VERSION}

# Build Date
QT_PACKAGEDATE_STRING=`date +%F`

#QTDIR stuff
BINARY_DIR=
SOURCE_DIR=
SOURCE_PACKAGE=
EVAL_PATCHES=
CONFIGURE_ARGS="-qt-libpng -qt-libjpeg -plugin-sql-sqlite -plugin-sql-odbc -plugin-sql-psql -framework -confirm-license -no-rpath -I/usr/local/pgsql/include -L/usr/local/pgsql/lib -universal -sdk /Developer/SDKs/MacOSX10.4u.sdk -optimized-qmake"

doStringReplace()
{
    sed -e "s,\\\$VERSION_MAJOR\\\$,$QT_MAJOR_VERSION,g" -e "s,\\\$VERSION_MINOR\\\$,$QT_MINOR_VERSION,g" \
        -e "s,\\\$VERSION_PATCH\\\$,$QT_PATCH_VERSION,g" "$1" >tmp.out

    mv -f tmp.out "$2"
}

createLicenseRTF()
{
   rm -f "$2"
   cat >>"$2" <<EOF
{\rtf1\mac\ansicpg10000\cocoartf102
{\fonttbl\f0\fswiss\fcharset77 Helvetica;\f1\fswiss\fcharset77 Helvetica-Oblique;\f2\fswiss\fcharset77 Helvetica-Bold;
}
{\colortbl;\red255\green255\blue255;}
\margl1440\margr1440\vieww9000\viewh9000\viewkind0
\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\ql\qnatural
EOF
   sed -e 's,\(^[A-Z][A-Z :-]*$\),\\f2\\b \1 \\f0\\b0,g' \
       -e 's,^\(Qt COMMERCIAL\) \(LICENSE AGREEMENT\)$,\\f0\\fs24 \\cf0 \\ul \\ulc0 \1 \\ulnone \2 \\f0\\i0,g' \
       -e 's,^\([0-9]*\)\. ,\\f2\\b \1 \\f0\\b0. ,g' \
       -e 's,\(^Agreement version [0-9].[0-9]$\),\\f1\\i \1 \\f0\\i0,g' \
       -e 's,^\(.*\)$,\1\\,g' \
       "$1" >>"$2"
   echo "}" >>"$2"

}

while [ -n "$1" ]; do
   CACHE_1="$1"
   OPTION=
   ARG=
   case $1 in
   -*=*) #gnu style
     OPTION=`echo $1 | sed 's,-\([^=]*\)=\(.*\),\1,'`
     ARG=`echo $1 | sed 's,-\([^=]*\)=\(.*\),\2,'`
     ;;
   -output|-packages|-qtbins|-qtsrcs|-qtdir|-qtpackage|-version|-license|-licensetype|-license_us|-license_allos_us|-license_allos|license_embedded_us|license_embedded|-readme|-evalpatches) #second arg style
     OPTION=`echo $1 | sed 's,-\([^=]*\),\1,'`
     shift
     ARG=$1
     ;;          
   -no-*) #no style
     OPTION=`echo $1 | sed 's,-no-\([^=]*\),\1,'`
     ARG=no
     ;;
   -*) #yes style
     OPTION=`echo $1 | sed 's,-\([^=]*\),\1,'`
     ARG=yes
     ;;
   *) #other
     OPTION=package
     ARG="$1"
     ;;
   esac
   shift
   case "$OPTION" in
   help)
        if [ "$ARG" = "yes" ]; then
           echo "$0 <options> <packages>"
           echo
           echo "  -output <directory>            Where to write the generated files to"
           echo "  -packages <directory>          Where to find packages to create"
           echo "  -qtbins <directory>            Where your Qt binaries live"
               echo "  -qtsrcs <directory>            Where to find our Qt sources (if -qtbins not set defaults to same)"
           echo "  -qtpackage <package>           Given a package it will be untar'd configured and built and used."
           echo "  -version <version>             What version the package is creating for (falls back to qglobal.h)"
           echo "  -license <license>             Where your desktop license (or opensource) file lives"
           echo "  -license_us <license>          Where your U.S. desktop (or GPLv3) license file lives"
           echo "  -license_allos <license>       Where your All-OS license file lives"
           echo "  -license_allos_us <license>       Where your U.S. All-OS license file lives"
           echo "  -license_embedded <license>       Where your Embedded license file lives"
           echo "  -license_embedded_us <license>    Where your U.S. Embedded license file lives"
           echo "  -licensetype <commercial|eval|opensource|preview-commercial|preview-opensource> The license for the package you are building"
           echo "  -readme <readme>               Where your readme file lives"
           echo "  -image                         Create a disk image of the outputs"
           echo "  -meta                          Create a meta package for all the outputs"
           echo "  -evalpatches <evalpatches>     Eval patches can be found here"
           echo "  -no-cleanup                    Don't remove files (can be used to restart a previous run)"
           exit 0
        fi
    ;;
   readme) README="$ARG" ;;
   license) LICENSE="$ARG" ;;
   licensetype) LICENSETYPE="$ARG" ;;
   all) USE_SEPARATE="$ARG" ;;
   qtpackage) SOURCE_PACKAGE="$ARG" ;;
   qtsrcs) SOURCE_DIR="$ARG" ;;
   qtbins|qtdir) BINARY_DIR="$ARG" ;;
   output) OUTPUT_DIR="$ARG" ;;
   packages) PACKAGE_DIR="$ARG" ;;
   meta) MAKE_META="$ARG" ;;
   package) PACKAGES="$PACKAGES $ARG" ;;
   image) MAKE_IMAGE="$ARG" ;;
   evalpatches) EVAL_PATCHES="$ARG" ;;
   cleanup) DO_CLEANUP="$ARG" ;;
   version) 
       VERSION="$ARG"
       MAJOR=`echo $VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\1,'`
       if [ -n "$MAJOR" ]; then
           MINOR=`echo $VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\2,'`
           [ -z "$MINOR" ] && MINOR=0
           PATCH=`echo $VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\3,'`
           [ -z "$PATCH" ] && PATCH=0
           QT_SET_VERSION=yes
           QT_VERSION_STRING="$VERSION"
           QT_MAJOR_VERSION="$MAJOR"
           QT_MINOR_VERSION="$MINOR"
           QT_PATCH_VERSION="$PATCH"
       else
           echo "Invalid version: $VERSION"
       fi
       ;;
   help|*)
       [ "$OPTION" = "help" ] || echo "Unknown option $CACHE_1!" 
       echo "Help!!"
       exit 888;
       ;;
   esac  
done

# No license type specified, so try to get it from the package. If we don't have a package,
# default to commercial
if [ -z "$LICENSETYPE" ]; then
   if [ ! -z "$SOURCE_PACKAGE" ]; then
        LICENSETYPE=`basename "$SOURCE_PACKAGE" | cut -d - -f 3`
   else
        LICENSETYPE="commercial"
   fi
fi

# If it's a preview license strip the preview out because there are some things
# that are exactly the same to what we do in the non-preview case, since the
# "preview" variant can be a "child" of the main license, we'll call it the
# parent license.
PARENTLICENSE=$LICENSETYPE
if [ "$LICENSETYPE" = "preview-commercial" ]; then
    PARENTLICENSE="commercial"
elif [ "$LICENSETYPE" = "preview-opensource" ]; then
    PARENTLICENSE="opensource"
fi

#get the QTDIR setup
[ -z "$BINARY_DIR" ] && [ -z "$SOURCE_PACKAGE" ] && BINARY_DIR="$QTDIR"
if [ ! -z "$BINARY_DIR" ] && [ -z "$SOURCE_PACKAGE" ]; then
    if [ -z "$SOURCE_DIR" ]; then
        if [ -e "$BINARY_DIR/.qmake.cache" ]; then
            SOURCE_DIR=`perl -n -e 'next unless /^QT_SOURCE_TREE *= *(.*)/;
                                    s/\$\$quote\((.*)\)/\1/;
                                    print "$1\n"; exit' "$BINARY_DIR/.qmake.cache"`
        else
            SOURCE_DIR="$BINARY_DIR"
        fi
    fi
elif [ ! -z "$SOURCE_PACKAGE" ]; then
    if [ "$DO_CLEANUP" = "yes" ]; then
        rm -rf "$TMP_DIR/source"
        mkdir -p "$TMP_DIR/source"
    fi
    PACKAGE_NAME=`basename "$SOURCE_PACKAGE"`
    CHECKLICENSETYPE=$PARENTLICENSE
    if [ "$LICENSETYPE" = "eval" ]; then
        CHECKLICENSETYPE="commercial"
    fi

    if [ -z `echo $PACKAGE_NAME | grep $CHECKLICENSETYPE` ]; then
        echo "I must have the $CHECKLICENSETYPE package, you gave me $SOURCE_PACKAGE"
        rm -rf "$TMP_DIR"
        exit 7
    fi
    EXTENSION=`echo "$PACKAGE_NAME" | sed -e 's,.*\.tar\.\(.*\),\1,'`
    PACKAGE_DEST=`echo "$PACKAGE_NAME" | sed -e 's,\(.*\)\.tar.*,\1,'`
    if [ "$LICENSETYPE" = "eval" ]; then
        CONFIGURE_ARGS="$CONFIGURE_ARGS -DQT_EVAL -release"
        # If you didn't set the eval patches, I'll try in the same place as the package
        if [ -z "$EVAL_PATCHES" ]; then
            PACKAGE_VERSION=`echo $PACKAGE_DEST | sed -e 's,.*src-\(.*\),\1,'`
            EVAL_PATCHES=`dirname "$SOURCE_PACKAGE"`/qt-mac-evalpatches-src-$PACKAGE_VERSION.tar.$EXTENSION
        fi
        # unzip the eval patches first since it _shouldn't_ matter.
        (cd "$TMP_DIR/source" && gunzip -c "$EVAL_PATCHES"  | tar xf -);
    fi

    export QTDIR=$TMP_DIR/source/$PACKAGE_DEST
    export DYLD_LIBRARY_PATH=$QTDIR/lib:$DYLD_LIBRARY_PATH
    export DYLD_FRAMEWORK_PATH=$QTDIR/lib:$DYLD_FRAMEWORK_PATH
    export PATH=$QTDIR/bin:$PATH
    if [ "$DO_CLEANUP" = "yes" ]; then
        if (cd "$TMP_DIR/source" && gunzip -c "$SOURCE_PACKAGE" | tar xf -); then
            realUsageReporter="$QTDIR/bin/qtusagereporter"
            tmpUsageReporter="$TMP_DIR/qtusagereporter"
            if [ -e "$realUsageReporter" ]; then
                cp "$realUsageReporter" "$tmpUsageReporter"
            fi
            if (cd "$QTDIR" && ./configure $CONFIGURE_ARGS); then
                if [ -e "$tmpUsageReporter" ]; then
                    mv "$tmpUsageReporter" "$realUsageReporter"
                fi
            else
                echo "Configure error"
                exit 1
            fi
            if !(cd "$QTDIR" && make); then
                echo "Build error"
                exit 2
            fi
        fi
    fi
    SOURCE_DIR="$QTDIR"
    BINARY_DIR="$SOURCE_DIR"
else
   echo "Only a source package or a source/binary directory can be specified!"
   exit 3   
fi


#License Stuff.

if [ "$LICENSETYPE" = "eval" ]; then
    if [ -z "$LICENSE" ]; then
	DEPOT_LICENSE="$SOURCE_DIR/dist/eval/LICENSE-EVALUATION"
	PACKAGE_LICENSE="$SOURCE_DIR/.LICENSE-EVALUATION"
        if [ -e "$DEPOT_LICENSE" ]; then
            LICENSE=$DEPOT_LICENSE
        elif [ -e "$PACKAGE_LICENSE" ]; then
            LICENSE="$PACKAGE_LICENSE"
	fi
    fi

    if [ -z "$LICENSE_US" ]; then
	DEPOT_LICENSE_US="$SOURCE_DIR/dist/eval/LICENSE-EVALUATION-US"
	PACKAGE_LICENSE_US="$SOURCE_DIR/.LICENSE-EVALUATION-US"
        if [ -e "$DEPOT_LICENSE_US" ]; then
            LICENSE_US=$DEPOT_LICENSE_US
        elif [ -e "$PACKAGE_LICENSE_US" ]; then
            LICENSE_US="$PACKAGE_LICENSE_US"
	fi
    fi
elif [ "$LICENSETYPE" = "opensource" ]; then
    DEPOT_LICENSE="$SOURCE_DIR/dist/opensource/LICENSE.GPL2"
    PACKAGE_LICENSE="$SOURCE_DIR/LICENSE.GPL2"
    if [ -e "$DEPOT_LICENSE" ]; then
        LICENSE=$DEPOT_LICENSE
    elif [ -e "$PACKAGE_LICENSE" ]; then
        LICENSE="$PACKAGE_LICENSE"
    fi

    if [ -z "$LICENSE_US" ]; then
        DEPOT_LICENSE_US="$SOURCE_DIR/dist/opensource/LICENSE.GPL3" 
        PACKAGE_LICENSE_US="$SOURCE_DIR/LICENSE.GPL3" 
        if [ -e "$DEPOT_LICENSE_US" ]; then
            LICENSE_US=$DEPOT_LICENSE_US
        elif [ -e "$PACKAGE_LICENSE_US" ]; then
            LICENSE_US="$PACKAGE_LICENSE_US"
        elif [ -e "../../../../dist/opensource/LICENSE.GPL3" ]; then
            LICENSE_US="../../../../dist/opensource/LICENSE.GPL3"
        fi
    fi
elif [ "$LICENSETYPE" = "commercial" ]; then
#Find the All-OS and Embedded License for commercial
    LICENSE="$SOURCE_DIR/.LICENSE"
    if [ -e "$LICENSE" ]; then
	# Generic license
	LICENSE_US="${LICENSE}-US"
	LICENSE_ALLOS=
	LICENSE_ALLOS_US=
	LICENSE_EMBEDDED=
	LICENSE_EMBEDDED_US=
    else
	DEPOT_LICENSE="$SOURCE_DIR/dist/commercial/LICENSE-DESKTOP" 
	PACKAGE_LICENSE="$SOURCE_DIR/.LICENSE-DESKTOP" 
	if [ -e "$DEPOT_LICENSE" ]; then
            LICENSE=$DEPOT_LICENSE
	elif [ -e "$PACKAGE_LICENSE" ]; then
            LICENSE="$PACKAGE_LICENSE"
	fi

	if [ -z "$LICENSE_US" ]; then
            DEPOT_LICENSE_US="$SOURCE_DIR/dist/commercial/LICENSE-DESKTOP-US" 
            PACKAGE_LICENSE_US="$SOURCE_DIR/.LICENSE-DESKTOP-US"
            if [ -e "$DEPOT_LICENSE_US" ]; then
		LICENSE_US=$DEPOT_LICENSE_US
            elif [ -e "$PACKAGE_LICENSE_US" ]; then
		LICENSE_US="$PACKAGE_LICENSE_US"
            elif [ -e "../../../../dist/commercial/LICENSE-US" ]; then
		LICENSE_US="../../../../dist/commercial/LICENSE-US"
            fi
	fi
	if [ -z "$LICENSE_ALLOS" ]; then
            DEPOT_LICENSE_ALLOS="$SOURCE_DIR/dist/commercial/LICENSE-ALLOS" 
            PACKAGE_LICENSE_ALLOS="$SOURCE_DIR/.LICENSE-ALLOS" 
            if [ -e "$DEPOT_LICENSE_ALLOS" ]; then
		LICENSE_ALLOS=$DEPOT_LICENSE_ALLOS
            elif [ -e "$PACKAGE_LICENSE_ALLOS" ]; then
		LICENSE_ALLOS="$PACKAGE_LICENSE_ALLOS"
            fi
	fi
	if [ -z "$LICENSE_ALLOS_US" ]; then
            DEPOT_LICENSE_ALLOS_US="$SOURCE_DIR/dist/commercial/LICENSE-ALLOS-US" 
            PACKAGE_LICENSE_ALLOS_US="$SOURCE_DIR/.LICENSE-ALLOS-US" 
            if [ -e "$DEPOT_LICENSE_ALLOS_US" ]; then
		LICENSE_ALLOS_US=$DEPOT_LICENSE_ALLOS_US
            elif [ -e "$PACKAGE_LICENSE_ALLOS_US" ]; then
		LICENSE_ALLOS_US="$PACKAGE_LICENSE_ALLOS_US"
            fi
	fi
	if [ -z "$LICENSE_EMBEDDED" ]; then
            DEPOT_LICENSE_EMBEDDED="$SOURCE_DIR/dist/commercial/LICENSE-EMBEDDED" 
            PACKAGE_LICENSE_EMBEDDED="$SOURCE_DIR/.LICENSE-EMBEDDED" 
            if [ -e "$DEPOT_LICENSE_EMBEDDED" ]; then
		LICENSE_EMBEDDED=$DEPOT_LICENSE_EMBEDDED
            elif [ -e "$PACKAGE_LICENSE_EMBEDDED" ]; then
		LICENSE_EMBEDDED="$PACKAGE_LICENSE_EMBEDDED"
            fi
	fi
	if [ -z "$LICENSE_EMBEDDED_US" ]; then
            DEPOT_LICENSE_EMBEDDED_US="$SOURCE_DIR/dist/commercial/LICENSE-EMBEDDED-US" 
            PACKAGE_LICENSE_EMBEDDED_US="$SOURCE_DIR/.LICENSE-EMBEDDED-US" 
            if [ -e "$DEPOT_LICENSE_EMBEDDED_US" ]; then
		LICENSE_EMBEDDED_US=$DEPOT_LICENSE_EMBEDDED_US
            elif [ -e "$PACKAGE_LICENSE_EMBEDDED_US" ]; then
		LICENSE_EMBEDDED_US="$PACKAGE_LICENSE_EMBEDDED_US"
            fi
	fi
    fi
fi

#find the README
if [ -z "$README" ]; then
    DEPOT_README="$SOURCE_DIR/dist/README"
    PACKAGE_README="$SOURCE_DIR/README"
    if [ -e "$DEPOT_README" ]; then
        README="$DEPOT_README"
    elif [ -e "$PACKAGE_README" ]; then 
        README="$PACKAGE_README"
    elif [ -e "../../../../dist/README" ]; then
        README="../../../../dist/README"
    fi
fi

#find the version from the source package
if [ "$QT_SET_VERSION" = "no" ] && [ ! -z "$SOURCE_DIR" ]; then
     VERSION=`grep '^# *define *QT_VERSION_STR' $SOURCE_DIR/src/corelib/global/qglobal.h`
     if [ -n "$VERSION" ]; then
        VERSION=`echo $VERSION | sed 's,^# *define *QT_VERSION_STR "*\([^ ]*\)"$,\1,'`
        MAJOR=`echo $VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\1,'`
        if [ -n "$MAJOR" ]; then
            MINOR=`echo $VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\2,'`
            [ -z "$MINOR" ] && MINOR=0
            PATCH=`echo $VERSION | sed 's,^\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*,\3,'`
            [ -z "$PATCH" ] && PATCH=0
            QT_VERSION_STRING="$VERSION"
            QT_MAJOR_VERSION="$MAJOR"
            QT_MINOR_VERSION="$MINOR"
            QT_PATCH_VERSION="$PATCH"
        else
            echo "Cannot process version from qglobal.h: $VERSION"
        fi
    fi
fi

if [ "$LICENSETYPE" != "opensource" ]; then
    if [ ! -z "$SOURCE_DIR" ]; then
        PACKAGEDATE=`grep '^# *define *QT_PACKAGEDATE_STR' $SOURCE_DIR/src/corelib/global/qglobal.h`
        if [ -n "$PACKAGEDATE" ]; then
            PACKAGEDATE=`echo $PACKAGEDATE | sed 's,^# *define *QT_PACKAGEDATE_STR "*\([^ ]*\)"$,\1,'`
            QT_PACKAGEDATE_STRING=$PACKAGEDATE
        else
            echo "Cannot process date information from qglobal.h: $PACKAGEDATE"
        fi
    fi
fi

# Put the date in a little file so we can access in later
PACKAGEDATE_FILE="Resources/.package_date"
if [ -e "$PACKAGEDATE_FILE" ]; then
    rm -rf "$PACKAGEDATE_FILE"
fi

echo $QT_PACKAGEDATE_STRING > $PACKAGEDATE_FILE

#just do all the packages
if [ -z "$PACKAGES" ]; then
    [ -z "$MAKE_META" ] && MAKE_META=yes
    [ -z "$MAKE_IMAGE" ] && MAKE_IMAGE=yes
    for a in $PACKAGE_DIR/*; do
        if [ -d "$a" ]; then
            package=`basename $a`
            [ "$USE_SEPARATE" = "no" ] && [ -e "$a/.build_separate" ] && continue
            PACKAGES="$PACKAGES $package"
        fi
    done
fi

#setup some default package options
[ -z "$SOURCE_PACKAGE" ] || PACKAGE_OPTIONS="$PACKAGE_OPTIONS --qtpackage=${SOURCE_PACKAGE}"
[ -z "$SOURCE_DIR" ] || PACKAGE_OPTIONS="$PACKAGE_OPTIONS --qtsrc=${SOURCE_DIR}"
[ -z "$BINARY_DIR" ] || PACKAGE_OPTIONS="$PACKAGE_OPTIONS --qtbin=${BINARY_DIR}"
PACKAGE_OPTIONS="$PACKAGE_OPTIONS --debug=yes"

mkdir -p "$TMP_DIR"
find .. -name '*~' -exec rm {} \; #just get rid of these before they end up in my package

#create the license information
if [ -e "$LICENSE" ]; then
   mkdir -p "$TMP_DIR/licenses"

   echo "Creating desktop license richtext for rest of the world"
   createLicenseRTF "$LICENSE" "$TMP_DIR/licenses/License.rtf"
else
   echo "No license file found!"
   exit 4
fi

if [ -e "$LICENSE_US" ]; then
   echo "Creating desktop license richtext for U.S. (GPL3 for opensource)"
   createLicenseRTF "$LICENSE_US" "$TMP_DIR/licenses/License-US.rtf"
else
   echo "No U.S. (GPL3 for opensource) license file found!"
   exit 5
fi

if [ "$LICENSETYPE" = "commercial" ] && [ -n "$LICENSE_ALLOS" ]; then
    if [ -e "$LICENSE_ALLOS" ]; then
	mkdir -p "$TMP_DIR/licenses"

	echo "Creating all OS license richtext for rest of the world"
	createLicenseRTF "$LICENSE_ALLOS" "$TMP_DIR/licenses/License-AllOS.rtf"
    else
	echo "No all OS license file found!"
	exit 6
    fi

    if [ -e "$LICENSE_ALLOS_US" ]; then
	echo "Creating desktop license richtext for U.S. (GPL3 for opensource)"
	createLicenseRTF "$LICENSE_ALLOS_US" "$TMP_DIR/licenses/License-AllOS-US.rtf"
    else
	echo "No U.S. all OS license file found!"
	exit 7
    fi

    if [ -e "$LICENSE_EMBEDDED" ]; then
	mkdir -p "$TMP_DIR/licenses"

	echo "Creating embedded license richtext for rest of the world"
	createLicenseRTF "$LICENSE_EMBEDDED" "$TMP_DIR/licenses/License-Embedded.rtf"
    else
	echo "No embedded license file found!"
	exit 8
    fi

    if [ -e "$LICENSE_EMBEDDED_US" ]; then
	echo "Creating embedded license richtext for U.S. (GPL3 for opensource)"
	createLicenseRTF "$LICENSE_EMBEDDED_US" "$TMP_DIR/licenses/License-Embedded-US.rtf"
    else
	echo "No U.S. embedded license file found!"
	exit 9
    fi
fi

# Build our license checking plugin!
if [ "$PARENTLICENSE" = "commercial" ] || [ "$PARENTLICENSE" = "eval" ]; then
    # build the InstallerPane plugin
    INSTALLERPANE_PATH=InstallerPane
    INSTALLERPANE_CONFIGURATION="Release-$PARENTLICENSE"
    INSTALLERPANE_BUILDPARAMS="-project ""$INSTALLERPANE_PATH/InstallerPane.xcodeproj"" -configuration ""$INSTALLERPANE_CONFIGURATION"

    echo "/usr/bin/xcodebuild $INSTALLERPANE_BUILDPARAMS"
    if !(/usr/bin/xcodebuild $INSTALLERPANE_BUILDPARAMS || grep '** BUILD SUCCEEDED **'); then
        echo "Could not build installer pane plugin"
        exit 100;
    fi

    # Create the key decoder for the script version
    BUILD_LINE="keydecoder/main.cpp $INSTALLERPANE_PATH/keydec.cpp -o Resources/keydecoder -arch i386 -arch ppc -isysroot /Developer/SDKs/MacOSX10.4u.sdk"
    /usr/bin/g++-4.0 $BUILD_LINE
fi

#create the packages
PKG_CREATED=
for package in $PACKAGES; do
    if [ "$LICENSETYPE" = "eval" ] && [ "$package" = "debuglibraries" ]; then
        continue
    fi

    [ "$package" = "none" ] && continue
    if [ !  -e "$PACKAGE_DIR/$package/Info.plist" ]; then
        echo "$package is not a valid package!!"
        continue
    fi
    rm -rf "$TMP_DIR/package" #cleanup

    #create files
    echo "Creating package [$package]..."
    mkdir -p "$TMP_DIR/package"
    if [ -x "$PACKAGE_DIR/$package/create_package.sh" ]; then
        if (cd $PACKAGE_DIR/$package/ && VERSION_MAJOR="$QT_MAJOR_VERSION" VERSION_MINOR="$QT_MINOR_VERSION" VERSION_STRING="$QT_VERSION_STRING" VERSION_PATCH="$QT_PATCH_VERSION" "$PACKAGE_DIR/$package/create_package.sh" $PACKAGE_OPTIONS --outdir="$TMP_DIR/package"); then
              true
              # Copy the uninstall script in for all of the packages
              mkdir -p "$TMP_DIR/package/Developer/Tools"
              cp "uninstall-qt.py" "$TMP_DIR/package/Developer/Tools"
         else
              echo "  Package failed"
              continue
         fi
    fi

    #create .pkg
    package_dir="$OUTPUT_DIR/packages/Qt_${package}.pkg"
    rm -rf "$package_dir"
    mkdir -p "$package_dir"
    echo "  Creating installation.. ($package_dir)"
    doStringReplace "$PACKAGE_DIR/$package/Info.plist" "$TMP_DIR/Info.plist"
    if !(/Developer/Applications/Utilities/PackageMaker.app/Contents/MacOS/PackageMaker --root "$TMP_DIR/package" --out "$package_dir" --info "$TMP_DIR/Info.plist" --filter '\.DS_Store' -v); then
        echo "  Error creating package ($package_dir)"
        continue
    fi

    sed '/IFPkgPathMappings/,${/[[:space:]]/d;}' $package_dir/Contents/Info.plist > cleaned
    mv cleaned $package_dir/Contents/Info.plist
        
    rm -rf "$TMP_DIR/Info.plist"
    rm -rf $package_dir/Contents/Resources/*.lproj
    #merge resources
    cp -R Resources/* "$package_dir/Contents/Resources"
    cp -R "$PACKAGEDATE_FILE" "$package_dir/Contents/Resources"
    cp -R $PACKAGE_DIR/$package/Resources/* "$package_dir/Contents/Resources"
    cp "Welcome-$PARENTLICENSE.rtf" "$package_dir/Contents/Resources/Welcome.rtf"
    cp "$README" "$package_dir/Contents/Resources/ReadMe.txt"
    if [ -n "$LICENSE_ALLOS" ] && [ "$PARENTLICENSE" = "commercial" ] || [ "$PARENTLICENSE" = "eval" ]; then
	# Release licenses
        for lang in "Desktop North and South America" "Desktop rest of the world" "All OS North and South America" "All OS rest of the World" "Embedded North and South America" "Embedded rest of the world"; do
            LOCALDIR="$package_dir/Contents/Resources/${lang}.lproj"
            if [ "$lang" = "Desktop North and South America" ]; then
                LOCALLICENSE="$TMP_DIR/licenses/License-US.rtf"
            elif [ "$lang" = "All OS North and South America" ]; then
                LOCALLICENSE="$TMP_DIR/licenses/License-AllOS.rtf"
            elif [ "$lang" = "Embedded North and South America" ]; then
                LOCALLICENSE="$TMP_DIR/licenses/License-Embedded.rtf"
            elif [ "$lang" = "All OS rest of the world" ]; then
                LOCALLICENSE="$TMP_DIR/licenses/License-AllOS.rtf"
            elif [ "$lang" = "Embedded rest of the world" ]; then
                LOCALLICENSE="$TMP_DIR/licenses/License-Embedded.rtf"
            else
                LOCALLICENSE="$TMP_DIR/licenses/License.rtf"
            fi

	    if [ -e "$LOCALLICENSE" ]; then
		mkdir -p "$LOCALDIR"
		cp "$LOCALLICENSE" "$LOCALDIR/License.rtf"
	    fi
        done
    elif [ "$PARENTLICENSE" = "commercial" ]; then
	# Non-release license
        for lang in "North and South America" "Rest of the world"; do
            LOCALDIR="$package_dir/Contents/Resources/${lang}.lproj"
            mkdir -p "$LOCALDIR"
            if [ "$lang" = "North and South America" ]; then
                cp "$TMP_DIR/licenses/License-US.rtf" "$LOCALDIR/License.rtf"
            else
                cp "$TMP_DIR/licenses/License.rtf" "$LOCALDIR"
            fi
        done
    elif [ "$PARENTLICENSE" = "opensource" ]; then
        for lang in "GNU Lesser General Public License Version 2.1" "GNU General Public License Version 3"; do
            LOCALDIR="$package_dir/Contents/Resources/${lang}.lproj"
            mkdir -p "$LOCALDIR"
            if [ "$lang" = "GNU General Public License Version 3" ]; then
                cp "$TMP_DIR/licenses/License-US.rtf" "$LOCALDIR/License.rtf"
            else
                cp "$TMP_DIR/licenses/License.rtf" "$LOCALDIR"
            fi
        done
        rm -f "$package_dir/Contents/Resources/InstallationCheck"
        rm -f "$package_dir/Contents/Resources/InstallationCheck.strings"
        cp opensourceStuff/InstallationCheck "$package_dir/Contents/Resources"
        cp opensourceStuff/InstallationCheck.strings "$package_dir/Contents/Resources"
        if [ "$package" = "libraries" ] || [ "$package" = "tools" ] || [ "$package" = "headers" ] || [ "$package" = "debuglibraries" ]; then
            rm -f "$package_dir/Contents/Resources/postflight"
        fi

    fi
    for a in $package_dir/Contents/Resources/*.plist $package_dir/Contents/Resources/*.info $package_dir/Contents/Resources/*flight $package_dir/Contents/Resources/*.rtf; do
        [ -e "$a" ] && doStringReplace "$a" "$a"
    done
    if [ -e "$package_dir/Contents/Resources/$package.info" ]; then
         cp "$package_dir/Contents/Resources/$package.info" "$package_dir/Contents/Resources/Qt_${package}.info"
    fi
    for a in $package_dir/Contents/Resources/*flight; do
        [ -e "$a" ] && chmod a+x $a #exe
    done
    for a in $package_dir/Contents/Resources/*Check; do
        if [ -e "$a" ]; then
            chmod a+x "$a"
            if false && [ -e "${a}.strings" ]; then
                for lang in English Norwegian French German Spanish; do
                    LOCALDIR="$package_dir/Contents/Resources/${lang}.lproj"
                    mkdir -p "$LOCALDIR"
                    cp "${a}.strings" "$LOCALDIR"
                done
                #rm -f "${a}.strings"
            fi
        fi
    done
    if [ "$PARENTLICENSE" = "commercial" ] || [ "$PARENTLICENSE" = "eval" ]; then
        # Copy over the plugin
        plugin_dir="$package_dir/Contents/Plugins"
        mkdir "$plugin_dir"
        cp -r "$INSTALLERPANE_PATH/build/$INSTALLERPANE_CONFIGURATION/InstallerPane.bundle" "$plugin_dir"
        cp "$INSTALLERPANE_PATH/InstallerSections.plist" "$plugin_dir"

    fi

    if [ "$package" != "debuglibraries" ]; then
        PKG_CREATED="$PKG_CREATED $package_dir"
    fi
done
if [ -z "$PKG_CREATED" ] && [ "$PACKAGES" = " none" ]; then
   if [ "$MAKE_META" = "yes" ] || [ "$MAKE_IMAGE" = "yes" ]; then
       PKG_CREATED=$OUTPUT_DIR/packages/*.pkg
       [ -z "$MAKE_META" ] && MAKE_META=yes
   fi
fi

#create meta package
if [ "$MAKE_META" = "yes" ]; then
    echo "Creating meta package.."
    rm -rf "$OUTPUT_DIR/Qt.mpkg/"
    mkdir -p "$OUTPUT_DIR/Qt.mpkg/"
    cp -R "MetaPackage" "$OUTPUT_DIR/Qt.mpkg/Contents"

    if [ "$PARENTLICENSE" = "commercial" ] || [ "$PARENTLICENSE" = "eval" ]; then
        # Copy over the plugin
        plugin_dir="$OUTPUT_DIR/Qt.mpkg/Contents/Plugins"
        mkdir -p "$plugin_dir"
        cp -r "$INSTALLERPANE_PATH/build/$INSTALLERPANE_CONFIGURATION/InstallerPane.bundle" "$plugin_dir"
        cp "$INSTALLERPANE_PATH/InstallerSections.plist" "$plugin_dir"
    fi

    mkdir -p "$OUTPUT_DIR/Qt.mpkg/Contents/Resources"
    cp -R Resources/* "$OUTPUT_DIR/Qt.mpkg/Contents/Resources"
    cp -R "$PACKAGEDATE_FILE" "$OUTPUT_DIR/Qt.mpkg/Contents/Resources"
    cp "Welcome-${PARENTLICENSE}.rtf" "$OUTPUT_DIR/Qt.mpkg/Contents/Resources/Welcome.rtf"
    cp "$README" "$OUTPUT_DIR/Qt.mpkg/Contents/Resources/ReadMe.txt"
    if [ -n "$LICENSE_ALLOS" ] && [ "$PARENTLICENSE" = "commercial" ] || [ "$PARENTLICENSE" = "eval" ]; then
	# Release licenses
        for lang in "Desktop North and South America" "Desktop rest of the world" "All OS North and South America" "All OS rest of the World" "Embedded North and South America" "Embedded rest of the world"; do
            LOCALDIR="$OUTPUT_DIR/Qt.mpkg/Contents/Resources/${lang}.lproj"
            if [ "$lang" = "Desktop North and South America" ]; then
                LOCALLICENSE="$TMP_DIR/licenses/License-US.rtf"
            elif [ "$lang" = "All OS North and South America" ]; then
                LOCALLICENSE="$TMP_DIR/licenses/License-AllOS.rtf"
            elif [ "$lang" = "Embedded North and South America" ]; then
                LOCALLICENSE="$TMP_DIR/licenses/License-Embedded.rtf"
            elif [ "$lang" = "All OS rest of the world" ]; then
                LOCALLICENSE="$TMP_DIR/licenses/License-AllOS.rtf"
            elif [ "$lang" = "Embedded rest of the world" ]; then
                LOCALLICENSE="$TMP_DIR/licenses/License-Embedded.rtf"
            else
                LOCALLICENSE="$TMP_DIR/licenses/License.rtf"
            fi

	    if [ -e "$LOCALLICENSE" ]; then
		mkdir -p "$LOCALDIR"
		cp "$LOCALLICENSE" "$LOCALDIR/License.rtf"
	    fi
        done
    elif [ "$PARENTLICENSE" = "commercial" ]; then
	# Non-release license
        for lang in "North and South America" "Rest of the world"; do
            LOCALDIR="$OUTPUT_DIR/Qt.mpkg/Contents/Resources/${lang}.lproj"
            mkdir -p "$LOCALDIR"
            if [ "$lang" = "North and South America" ]; then
                cp "$TMP_DIR/licenses/License-US.rtf" "$LOCALDIR/License.rtf"
            else
                cp "$TMP_DIR/licenses/License.rtf" "$LOCALDIR"
            fi
        done
    elif [ "$PARENTLICENSE" = "opensource" ]; then
        for lang in "GNU General Public License Version 2" "GNU General Public License Version 3"; do
            LOCALDIR="$OUTPUT_DIR/Qt.mpkg/Contents/Resources/${lang}.lproj"
            mkdir -p "$LOCALDIR"
            if [ "$lang" = "GNU General Public License Version 3" ]; then
                cp "$TMP_DIR/licenses/License-US.rtf" "$LOCALDIR/License.rtf"
            else
                cp "$TMP_DIR/licenses/License.rtf" "$LOCALDIR"
            fi
        done
        rm -f "$OUTPUT_DIR/Qt.mpkg/Contents/Resources/InstallationCheck"
        rm -f "$OUTPUT_DIR/Qt.mpkg/Contents/Resources/InstallationCheck.strings"
        cp opensourceStuff/InstallationCheck "$OUTPUT_DIR/Qt.mpkg/Contents/Resources"
        cp opensourceStuff/InstallationCheck.strings "$OUTPUT_DIR/Qt.mpkg/Contents/Resources"
    fi
    for a in $OUTPUT_DIR/Qt.mpkg/Contents/*.plist $OUTPUT_DIR/Qt.mpkg/Contents/Resources/*.info $OUTPUT_DIR/Qt.mpkg/Contents/Resources/*.plist $OUTPUT_DIR/Qt.mpkg/Contents/Resources/*.rtf; do
        doStringReplace "$a" "$a"
    done
    for a in $OUTPUT_DIR/Qt.mpkg/Contents/Resources/*Check; do
        if [ -e "$a" ]; then
            chmod a+x "$a"
            if false && [ -e "${a}.strings" ]; then
                for lang in English Norwegian French German Spanish; do
                    LOCALDIR="$OUTPUT_DIR/Qt.mpkg/Contents/Resources/${lang}.lproj"
                    mkdir -p "$LOCALDIR"
                    cp "${a}.strings" "$LOCALDIR"
                done
                #rm -f "${a}.strings"
            fi
        fi
    done

    PACKAGE_DICT="$TMP_DIR/pkg.dict"
    >"$PACKAGE_DICT"
    for package in $PKG_CREATED; do
        package_name=`basename $package`
        package_type=selected
        if [ "$package_name" = "Qt_libraries.pkg" ] || [ "$package_name" = "Qt_tools.pkg" ]; then
            package_type=required
        fi
        cat >"${PACKAGE_DICT}.tmp" <<EOF
           <dict>
              <key>IFPkgFlagPackageLocation</key>
              <string>${package_name}</string>
              <key>IFPkgFlagPackageSelection</key>
              <string>${package_type}</string>
           </dict>
EOF
        if [ "$package_type" = "required" ]; then
            cat "${PACKAGE_DICT}.tmp" "$PACKAGE_DICT" >"$TMP_DIR/dict.combined"
            mv "$TMP_DIR/dict.combined" "$PACKAGE_DICT"
        else
            cat "${PACKAGE_DICT}.tmp" >>"$PACKAGE_DICT"
        fi
        rm -f "${PACKAGE_DICT}.tmp"
    done
    sed "/PACKAGE_DICT/r $PACKAGE_DICT" "$OUTPUT_DIR/Qt.mpkg/Contents/Info.plist" >"${TMP_DIR}/Info.plist"
    chflags nouchg "$OUTPUT_DIR/Qt.mpkg/Contents/Info.plist"
    rm -f "$OUTPUT_DIR/Qt.mpkg/Contents/Info.plist"
    cp "${TMP_DIR}/Info.plist" "$OUTPUT_DIR/Qt.mpkg/Contents/Info.plist"
    rm -f "${TMP_DIR}/Info.plist"

    PKG_CREATED="$PKG_CREATED $OUTPUT_DIR/Qt.mpkg"
fi

#create disk image
if [ "$MAKE_IMAGE" = "yes" ] && [ ! -z "$PKG_CREATED" ]; then
    echo "Creating disk image..."
    IMAGE_NAME="Qt ${QT_VERSION_STRING}"
    IMAGE="$OUTPUT_DIR/qt-mac-${PARENTLICENSE}-${QT_VERSION_STRING}.dmg"
    TMPIMAGE="$OUTPUT_DIR/qt-mac-${PARENTLICENSE}-${QT_VERSION_STRING}-RW.dmg"
    rm -f "$IMAGE" #remove old

    #copy
    echo "  Copying..."
    DISKIMAGE="$TMP_DIR/diskimage"
    mkdir -p "$DISKIMAGE/.background"
    cp "backgrounds/DiskImage-${PARENTLICENSE}.png" "$DISKIMAGE/.background/findersbackground.png"
    cp model-DS_Store-${QT_VERSION_STRING} "$DISKIMAGE/.DS_Store"
    chmod 755 "$DISKIMAGE/.DS_Store"
    cp "backgrounds/DriveIcon.icns" "$DISKIMAGE/.VolumeIcon.icns"

    for package in $PKG_CREATED; do 
        [ -z "$package" ] && continue
        OUT_PACKAGE=`echo $package | sed "s,^$OUTPUT_DIR,$DISKIMAGE/,"`
        mkdir -p "`dirname "$OUT_PACKAGE"`"
        cp -R "$package" "$OUT_PACKAGE"
    done
    [ -e "$README" ] && cp "$README" "$DISKIMAGE/ReadMe.txt"

    echo -n "  Creating Image..."
    hdiutil create -format UDRW -volname "$IMAGE_NAME" -srcfolder "$DISKIMAGE" "$TMPIMAGE" | grep -v ^created:
    mountpoint=`hdiutil attach "$TMPIMAGE" | grep '/Volumes' | cut -f 3`
    /Developer/Tools/SetFile -a C "$mountpoint"
    hdiutil detach "$mountpoint"
    hdiutil convert "$TMPIMAGE"  -format UDZO -o "$IMAGE" -imagekey zlib-level=9 | grep -v ^created:
    rm "$TMPIMAGE"
    echo " done!"
fi

# Create the disk image for the debug libraries too
if [ "$MAKE_IMAGE" = "yes" ] && [ "$PARENTLICENSE" != "eval" ]; then
    echo "Creating the debug libraries disk image..."
    IMAGE_NAME="Qt ${QT_VERSION_STRING} Debug Libraries"
    IMAGE="$OUTPUT_DIR/qt-mac-${PARENTLICENSE}-${QT_VERSION_STRING}-debug-libs.dmg"
    DISKIMAGE="$TMP_DIR/diskimage"

    #remove the old stuff
    rm -f "$IMAGE"
    rm -rf "$DISKIMAGE"
    mkdir -p "$DISKIMAGE"
    cp -R "$OUTPUT_DIR/packages/Qt_debuglibraries.pkg" "$DISKIMAGE"
    hdiutil create -srcfolder "$DISKIMAGE" -o "$IMAGE" -volname "$IMAGE_NAME" -imagekey zlib-level=9
    echo " done!"
fi


#cleanup
if [ "$DO_CLEANUP" = "yes" ]; then
    rm -rf "$TMP_DIR"
fi
echo "Done!"