1
mirror of https://invent.kde.org/network/falkon.git synced 2024-12-20 02:36:34 +01:00

Add „configure like“ source code compilation script. (#2338)

This commit is contained in:
cranes-bill 2017-05-29 15:41:35 +03:00 committed by David Rosca
parent bd9a33d6f9
commit 0747379114

539
scripts/build-appimage.sh Executable file
View File

@ -0,0 +1,539 @@
#!/bin/sh
###############################################################################
# Configure and compile QupZilla source.
###############################################################################
set -e
SCRIPT_PATH="$(dirname "$(readlink -f "$0")")"
NCPUS=$(getconf _NPROCESSORS_ONLN) || :
which mksquashfs >/dev/null 2>&1 || TEST=no
which chrpath >/dev/null 2>&1 || TEST=no
TEST=${TEST:-yes}
if [ $(which qmake 2>/dev/null) ]; then
SYSTEM_QMAKE=$(which qmake)
elif [ $(which qmake-qt5 2>/dev/null) ]; then
SYSTEM_QMAKE=$(which qmake-qt5)
fi
BLD1="\033[1m"
BLD0="\033[21m"
ITL1="\033[3m"
ITL0="\033[23m"
UDR1="\033[4m"
UDR0="\033[24m"
CRS1="\033[9m"
CRS0="\033[29m"
RDFG="\033[31m"
RDBG="\033[41m"
DFFG="\033[39m"
DFBG="\033[49m"
ALL0="\033[00m"
NO_SYSTEM_DATAPATH=${NO_SYSTEM_DATAPATH:-false} ; export NO_SYSTEM_DATAPATH
PORTABLE_BUILD=${PORTABLE_BUILD:-false} ; export PORTABLE_BUILD
NONBLOCK_JS_DIALOGS=${NONBLOCK_JS_DIALOGS:-false} ; export NONBLOCK_JS_DIALOGS
NO_X11=${NO_X11:-false} ; export NO_X11
USE_WEBGL=${USE_WEBGL:-true} ; export USE_WEBGL
KDE_INTEGRATION=${KDE_INTEGRATION:-false} ; export KDE_INTEGRATION
GNOME_INTEGRATION=${GNOME_INTEGRATION:-false} ; export GNOME_INTEGRATION
DISABLE_DBUS=${DISABLE_DBUS:-false} ; export DISABLE_DBUS
QMAKE=${QMAKE:-$SYSTEM_QMAKE} ; export QMAKE
SOURCE_DIR=${SOURCE_DIR:-${SCRIPT_PATH}/..} ; export SOURCE_DIR
CFLAGS="${CFLAGS:--O2 -g -pipe -Wall }" ; export CFLAGS ;
CXXFLAGS="${CXXFLAGS:--O2 -g -pipe -Wall }" ; export CXXFLAGS ;
LDFLAGS="${LDFLAGS:--Wl,-z,relro }"; export LDFLAGS ;
optPrint(){
printf "\n\t\t${ITL1}VALID OPTIONS ARE${ITL0}:\n
--prefix=[path]
--sourcedir=[path]
--shared=[path]
--libdir=[path]
--qmake=[path to executable]
--debug | -D
--appimage | -A
--runtime=[path]
--portable
--nojs
--no-x11
--with-kde | -K
--with-gnome | -G
--nodatapath
--nodbus
--disable-webgl
--with-system-qtsingleapp
--update-git-source | -U
--no-clean | --noclean
--help | -h | help |-H\n\n"
}
helpPrint(){
printf "\n\t\t\t${ITL1}PARAMETERS${ITL0}:
${BLD1}--portable${BLD0}
QupZilla won't write any data outside of path of execution.
It will also disable plugins by default.
(disabled by default)
${BLD1}--nojs${BLD0}
Enable non-blocking JavaScript dialogs from alert() prompt()
and confirm() functions. They are shown inside page and are not
blocking application window.
However, due to synchronous API, there is a possible crash when
closing browser windows with opened dialogs.
If you can take this risk and/or make sure you aren't closing browser
with opened dialogs, you may enable this option.
These dialogs are much more beautiful than normal QDialogs.
(disabled by default)
${BLD1}--no-x11${BLD0}
Disable all X11 calls.
Enable this when building for Wayland-only.
All X11 calls are guarded by runtime X11 platform check
even without this option.
${BLD1}--with-kde | -K ${BLD0}
Enable KDE integration.
Currently it enables building of KWallet Password plugin,
which provides support for storing passwords in KWallet.
${BLD1}--with-gnome | -G${BLD0}
Enable Gnome integration.
Currently it enables building of Gnome-Keyring Password plugin,
which provides support for storing passwords in Gnome-Keyring.
${BLD1}--libdir=${BLD0}
By default, /usr/lib/ is used for libQupZilla and /usr/lib/qupzilla
for plugins.
You can change it by setting this define.
${UDR1}example:--libdir="/usr/lib64"${UDR0}
${BLD1}--nodatapath=${BLD0}
By default, QupZilla is using /usr/share/qupzilla/ path
for storing themes and translations.
By setting this define, QupZilla will use path of execution.
(disabled by default)
${BLD1}--prefix=${BLD0}
You can define different prefix.
QupZilla binary will then be moved to PREFIX/bin/, use
PREFIX/share/qupzilla/ as datadir, PREFIX/share/applications for
desktop launcher and PREFIX/share/pixmaps for icon.
(default prefix is "/usr/local")
${UDR1}example:--prefix="/usr"${UDR0}
${BLD1}--shared=${BLD0}
You can define the path of the share folder, i.e. /usr/share
QupZilla will then use shared/qupzilla as datadir,
shared/applications for desktop launcher and
shared/pixmaps for the icon. By default it is not defined
and files will be installed as described above.
(default share folder is "/usr/local/share")
${UDR1}example:--shared="/usr/share"${UDR0}
${BLD1}--nodbus${BLD0}
Build without QtDBus module. Native desktop notifications
will be disabled.
${BLD1}--sourcedir=${BLD0}
Assuming this script is located in ${ITL1}qupzilla/scripts${ITL0},
otherwise you must specify the path to
QupZilla source directory.
${UDR1}example:--sourcedir="/home/build/qupzilla"${UDR0}
${BLD1}--runtime=[path]${BLD0}
Path to precompiled „${BLD1}runtime.c${BLD0}${ITL1}(part of AppImageKit)${ITL0}.
More info at: ${UDR1}https://github.com/probonopd/AppImageKit${UDR0}
Requires ${BLD1}--appimage${BLD0}
${BLD1}--appimage | -A${BLD0}
Also create an AppImage.
In order to build AppImage,
you must have installed the following tools:
${ITL1}mmksquashfs, patchelf${ITL0}!
Also, you should use precompiled Qt package
downloaded from ${UDR1}${ITL1}http://download.qt.io/official_releases/qt/${ALL0},
and precompiled „${BLD1}runtime${BLD0}“ binary - part of ${ITL1}AppImageKit${ITL0}
${UDR1}https://github.com/probonopd/AppImageKit${UDR0},
otherwise this option will be ignored.
Requires ${BLD1}--runtime${BLD0}
Implies ${BLD1}--nodatapath${BLD0}
${BLD1}--disable-webgl${BLD0}
Disable WebGL. You need to build QupZilla with WebKit built
with WebGL support, otherwise you won't be able to compile
without errors.
Only for QtWebKit lower than 2.3
(disabled by default)
${BLD1}--with-system-qtsingleapp${BLD0}
Use system QtSingleApplication library.
This option can only be used with system qmake!
${BLD1}--debug | -D${BLD0}
You may want to build QupZilla with debugging symbols (for generating
backtrace of crash).
${BLD1}--update-git-source | -U${BLD0}
Fetches the information from QupZilla online git repository
and merges it with your local copy
${BLD1}--no-clean | --noclean${BLD0}
Skip cleaning previously compilled files.
${BLD1}--qmake=${BLD0}
Full path to qmake executable.
This option is mandatory in case you want
to create an AppImage.
\n"
}
printConf(){
printf "\n\tBuild configuration:\n
QUPZILLA_PREFIX=${QUPZILLA_PREFIX}
SOURCE_DIR=${SOURCE_DIR}
SHARE_FOLDER=${SHARE_FOLDER}
USE_LIBPATH=${USE_LIBPATH}
DEBUG_BUILD=${DEBUG_BUILD}
BUILD_AI=${BUILD_AI}
PORTABLE_BUILD=${PORTABLE_BUILD}
NONBLOCK_JS_DIALOGS=${NONBLOCK_JS_DIALOGS}
NO_X11=${NO_X11}
KDE_INTEGRATION=${KDE_INTEGRATION}
GNOME_INTEGRATION=${GNOME_INTEGRATION}
NO_SYSTEM_DATAPATH=${NO_SYSTEM_DATAPATH}
DISABLE_DBUS=${DISABLE_DBUS}
USE_WEBGL=${USE_WEBGL}
SKIP_CLEANNING=${SKIP_CLEANNING}
USE_SYS_QTSA=${USE_SYS_QTSA}
RUNTIME_BINARY=${RUNTIME_BINARY}
QMAKE=${QMAKE}\n" | sed -r 's/=$/ » Not set/g'
}
getVal(){
echo $* | sed -r 's/([[:graph:]]*=)//'
}
varAssign(){
while [ $# != 0 ] ;do
CFG_OPT="$1"
case "${CFG_OPT}" in
--prefix=*)
QUPZILLA_PREFIX=$(getVal "${CFG_OPT}")
export QUPZILLA_PREFIX
;;
--sourcedir=*)
SOURCE_DIR=$(getVal "${CFG_OPT}")
export SOURCE_DIR
;;
--shared=*)
SHARE_FOLDER=$(getVal "${CFG_OPT}")
export SHARE_FOLDER
;;
--libdir=*)
USE_LIBPATH=$(getVal "${CFG_OPT}")
export USE_LIBPATH
;;
--debug|-D)
DEBUG_BUILD="CONFIG+=debug"
export DEBUG_BUILD
;;
--appimage|-A)
BUILD_AI="true"
export BUILD_AI
;;
--runtime=*)
RUNTIME_BINARY=$(getVal "${CFG_OPT}")
export RUNTIME_BINARY
;;
--portable)
PORTABLE_BUILD="true"
export PORTABLE_BUILD
;;
--nojs)
NONBLOCK_JS_DIALOGS="true"
export NONBLOCK_JS_DIALOGS
;;
--no-clean|--noclean)
SKIP_CLEANNING="true"
export SKIP_CLEANNING
;;
--no-x11)
NO_X11="true"
export NO_X11
;;
--with-kde|-K)
KDE_INTEGRATION="true"
export KDE_INTEGRATION
;;
--with-gnome|-G)
GNOME_INTEGRATION="true"
export GNOME_INTEGRATION
;;
--nodatapath)
NO_SYSTEM_DATAPATH="true"
export NO_SYSTEM_DATAPATH
;;
--nodbus)
DISABLE_DBUS="true"
export DISABLE_DBUS
;;
--disable-webgl)
USE_WEBGL="false"
export USE_WEBGL
;;
--with-system-qtsingleapp)
USE_SYS_QTSA="CONFIG+=QtSingleApplication"
export USE_SYS_QTSA
;;
--qmake=*)
QMAKE=$(getVal "${CFG_OPT}")
export QMAKE
;;
--update-git-source|-U)
UPDATE_SOURCE="true"
export UPDATE_SOURCE
;;
--help|help|-h|-H)
helpPrint
exit 1
;;
*)
printf "\n${RDBG}unknown parameter: ${CFG_OPT}${DFBG}\n"
optPrint
exit 1
;;
esac
shift
done
}
nowBuild()
{
QUPZILLA_PREFIX=${QUPZILLA_PREFIX:-/usr/local} ; export QUPZILLA_PREFIX
SHARE_FOLDER=${SHARE_FOLDER:-$QUPZILLA_PREFIX/share} ; export SHARE_FOLDER
USE_LIBPATH=${USE_LIBPATH:-$QUPZILLA_PREFIX/lib} ; export USE_LIBPATH
printConf
cd "${SOURCE_DIR}"
if [[ -z "${SKIP_CLEANNING}" ]]; then
make distclean >/dev/null 2>&1 || :
rm -fr bundle_build_dir qupzilla.squashfs bin/QupZilla.AppImage || :
fi
if [[ "${UPDATE_SOURCE}" == "true" ]]; then
git pull || :
fi
if [[ ! -z "${USE_SYS_QTSA}" ]]; then
HEADERSARETHERE=$(${QMAKE} -query | grep INSTALL_HEADERS | sed 's/QT_INSTALL_HEADERS://')
rm -fr src/lib/3rdparty/qtsingleapplication
ln -s ${HEADERSARETHERE}/QtSolutions src/lib/3rdparty/qtsingleapplication
sed -i 's,include.*qtsingleapplication.*,,' src/plugins.pri
sed -i 's,include.*qtsingleapplication.*,,' src/lib/lib.pro
fi
${QMAKE} ${DEBUG_BUILD} ${USE_SYS_QTSA}
printf "Compiling QupZilla\n"
make -j$NCPUS
}
nowBldImg(){
NO_SYSTEM_DATAPATH="true"; export NO_SYSTEM_DATAPATH
QTFILESARETHERE=$(${QMAKE} -query | grep INSTALL_PREFIX | sed 's/QT_INSTALL_PREFIX://')
LIBSARETHERE=$(${QMAKE} -query | grep INSTALL_LIBS | sed 's/QT_INSTALL_LIBS://')
PLUGINSARETHERE=$(${QMAKE} -query | grep INSTALL_PLUGINS | sed 's/QT_INSTALL_PLUGINS://')
QMLSARETHERE=$(${QMAKE} -query | grep INSTALL_QML | sed 's/QT_INSTALL_QML://')
TRANSLATIONSARETHERE=$(${QMAKE} -query | grep INSTALL_TRANSLATIONS | sed 's/QT_INSTALL_TRANSLATIONS://')
LIBEXECSARETHERE=$(${QMAKE} -query | grep INSTALL_LIBEXECS | sed 's/QT_INSTALL_LIBEXECS://')
NEEDEDLIBSLIST="libicudata.so
libicui18n.so
libicuuc.so
libQt5Core.so
libQt5DBus.so
libQt5Gui.so
libQt5Multimedia.so
libQt5MultimediaWidgets.so
libQt5Network.so
libQt5OpenGL.so
libQt5Positioning.so
libQt5PrintSupport.so
libQt5Qml.so
libQt5Quick.so
libQt5QuickWidgets.so
libQt5Sql.so
libQt5Svg.so
libQt5WebChannel.so
libQt5WebEngineCore.so
libQt5WebEngineCore.so
libQt5WebEngine.so
libQt5WebEngineWidgets.so
libQt5Widgets.so
libQt5X11Extras.so
libQt5XcbQpa.so"
NEEDEDPLUGINSLIST="generic
iconengines
imageformats
platforminputcontexts
platformthemes
printsupport
xcbglintegrations"
nowBuild
mkdir bundle_build_dir || :
cp -r bin/* bundle_build_dir
pushd bundle_build_dir/plugins
patchelf --set-rpath '$ORIGIN/../lib' *.so
popd
mkdir -p bundle_build_dir/lib \
bundle_build_dir/plugins/{platforms,sqldrivers} \
bundle_build_dir/qtwebengine_dictionaries \
bundle_build_dir/qml \
bundle_build_dir/translations || :
for L in ${NEEDEDLIBSLIST} ; do
cp -d ${LIBSARETHERE}/${L}* bundle_build_dir/lib ;
done
for P in ${NEEDEDPLUGINSLIST} ; do
cp -r ${PLUGINSARETHERE}/${P} bundle_build_dir/plugins ;
done
install ${PLUGINSARETHERE}/platforms/libqxcb.so bundle_build_dir/plugins/platforms
install ${PLUGINSARETHERE}/sqldrivers/libqsqlite.so bundle_build_dir/plugins/sqldrivers
cp -r ${QMLSARETHERE}/{QtQuick.2,QtWebEngine} bundle_build_dir/qml
cp -r ${QTFILESARETHERE}/resources bundle_build_dir
cp -r ${TRANSLATIONSARETHERE}/qtwebengine_locales bundle_build_dir/translations
cp ${LIBEXECSARETHERE}/QtWebEngineProcess bundle_build_dir
CRYPTONEEDED=$(ldd 'bin/qupzilla'| grep libcrypto | sed 's/.*=>//;s/(.*//')
cp ${CRYPTONEEDED} bundle_build_dir/lib
cp linux/applications/qupzilla.desktop bundle_build_dir
cp linux/pixmaps/qupzilla.png bundle_build_dir
ln -sf qupzilla.png bundle_build_dir/.DirIcon
pushd bundle_build_dir
patchelf --set-rpath '$ORIGIN:$ORIGIN/lib' libQupZilla.so
patchelf --set-rpath '$ORIGIN:$ORIGIN/lib' qupzilla
patchelf --set-rpath '$ORIGIN:$ORIGIN/lib' QtWebEngineProcess
cat <<EOQTCFG >qt.conf
[Paths]
Plugins=plugins
Imports=qml
Qml2Imports=qml
LibraryExecutables=.
EOQTCFG
cat <<EOF >AppRun
#!/bin/sh
#
set -e
QUPZILLA_MOUNT_PATH="\$(dirname "\$(readlink -f "\$0")")"
QT_DIR=\${QUPZILLA_MOUNT_PATH}
export QT_DIR
QT_QPA_PLATFORM_PLUGIN_PATH="\${QT_DIR}/plugins/platforms"
QT_PLUGIN_PATH="\${QT_DIR}/plugins"
QML2_IMPORT_PATH="\${QT_DIR}/qml"
QTWEBENGINEPROCESS_PATH="\${QT_DIR}/QtWebEngineProcess"
export QT_QPA_PLATFORM_PLUGIN_PATH QT_PLUGIN_PATH QML2_IMPORT_PATH QTWEBENGINEPROCESS_PATH
cd "\${QUPZILLA_MOUNT_PATH}/"
exec ./qupzilla "\$@"
EOF
chmod +x AppRun
popd
printf "Generating app image\n"
mksquashfs bundle_build_dir qupzilla.squashfs -root-owned -noappend
cat "${RUNTIME_BINARY}" >bin/QupZilla.AppImage
cat qupzilla.squashfs >>bin/QupZilla.AppImage
chmod a+x bin/QupZilla.AppImage
}
varAssign $*
if [[ ! -x ${QMAKE} ]] ;then
printf "${RDFG}ERROR${DFFG}: ${BLD1}qmake${BLD0} was not found! Please install it or use ${BLD1}--qmake=${BLD0} option to specify the path where it is located!\n"
exit 1
fi
if [[ ! -z "${USE_SYS_QTSA}" ]] && [[ ${QMAKE} != ${SYSTEM_QMAKE} ]] ;then
printf "${RDFG}ERROR${DFFG}: You must use system qmake in order to build Qupzilla with system QtsingleApplication libraries!\n"
exit 1
fi
if [[ ! -d "${SOURCE_DIR}/src" ]]; then
printf "Please install ${UDR1}$0${UDR0} in „${BLD1}scripts${BLD0}${ITL1}(a sub folder in QupZilla source directory)${ITL0},
or specify the source path with ${BLD1}--sourcedir=${BLD0} parameter!\n"
exit 1
fi
if [[ ${BUILD_AI} == "true" ]] && [[ ${TEST} == "yes" ]] && [[ ${QMAKE} != ${SYSTEM_QMAKE} ]] && [[ ! -z ${RUNTIME_BINARY} ]] ; then
nowBldImg
else
nowBuild
fi
if [[ $? == 0 ]] && [[ -x ${SOURCE_DIR}/bin/qupzilla ]]; then
printf "\\033c"
printf "Done!\nThe compiled files are in "${PWD}"/bin\n"
if [[ -z "${BUILD_AI}" ]]; then
printf "Now you can type „${ITL1}make install${ITL}“ to install them\n"
fi
fi
exit 0