wxWidgets/wxPython/distrib/mac/wxPythonOSX/build

#!/bin/sh -e
#----------------------------------------------------------------------
# Build wxMac and wxPythonOSX from the tarball and then make an
# Installer package out of it.

#set -o xtrace

spectemplate=distrib/wxPythonFull.spec.in

if [ ! -d wxPython -o ! -e ${spectemplate} ]; then
    echo "Please run this script from the root wxPython directory."
    exit 1
fi

if [ "$UID" != "0" ]; then
    echo "-------------------------------------------------------"
    echo " WARNING: I will be unable to change ownership of files"
    echo " unless this script is run as root or via sudo"
    echo "-------------------------------------------------------"
fi

#----------------------------------------------------------------------
# Check Parameters

function usage {
    echo ""
    echo "Usage: $0  PYVER [command flags...]"
    echo ""
    echo "   PYVER          Python version to use to do the build.  A"
    echo "                  matching python\$PYVER must be found on the PATH"
    echo ""
    echo "optional command flags:"
    echo "   skiptar        Don't unpack the tarball"
    echo "   inplace        Don't use the tarball, build from the CVS tree instead"
    echo "                  (The Docs and Demo tarballs are still required for a full build.)"
    echo "   reswig         Regenerate SWIG wrappers"
    echo "   universal      Generate Universal wxWidgets binary (requires Universal Python "
    echo "                  to general Universal wxPython)."
    echo "   unicode        Make a unicode build"
    echo "   skipconfig     Don't run configure"
    echo "   skipbuild      Don't build wxWidgets or wxPython"
    echo "   skipinstall    Don't do the installation step"
    echo "   skipdmg        Don't make the package or diskimage"
    echo "   skipclean      Don't do the cleanup at the end"
    echo ""
}


PYVER=$1
if [ "$PYVER" != "" ] && which python$PYVER && which pythonw$PYVER; then
    PYTHON=`which python$PYVER`
    PYTHONW=`which pythonw$PYVER`
else
    usage;
    exit 1
fi

shift

skiptar=no
skipconfig=no
skipbuild=no
skipinstall=no
skipdmg=no
skipclean=no
inplace=no
unicode=no
debug=no
reswig=no
universal=no

for flag in $*; do
    case ${flag} in
	skiptar)     skiptar=yes                                ;;
	skipconfig)  skipconfig=yes; skiptar=yes                ;;
	skipbuild)   skipbuild=yes; skipconfig=yes; skiptar=yes ;;
	skipinstall) skipinstall=yes                            ;;
	skipdmg)     skipdmg=yes                                ;;
	skipclean)   skipclean=yes                              ;;
	inplace)     inplace=yes; skiptar=yes                   ;;
	unicode)     unicode=yes                                ;;
	ansi)        unicode=no                                 ;;
	debug)       debug=yes                                  ;;
	reswig)      reswig=yes                                 ;;
	universal)   universal=yes                              ;;
	*)  echo "Unknown flag \"${flag}\""
	    usage
	    exit 1
    esac
done



OSX_VERSION=`sw_vers -productVersion`
OSX_VERSION=${OSX_VERSION:0:4}

case $OSX_VERSION in
    10.4)    TAG=macosx10.4 ;;
    10.3)    TAG=macosx10.3 ;;
    10.2)    TAG=macosx10.2 ;;
    *)       usage; exit 1 ;;
esac

if [ $universal = yes ]; then
    TAG=universal10.4
fi



VERSION=`$PYTHON -c "import setup;print setup.VERSION"`
SHORTVER=`echo $VERSION | cut -c 1,2,3`
PYPREFIX=`$PYTHON -c "import sys; print sys.exec_prefix"`
PYLIB=$PYPREFIX/lib/python$PYVER
SITEPACKAGES=$PYLIB/site-packages

if [ $unicode == yes ]; then
    CHARTYPE=unicode
    UNICODEOPT=--enable-unicode
    PYUNICODEOPT=1
else
    CHARTYPE=ansi
    UNICODEOPT=--disable-unicode
    PYUNICODEOPT=0
fi

if [ $debug == yes ]; then
    DEBUG_FLAG=--enable-debug
    PYDEBUGOPT=--debug
else
    DEBUG_FLAG=--enable-debug_flag
    PYDEBUGOPT=
fi


# Test if the python we are using is the System installed framework 
# or one that was installed by the user.  This changes where the 
# site-packages (or its alias) is located in the installer tree.
APPLE_PYTHON=no
if [ -e /Library/Python/$PYVER ] && [ `dirname $PYTHON` == "/usr/bin" ]; then
    APPLE_PYTHON=yes
fi



if [ -z "$TARBALLDIR" ]; then
    # this is a spot on my fileserver where the tarballs go, adjust
    # as needed for where you put the wxPython tarball, or set
    # TARBALLDIR before invoking this script...
    TARBALLDIR=/stuff/Development/wxPython/dist/$VERSION
fi
TARBALL=$TARBALLDIR/wxPython-src-$VERSION.tar.bz2

if [ ! -e $TARBALLDIR/wxPython-demo-$VERSION.tar.bz2 ]; then 
    echo "-------------------------------------------------------"
    echo " WARNING:  Demo tarball not found, will skip building "
    echo "           the Demo app bundle and etc."
    echo " $TARBALLDIR/wxPython-demo-$VERSION.tar.bz2"
    echo "-------------------------------------------------------"
fi

if [ ! -e $TARBALLDIR/wxPython-docs-$VERSION.tar.bz2 ]; then
    echo "-------------------------------------------------------"
    echo " WARNING:  Docs tarball not found, will skip building "
    echo "           the the wxDocsViewer app bundle and etc."
    echo " $TARBALLDIR/wxPython-docs-$VERSION.tar.bz2"
    echo "-------------------------------------------------------"
fi




PREFIX=/usr/local/lib/wxPython-$CHARTYPE-$VERSION
BINPREFIX=/usr/local/bin

SWIGBIN=/opt/swig/bin/swig
WXROOT=`dirname $PWD`
PROGDIR="`dirname \"$0\"`"
TMPDIR=$PWD/_build_dmg

BUILDROOT=$TMPDIR/build

INSTALLROOT=$TMPDIR/install-root
INSTALLAPPS=$TMPDIR/install-apps

DMGDIR=$TMPDIR/dmg
DMGROOT=$DMGDIR/root
DMGAPPS=$DMGDIR/apps

RESOURCEDIR=$PROGDIR/resources
DESTDIR=$PWD/dist
SRCROOT=$BUILDROOT/wxPython-src-$VERSION


#----------------------------------------------------------------------
# Setup builddirs

mkdir -p $BUILDROOT
mkdir -p $INSTALLROOT
mkdir -p $INSTALLAPPS

rm -rf $DMGDIR
mkdir -p $DMGROOT
mkdir -p $DMGAPPS/Docs
mkdir -p $DMGAPPS/Samples

if [ ! -d $DESTDIR ]; then
  mkdir $DESTDIR
fi

pushd $BUILDROOT


#----------------------------------------------------------------------
# Unpack the tarball

if [ $skiptar != yes ]; then
    echo Unarchiving tarball...
    tar xjf $TARBALL
fi

if [ $inplace = no ]; then
    # make a build dir and cd to it.
    cd wxPython-src-$VERSION
    WXDIR=`pwd`
    mkdir -p $WXDIR/bld
    cd $WXDIR/bld
    WXBLD=$WXDIR/bld
else

    # If building "inplace" then our build dir will be off of the
    # WXROOT like normal, adjust the variables to find things that
    # way.
    WXBLD=$WXROOT/build-$CHARTYPE
    mkdir -p $WXBLD
    cd $WXBLD
    WXDIR=..
    SRCROOT=$WXROOT
fi

echo "Using wx root dir: $WXROOT"
echo "Using build dir:   $WXBLD" 
echo "Using source tree: $WXDIR"

#----------------------------------------------------------------------

if [ $OSX_VERSION = 10.3 -o $OSX_VERSION = 10.4 ]; then 
    OTHER_CFG_OPTS=--enable-mediactrl
fi

# Configure wxWidgets
if [ $skipconfig != yes -a $universal != yes ]; then
    $WXDIR/configure \
	--prefix=$PREFIX \
	--with-mac \
	--enable-monolithic \
	--with-opengl \
	--enable-sound \
	--enable-display \
	--enable-geometry \
	--enable-graphics_ctx \
	$DEBUG_FLAG \
	--enable-precomp=no \
	--enable-optimise \
	--disable-debugreport \
	--disable-precompiled-headers \
	$UNICODEOPT $OTHER_CFG_OPTS

fi

# Build wxWidgets and wxPython
if [ $skipbuild != yes ]; then

    # Make wxWidgets and some contribs
    WXBLD_CONFIG="$WXBLD/wx-config"
    if [ $universal = yes ]; then
        export WXROOT
        export BUILDPREFIX=$PREFIX
        export INSTALLDIR=$INSTALLROOT$PREFIX
        $WXDIR/distrib/scripts/mac/macbuild wxpython universal $CHARTYPE
    else
        make $MAKEJOBS
        make $MAKEJOBS -C contrib/src/gizmos
        make $MAKEJOBS -C contrib/src/stc
    fi
    
    SWIGIT=0
    if [ $reswig = yes ]; then
        SWIGIT=1
    fi

    # Build wxPython
    cd $WXROOT/wxPython
    $PYTHON setup.py \
	UNICODE=$PYUNICODEOPT \
	NO_SCRIPTS=1 \
	EP_ADD_OPTS=1 \
	WX_CONFIG="$WXBLD_CONFIG --inplace" \
	BUILD_BASE=$WXBLD/wxPython \
	SWIG=$SWIGBIN \
	USE_SWIG=$SWIGIT \
	build
fi

#----------------------------------------------------------------------

if [ $skipinstall != yes ]; then
    # Install wxWidgets
    cd $WXBLD
    if [ $universal != yes ]; then
        make                        prefix=$INSTALLROOT$PREFIX install
        make -C contrib/src/gizmos  prefix=$INSTALLROOT$PREFIX install
        make -C contrib/src/stc     prefix=$INSTALLROOT$PREFIX install
    fi

    # relink wx-config with a relative link
    cd $INSTALLROOT$PREFIX/bin
    rm wx-config
    ln -s ../lib/wx/config/* wx-config

    # and wxPython
    cd $WXROOT/wxPython
    $PYTHON setup.py \
	UNICODE=$PYUNICODEOPT \
	NO_SCRIPTS=1 \
	EP_ADD_OPTS=1 \
	WX_CONFIG="$INSTALLROOT$PREFIX/bin/wx-config --prefix=$INSTALLROOT$PREFIX" \
	BUILD_BASE=$WXBLD/wxPython \
	install \
	--root=$INSTALLROOT


    # Apple's Python Framework (such as what comes with Panther)
    # sym-links the site-packages dir in the framework to
    # /Library/Python/$PYVER so we need to move the files so they are
    # installed in the physical location, not the virtual one.
    if [ $APPLE_PYTHON == yes ]; then
	if [ -e $INSTALLROOT/Library/Python/$PYVER ]; then
	    rm -r $INSTALLROOT/Library/Python/$PYVER
	fi	    
	mkdir -p $INSTALLROOT/Library/Python/$PYVER
	mv $INSTALLROOT/$SITEPACKAGES/* $INSTALLROOT/Library/Python/$PYVER
	rm -r $INSTALLROOT/System
	SITEPACKAGES=/Library/Python/$PYVER
    fi

    # install wxPython's tool scripts
    mkdir -p $INSTALLROOT$BINPREFIX
    cd $WXROOT/wxPython/scripts
    python$PYVER CreateMacScripts.py $INSTALLROOT $BINPREFIX


    # Remove the .pyc/.pyo files they just take up space and can be recreated
    # during the install.
    pushd $WXROOT/wxPython
    $PYTHON $PROGDIR/../zappycfiles.py $INSTALLROOT > /dev/null
    popd

    # Set premissions for files in $INSTALLROOT
    if [ "$UID" = "0" ]; then
	chown -R root:admin $INSTALLROOT
	chmod -R g+w        $INSTALLROOT
    fi
fi

if [ $APPLE_PYTHON == yes ]; then
    SITEPACKAGES=/Library/Python/$PYVER
fi
PKGDIR=`cat $INSTALLROOT$SITEPACKAGES/wx.pth`

popd

#----------------------------------------------------------------------

# Make the Installer packages and disk image
if [ $skipdmg != yes ]; then

    #-----------------------------------------------
    # The main runtime installer package

    # Make the welcome message
    case $OSX_VERSION in
	10.4)  W_MSG="the Tiger (OS X 10.4.x Intel) version of" ;;
	10.3)  W_MSG="the Panther (OS X 10.3.x) version of" ;;
	10.2)  W_MSG="the Jaguar (OS X 10.2.x) version of" ;;
    esac

    if [ $universal == yes ]; then
      W_MSG="the Universal (OS X 10.4.x and above) version of"
    fi
    

    cat > $RESOURCEDIR/Welcome.txt <<EOF
Welcome!

This Installer package will install the wxPython $CHARTYPE runtime $VERSION for $W_MSG MacPython-OSX $PYVER.  This includes:

    * The wxPython packages and modules
    * The wxWidgets shared libraries and headers
    * Some command line tool scripts, installed to /usr/local/bin.

You must install onto your current boot disk, eventhough the installer does not enforce this, otherwise things will not work.

You can install more than one version of the wxPython runtime if you desire.  The most recently installed version will be the default wxPython, but you can choose another by setting the PYTHONPATH or by using the wxversion module.  See http://wiki.wxpython.org/index.cgi/MultiVersionInstalls for more details.

Build date:   `date`
EOF

    # make the preflight script
    cat > $RESOURCEDIR/preflight <<EOF
#!/bin/sh
# Cleanup any old install of the wxPython package
rm -rf \$2$SITEPACKAGES/wxPython
rm -rf \$2$SITEPACKAGES/wx
rm -rf \$2$SITEPACKAGES/$PKGDIR
exit 0
EOF
    chmod +x $RESOURCEDIR/preflight

    # make the postflight script
    cat > $RESOURCEDIR/postflight <<EOF
#!/bin/sh -e
# Compile the .py files in the wxPython pacakge
$PYTHON \$2$PYLIB/compileall.py \$2$SITEPACKAGES/$PKGDIR
$PYTHON -O \$2$PYLIB/compileall.py \$2$SITEPACKAGES/$PKGDIR

# and all of the wxPython pacakge should be group writable
chgrp -R admin \$2$SITEPACKAGES/$PKGDIR
chmod -R g+w \$2$SITEPACKAGES/$PKGDIR

exit 0
EOF
    chmod +x $RESOURCEDIR/postflight

    

    # Build the main Installer Package...
    PKGNAME=wxPython${SHORTVER}-osx-$CHARTYPE-$TAG
    if [ $PYVER != 2.3 ]; then
	PKGNAME=wxPython${SHORTVER}-osx-$CHARTYPE-$TAG-py$PYVER
    fi
    rm -rf $PKGNAME.pkg
    $PYTHON $PROGDIR/../buildpkg.py \
	--Title=$PKGNAME \
	--Version=$VERSION \
	--Description="wxPython $CHARTYPE runtime $VERSION for $W_MSG MacPython-OSX $PYVER" \
	--NeedsAuthorization="YES" \
	--Relocatable="NO" \
	--InstallOnly="YES" \
	$INSTALLROOT \
	$RESOURCEDIR

    mv $PKGNAME.pkg $DMGROOT/$PKGNAME.pkg

    rm $RESOURCEDIR/postflight
    rm $RESOURCEDIR/preflight
    rm $RESOURCEDIR/Welcome.txt


    #-----------------------------------------------
    # Make a README to go on the disk image
    cat > "$DMGROOT/README 1st.txt" <<EOF
Welcome to wxPython!

This disk image contains the following items:

    wxPython${SHORTVER}-osx-$CHARTYPE-$VERSION-$KIND

        This Installer contains the wxPython runtime, compiled on a
        $KIND OS X system, using the $CHARTYPE build of the wxWidgets
        library.  It includes the Python modules and extension
        modules, as well as the wxWidgets libraries.

        It is possible to have more than one version of the runtime
        installed at once if you wish.  The most recently installed
        version will be the default wxPython, but you can choose
        another by setting the PYTHONPATH or by using the wxversion
        module.  For more details see:
        http://wiki.wxpython.org/index.cgi/MultiVersionInstalls 


    uninstall_wxPython.py

        A simple tool to help you manage your installed versions of
        wxPython.  It will allow you to choose from the currently
        installed wxPython packages and to select one for
        uninstallation.  It is a text-mode tool so you can either run
        it from a Terminal command line, or you can open it with
        PythonLauncher and let it create a Terminal to run it in.

        NOTE: If you have versions prior to 2.5.3.1 installed, please
        do run this uninstall tool to remove the older version.

EOF



    cp $PROGDIR/../uninstall_wxPython.py $DMGROOT


    #-----------------------------------------------
    # Make a disk image to hold these files
    dmgname=wxPython${SHORTVER}-osx-$CHARTYPE-$VERSION-$TAG-py$PYVER
    $PROGDIR/../makedmg $DMGROOT $DMGDIR $dmgname

    echo Moving $DMGDIR/$dmgname.dmg to $DESTDIR
    mv $DMGDIR/$dmgname.dmg  $DESTDIR/$dmgname.dmg


#---------------------------------------------------------------------------
# Now create app bundles for the demo, docs, and tools and make another
# disk image to hold it all.
#---------------------------------------------------------------------------

    cat > "$DMGAPPS/README 1st.txt" <<EOF
Welcome to wxPython!

On this disk image you will find Demo, Tools, Docs, and etc. for
wxPython $VERSION.  Everything here is optional and you can drag them
out of the disk image and drop them wherever you want.  You will need
to have an installed wxPython runtime to be able to use any of them.


   wxPython Demo        An application bundle version of the demo.
                        (This has it's own copy of the demo sources 
                        within the bundle.)

   XRCed                An application for editing wxPython resource
                        files  (XRC files.)

   PyCrust              An application that provides an interactive
                        Python shell and also namespace inspectors.



   Docs/wxDocsViewer    An application that allows you to view the
                        wxWidgets documentation.

   Docs/licence         License files.

   Docs/other           A few readmes, change log, etc.


   Samples/samples      Several small sample applications that
                        demonstrate how to use wxPython.

   Samples/demo         A copy of the wxPython demo source code,
                        just open the folder and run demo.pyw.

Happy Hacking!
EOF

#   PyAlaMode            An extension of PyCrust that includes source
#                        file editing capabilities.


    # wxDocs
    if [ ! -e $TARBALLDIR/wxPython-docs-$VERSION.tar.bz2 ]; then
	cat > "$DMGAPPS/Docs/Build ERROR.txt" <<EOF

The wxPython-docs tarball was not found when building this disk image!

EOF

    else
	pushd $BUILDROOT
	tar xjvf $TARBALLDIR/wxPython-docs-$VERSION.tar.bz2
	popd

        # Make an app to launch viewdocs.py
	$PYTHONW $PROGDIR/../buildapp.py \
	    --builddir=$DMGAPPS/Docs \
	    --name=wxDocsViewer \
	    --mainprogram=$BUILDROOT/wxPython-$VERSION/docs/viewdocs.py \
	    --iconfile=$PROGDIR/Info.icns \
	    build

	cp $BUILDROOT/wxPython-$VERSION/docs/*.zip $DMGAPPS/Docs/wxDocsViewer.app/Contents/Resources

	cat > "$DMGAPPS/Docs/README 1st.txt" <<EOF

The wxDocsViewer application needs to be copied to your Desktop (or
someplace else you have write access to) before you can run it, so it
can cache some indexes within its bundle.

EOF

    fi

    # license files, docs, etc.
    pushd $DMGAPPS/Docs
    cp -pR $SRCROOT/wxPython/licence   .
    cp -pR $SRCROOT/wxPython/docs      .
    rm -rf docs/bin
    rm -rf docs/xml-raw
    mv docs other
    popd


    if [ ! -e $TARBALLDIR/wxPython-demo-$VERSION.tar.bz2 ]; then
	cat > "$DMGAPPS/Samples/Build ERROR.txt" <<EOF

The wxPython-$VERSION-demo tarball was not found when building this disk image!

EOF
	cp "$DMGAPPS/Samples/Build ERROR.txt" $DMGAPPS

    else

        # Copy the demo and samples to the disk image from the tarball
	pushd $DMGAPPS/Samples
	tar xjvf $TARBALLDIR/wxPython-demo-$VERSION.tar.bz2
	mv wxPython-$VERSION/* .
	rm -rf wxPython-$VERSION
	rm -f demo/b demo/.setup.sh
	mv demo/demo.py demo/demo.pyw
	popd

        # Make an app bundle to run the demo
	$PYTHONW $PROGDIR/../buildapp.py \
	    --builddir=$DMGAPPS \
	    --name="wxPython Demo" \
	    --mainprogram=$DMGAPPS/Samples/demo/demo.pyw \
	    --iconfile=$PROGDIR/RunDemo.icns \
	    build
	cp -pR $DMGAPPS/Samples/demo/* "$DMGAPPS/wxPython Demo.app/Contents/Resources"
    fi


    # Make an app bundle to launch PyCrust
    $PYTHONW $PROGDIR/../buildapp.py \
	--builddir=$DMGAPPS \
	--name=PyCrust \
	--mainprogram=$INSTALLROOT$BINPREFIX/pycrust.py \
	--iconfile=$PROGDIR/PieShell.icns \
	build

## TODO: PyAlaMode needs tweaked to be able to run from a bundle.  It
## needs to know to ignore command line parameters and etc...
#      # and PyAlaMode
#      $PYTHONW $PROGDIR/../buildapp.py \
#  	--builddir=$DMGAPPS \
#  	--name=PyAlaMode \
#  	--mainprogram=$INSTALLROOT$BINPREFIX/pyalamode.py \
#  	--iconfile=$PROGDIR/PieShell.icns \
#  	build

    # Make an app to launch XRCed
    $PYTHONW $PROGDIR/../buildapp.py \
 	--builddir=$DMGAPPS \
 	--name=XRCed \
 	--mainprogram=$INSTALLROOT$BINPREFIX/xrced.py \
 	--iconfile=$PROGDIR/XRCed.icns \
 	build



    # and then finally make a disk image containing everything
    dmgname=wxPython${SHORTVER}-osx-docs-demos-$VERSION-$TAG-py$PYVER
    $PROGDIR/../makedmg $DMGAPPS $DMGDIR $dmgname

    echo Moving $DMGDIR/$dmgname.dmg to $DESTDIR
    mv $DMGDIR/$dmgname.dmg  $DESTDIR/$dmgname.dmg
fi


# Cleanup build/install dirs
if [ $skipclean != yes ]; then
    echo "Cleaning up..."
    rm -rf $TMPDIR
else
    echo "Cleanup is disabled.  You should remove $TMPDIR when finished"
fi

exit 0