Daira Hopwood
7 years ago
8 changed files with 86 additions and 1975 deletions
@ -1,433 +0,0 @@ |
|||
dnl Helper for cases where a qt dependency is not met. |
|||
dnl Output: If qt version is auto, set bitcoin_enable_qt to false. Else, exit. |
|||
AC_DEFUN([BITCOIN_QT_FAIL],[ |
|||
if test "x$bitcoin_qt_want_version" = "xauto" && test x$bitcoin_qt_force != xyes; then |
|||
if test x$bitcoin_enable_qt != xno; then |
|||
AC_MSG_WARN([$1; bitcoin-qt frontend will not be built]) |
|||
fi |
|||
bitcoin_enable_qt=no |
|||
bitcoin_enable_qt_test=no |
|||
else |
|||
AC_MSG_ERROR([$1]) |
|||
fi |
|||
]) |
|||
|
|||
AC_DEFUN([BITCOIN_QT_CHECK],[ |
|||
if test "x$bitcoin_enable_qt" != "xno" && test x$bitcoin_qt_want_version != xno; then |
|||
true |
|||
$1 |
|||
else |
|||
true |
|||
$2 |
|||
fi |
|||
]) |
|||
|
|||
dnl BITCOIN_QT_PATH_PROGS([FOO], [foo foo2], [/path/to/search/first], [continue if missing]) |
|||
dnl Helper for finding the path of programs needed for Qt. |
|||
dnl Inputs: $1: Variable to be set |
|||
dnl Inputs: $2: List of programs to search for |
|||
dnl Inputs: $3: Look for $2 here before $PATH |
|||
dnl Inputs: $4: If "yes", don't fail if $2 is not found. |
|||
dnl Output: $1 is set to the path of $2 if found. $2 are searched in order. |
|||
AC_DEFUN([BITCOIN_QT_PATH_PROGS],[ |
|||
BITCOIN_QT_CHECK([ |
|||
if test "x$3" != "x"; then |
|||
AC_PATH_PROGS($1,$2,,$3) |
|||
else |
|||
AC_PATH_PROGS($1,$2) |
|||
fi |
|||
if test "x$$1" = "x" && test "x$4" != "xyes"; then |
|||
BITCOIN_QT_FAIL([$1 not found]) |
|||
fi |
|||
]) |
|||
]) |
|||
|
|||
dnl Initialize qt input. |
|||
dnl This must be called before any other BITCOIN_QT* macros to ensure that |
|||
dnl input variables are set correctly. |
|||
dnl CAUTION: Do not use this inside of a conditional. |
|||
AC_DEFUN([BITCOIN_QT_INIT],[ |
|||
dnl enable qt support |
|||
AC_ARG_WITH([gui], |
|||
[AS_HELP_STRING([--with-gui@<:@=no|qt4|qt5|auto@:>@], |
|||
[build bitcoin-qt GUI (default=auto, qt4 tried first)])], |
|||
[ |
|||
bitcoin_qt_want_version=$withval |
|||
if test x$bitcoin_qt_want_version = xyes; then |
|||
bitcoin_qt_force=yes |
|||
bitcoin_qt_want_version=auto |
|||
fi |
|||
], |
|||
[bitcoin_qt_want_version=auto]) |
|||
|
|||
AC_ARG_WITH([qt-incdir],[AS_HELP_STRING([--with-qt-incdir=INC_DIR],[specify qt include path (overridden by pkgconfig)])], [qt_include_path=$withval], []) |
|||
AC_ARG_WITH([qt-libdir],[AS_HELP_STRING([--with-qt-libdir=LIB_DIR],[specify qt lib path (overridden by pkgconfig)])], [qt_lib_path=$withval], []) |
|||
AC_ARG_WITH([qt-plugindir],[AS_HELP_STRING([--with-qt-plugindir=PLUGIN_DIR],[specify qt plugin path (overridden by pkgconfig)])], [qt_plugin_path=$withval], []) |
|||
AC_ARG_WITH([qt-translationdir],[AS_HELP_STRING([--with-qt-translationdir=PLUGIN_DIR],[specify qt translation path (overridden by pkgconfig)])], [qt_translation_path=$withval], []) |
|||
AC_ARG_WITH([qt-bindir],[AS_HELP_STRING([--with-qt-bindir=BIN_DIR],[specify qt bin path])], [qt_bin_path=$withval], []) |
|||
|
|||
AC_ARG_WITH([qtdbus], |
|||
[AS_HELP_STRING([--with-qtdbus], |
|||
[enable DBus support (default is yes if qt is enabled and QtDBus is found)])], |
|||
[use_dbus=$withval], |
|||
[use_dbus=auto]) |
|||
|
|||
AC_SUBST(QT_TRANSLATION_DIR,$qt_translation_path) |
|||
]) |
|||
|
|||
dnl Find the appropriate version of Qt libraries and includes. |
|||
dnl Inputs: $1: Whether or not pkg-config should be used. yes|no. Default: yes. |
|||
dnl Inputs: $2: If $1 is "yes" and --with-gui=auto, which qt version should be |
|||
dnl tried first. |
|||
dnl Outputs: See _BITCOIN_QT_FIND_LIBS_* |
|||
dnl Outputs: Sets variables for all qt-related tools. |
|||
dnl Outputs: bitcoin_enable_qt, bitcoin_enable_qt_dbus, bitcoin_enable_qt_test |
|||
AC_DEFUN([BITCOIN_QT_CONFIGURE],[ |
|||
use_pkgconfig=$1 |
|||
|
|||
if test x$use_pkgconfig = x; then |
|||
use_pkgconfig=yes |
|||
fi |
|||
|
|||
if test x$use_pkgconfig = xyes; then |
|||
BITCOIN_QT_CHECK([_BITCOIN_QT_FIND_LIBS_WITH_PKGCONFIG([$2])]) |
|||
else |
|||
BITCOIN_QT_CHECK([_BITCOIN_QT_FIND_LIBS_WITHOUT_PKGCONFIG]) |
|||
fi |
|||
|
|||
dnl This is ugly and complicated. Yuck. Works as follows: |
|||
dnl We can't discern whether Qt4 builds are static or not. For Qt5, we can |
|||
dnl check a header to find out. When Qt is built statically, some plugins must |
|||
dnl be linked into the final binary as well. These plugins have changed between |
|||
dnl Qt4 and Qt5. With Qt5, languages moved into core and the WindowsIntegration |
|||
dnl plugin was added. Since we can't tell if Qt4 is static or not, it is |
|||
dnl assumed for windows builds. |
|||
dnl _BITCOIN_QT_CHECK_STATIC_PLUGINS does a quick link-check and appends the |
|||
dnl results to QT_LIBS. |
|||
BITCOIN_QT_CHECK([ |
|||
TEMP_CPPFLAGS=$CPPFLAGS |
|||
CPPFLAGS="$QT_INCLUDES $CPPFLAGS" |
|||
if test x$bitcoin_qt_got_major_vers = x5; then |
|||
_BITCOIN_QT_IS_STATIC |
|||
if test x$bitcoin_cv_static_qt = xyes; then |
|||
AC_DEFINE(QT_STATICPLUGIN, 1, [Define this symbol if qt plugins are static]) |
|||
if test x$qt_plugin_path != x; then |
|||
QT_LIBS="$QT_LIBS -L$qt_plugin_path/platforms" |
|||
fi |
|||
if test x$use_pkgconfig = xyes; then |
|||
PKG_CHECK_MODULES([QTPLATFORM], [Qt5PlatformSupport], [QT_LIBS="$QTPLATFORM_LIBS $QT_LIBS"]) |
|||
fi |
|||
AC_CACHE_CHECK(for Qt < 5.4, bitcoin_cv_need_acc_widget,[AC_COMPILE_IFELSE([AC_LANG_PROGRAM( |
|||
[[#include <QtCore>]],[[ |
|||
#if QT_VERSION >= 0x050400 |
|||
choke; |
|||
#endif |
|||
]])], |
|||
[bitcoin_cv_need_acc_widget=yes], |
|||
[bitcoin_cv_need_acc_widget=no]) |
|||
]) |
|||
if test "x$bitcoin_cv_need_acc_widget" = "xyes"; then |
|||
if test x$qt_plugin_path != x; then |
|||
QT_LIBS="$QT_LIBS -L$qt_plugin_path/accessible" |
|||
fi |
|||
_BITCOIN_QT_CHECK_STATIC_PLUGINS([Q_IMPORT_PLUGIN(AccessibleFactory)], [-lqtaccessiblewidgets]) |
|||
fi |
|||
if test x$TARGET_OS = xwindows; then |
|||
_BITCOIN_QT_CHECK_STATIC_PLUGINS([Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin)],[-lqwindows]) |
|||
AC_DEFINE(QT_QPA_PLATFORM_WINDOWS, 1, [Define this symbol if the qt platform is windows]) |
|||
elif test x$TARGET_OS = xlinux; then |
|||
PKG_CHECK_MODULES([X11XCB], [x11-xcb], [QT_LIBS="$X11XCB_LIBS $QT_LIBS"]) |
|||
if ${PKG_CONFIG} --exists "Qt5Core >= 5.5" 2>/dev/null; then |
|||
PKG_CHECK_MODULES([QTXCBQPA], [Qt5XcbQpa], [QT_LIBS="$QTXCBQPA_LIBS $QT_LIBS"]) |
|||
fi |
|||
_BITCOIN_QT_CHECK_STATIC_PLUGINS([Q_IMPORT_PLUGIN(QXcbIntegrationPlugin)],[-lqxcb -lxcb-static]) |
|||
AC_DEFINE(QT_QPA_PLATFORM_XCB, 1, [Define this symbol if the qt platform is xcb]) |
|||
elif test x$TARGET_OS = xdarwin; then |
|||
if test x$use_pkgconfig = xyes; then |
|||
PKG_CHECK_MODULES([QTPRINT], [Qt5PrintSupport], [QT_LIBS="$QTPRINT_LIBS $QT_LIBS"]) |
|||
fi |
|||
AX_CHECK_LINK_FLAG([[-framework IOKit]],[QT_LIBS="$QT_LIBS -framework IOKit"],[AC_MSG_ERROR(could not iokit framework)]) |
|||
_BITCOIN_QT_CHECK_STATIC_PLUGINS([Q_IMPORT_PLUGIN(QCocoaIntegrationPlugin)],[-lqcocoa]) |
|||
AC_DEFINE(QT_QPA_PLATFORM_COCOA, 1, [Define this symbol if the qt platform is cocoa]) |
|||
fi |
|||
fi |
|||
else |
|||
if test x$TARGET_OS = xwindows; then |
|||
AC_DEFINE(QT_STATICPLUGIN, 1, [Define this symbol if qt plugins are static]) |
|||
if test x$qt_plugin_path != x; then |
|||
QT_LIBS="$QT_LIBS -L$qt_plugin_path/accessible" |
|||
QT_LIBS="$QT_LIBS -L$qt_plugin_path/codecs" |
|||
fi |
|||
_BITCOIN_QT_CHECK_STATIC_PLUGINS([ |
|||
Q_IMPORT_PLUGIN(qcncodecs) |
|||
Q_IMPORT_PLUGIN(qjpcodecs) |
|||
Q_IMPORT_PLUGIN(qtwcodecs) |
|||
Q_IMPORT_PLUGIN(qkrcodecs) |
|||
Q_IMPORT_PLUGIN(AccessibleFactory)], |
|||
[-lqcncodecs -lqjpcodecs -lqtwcodecs -lqkrcodecs -lqtaccessiblewidgets]) |
|||
fi |
|||
fi |
|||
CPPFLAGS=$TEMP_CPPFLAGS |
|||
]) |
|||
|
|||
if test x$use_pkgconfig$qt_bin_path = xyes; then |
|||
if test x$bitcoin_qt_got_major_vers = x5; then |
|||
qt_bin_path="`$PKG_CONFIG --variable=host_bins Qt5Core 2>/dev/null`" |
|||
fi |
|||
fi |
|||
|
|||
BITCOIN_QT_PATH_PROGS([MOC], [moc-qt${bitcoin_qt_got_major_vers} moc${bitcoin_qt_got_major_vers} moc], $qt_bin_path) |
|||
BITCOIN_QT_PATH_PROGS([UIC], [uic-qt${bitcoin_qt_got_major_vers} uic${bitcoin_qt_got_major_vers} uic], $qt_bin_path) |
|||
BITCOIN_QT_PATH_PROGS([RCC], [rcc-qt${bitcoin_qt_got_major_vers} rcc${bitcoin_qt_got_major_vers} rcc], $qt_bin_path) |
|||
BITCOIN_QT_PATH_PROGS([LRELEASE], [lrelease-qt${bitcoin_qt_got_major_vers} lrelease${bitcoin_qt_got_major_vers} lrelease], $qt_bin_path) |
|||
BITCOIN_QT_PATH_PROGS([LUPDATE], [lupdate-qt${bitcoin_qt_got_major_vers} lupdate${bitcoin_qt_got_major_vers} lupdate],$qt_bin_path, yes) |
|||
|
|||
MOC_DEFS='-DHAVE_CONFIG_H -I$(srcdir)' |
|||
case $host in |
|||
*darwin*) |
|||
BITCOIN_QT_CHECK([ |
|||
MOC_DEFS="${MOC_DEFS} -DQ_OS_MAC" |
|||
base_frameworks="-framework Foundation -framework ApplicationServices -framework AppKit" |
|||
AX_CHECK_LINK_FLAG([[$base_frameworks]],[QT_LIBS="$QT_LIBS $base_frameworks"],[AC_MSG_ERROR(could not find base frameworks)]) |
|||
]) |
|||
;; |
|||
*mingw*) |
|||
BITCOIN_QT_CHECK([ |
|||
AX_CHECK_LINK_FLAG([[-mwindows]],[QT_LDFLAGS="$QT_LDFLAGS -mwindows"],[AC_MSG_WARN(-mwindows linker support not detected)]) |
|||
]) |
|||
esac |
|||
|
|||
|
|||
dnl enable qt support |
|||
AC_MSG_CHECKING(whether to build Bitcoin Core GUI) |
|||
BITCOIN_QT_CHECK([ |
|||
bitcoin_enable_qt=yes |
|||
bitcoin_enable_qt_test=yes |
|||
if test x$have_qt_test = xno; then |
|||
bitcoin_enable_qt_test=no |
|||
fi |
|||
bitcoin_enable_qt_dbus=no |
|||
if test x$use_dbus != xno && test x$have_qt_dbus = xyes; then |
|||
bitcoin_enable_qt_dbus=yes |
|||
fi |
|||
if test x$use_dbus = xyes && test x$have_qt_dbus = xno; then |
|||
AC_MSG_ERROR("libQtDBus not found. Install libQtDBus or remove --with-qtdbus.") |
|||
fi |
|||
if test x$LUPDATE = x; then |
|||
AC_MSG_WARN("lupdate is required to update qt translations") |
|||
fi |
|||
],[ |
|||
bitcoin_enable_qt=no |
|||
]) |
|||
AC_MSG_RESULT([$bitcoin_enable_qt (Qt${bitcoin_qt_got_major_vers})]) |
|||
|
|||
AC_SUBST(QT_INCLUDES) |
|||
AC_SUBST(QT_LIBS) |
|||
AC_SUBST(QT_LDFLAGS) |
|||
AC_SUBST(QT_DBUS_INCLUDES) |
|||
AC_SUBST(QT_DBUS_LIBS) |
|||
AC_SUBST(QT_TEST_INCLUDES) |
|||
AC_SUBST(QT_TEST_LIBS) |
|||
AC_SUBST(QT_SELECT, qt${bitcoin_qt_got_major_vers}) |
|||
AC_SUBST(MOC_DEFS) |
|||
]) |
|||
|
|||
dnl All macros below are internal and should _not_ be used from the main |
|||
dnl configure.ac. |
|||
dnl ---- |
|||
|
|||
dnl Internal. Check if the included version of Qt is Qt5. |
|||
dnl Requires: INCLUDES must be populated as necessary. |
|||
dnl Output: bitcoin_cv_qt5=yes|no |
|||
AC_DEFUN([_BITCOIN_QT_CHECK_QT5],[ |
|||
AC_CACHE_CHECK(for Qt 5, bitcoin_cv_qt5,[ |
|||
AC_COMPILE_IFELSE([AC_LANG_PROGRAM( |
|||
[[#include <QtCore>]], |
|||
[[ |
|||
#if QT_VERSION < 0x050000 |
|||
choke me |
|||
#else |
|||
return 0; |
|||
#endif |
|||
]])], |
|||
[bitcoin_cv_qt5=yes], |
|||
[bitcoin_cv_qt5=no]) |
|||
])]) |
|||
|
|||
dnl Internal. Check if the linked version of Qt was built as static libs. |
|||
dnl Requires: Qt5. This check cannot determine if Qt4 is static. |
|||
dnl Requires: INCLUDES and LIBS must be populated as necessary. |
|||
dnl Output: bitcoin_cv_static_qt=yes|no |
|||
dnl Output: Defines QT_STATICPLUGIN if plugins are static. |
|||
AC_DEFUN([_BITCOIN_QT_IS_STATIC],[ |
|||
AC_CACHE_CHECK(for static Qt, bitcoin_cv_static_qt,[ |
|||
AC_COMPILE_IFELSE([AC_LANG_PROGRAM( |
|||
[[#include <QtCore>]], |
|||
[[ |
|||
#if defined(QT_STATIC) |
|||
return 0; |
|||
#else |
|||
choke me |
|||
#endif |
|||
]])], |
|||
[bitcoin_cv_static_qt=yes], |
|||
[bitcoin_cv_static_qt=no]) |
|||
]) |
|||
if test xbitcoin_cv_static_qt = xyes; then |
|||
AC_DEFINE(QT_STATICPLUGIN, 1, [Define this symbol for static Qt plugins]) |
|||
fi |
|||
]) |
|||
|
|||
dnl Internal. Check if the link-requirements for static plugins are met. |
|||
dnl Requires: INCLUDES and LIBS must be populated as necessary. |
|||
dnl Inputs: $1: A series of Q_IMPORT_PLUGIN(). |
|||
dnl Inputs: $2: The libraries that resolve $1. |
|||
dnl Output: QT_LIBS is prepended or configure exits. |
|||
AC_DEFUN([_BITCOIN_QT_CHECK_STATIC_PLUGINS],[ |
|||
AC_MSG_CHECKING(for static Qt plugins: $2) |
|||
CHECK_STATIC_PLUGINS_TEMP_LIBS="$LIBS" |
|||
LIBS="$2 $QT_LIBS $LIBS" |
|||
AC_LINK_IFELSE([AC_LANG_PROGRAM([[ |
|||
#define QT_STATICPLUGIN |
|||
#include <QtPlugin> |
|||
$1]], |
|||
[[return 0;]])], |
|||
[AC_MSG_RESULT(yes); QT_LIBS="$2 $QT_LIBS"], |
|||
[AC_MSG_RESULT(no); BITCOIN_QT_FAIL(Could not resolve: $2)]) |
|||
LIBS="$CHECK_STATIC_PLUGINS_TEMP_LIBS" |
|||
]) |
|||
|
|||
dnl Internal. Find Qt libraries using pkg-config. |
|||
dnl Inputs: bitcoin_qt_want_version (from --with-gui=). The version to check |
|||
dnl first. |
|||
dnl Inputs: $1: If bitcoin_qt_want_version is "auto", check for this version |
|||
dnl first. |
|||
dnl Outputs: All necessary QT_* variables are set. |
|||
dnl Outputs: bitcoin_qt_got_major_vers is set to "4" or "5". |
|||
dnl Outputs: have_qt_test and have_qt_dbus are set (if applicable) to yes|no. |
|||
AC_DEFUN([_BITCOIN_QT_FIND_LIBS_WITH_PKGCONFIG],[ |
|||
m4_ifdef([PKG_CHECK_MODULES],[ |
|||
auto_priority_version=$1 |
|||
if test x$auto_priority_version = x; then |
|||
auto_priority_version=qt5 |
|||
fi |
|||
if test x$bitcoin_qt_want_version = xqt5 || ( test x$bitcoin_qt_want_version = xauto && test x$auto_priority_version = xqt5 ); then |
|||
QT_LIB_PREFIX=Qt5 |
|||
bitcoin_qt_got_major_vers=5 |
|||
else |
|||
QT_LIB_PREFIX=Qt |
|||
bitcoin_qt_got_major_vers=4 |
|||
fi |
|||
qt5_modules="Qt5Core Qt5Gui Qt5Network Qt5Widgets" |
|||
qt4_modules="QtCore QtGui QtNetwork" |
|||
BITCOIN_QT_CHECK([ |
|||
if test x$bitcoin_qt_want_version = xqt5 || ( test x$bitcoin_qt_want_version = xauto && test x$auto_priority_version = xqt5 ); then |
|||
PKG_CHECK_MODULES([QT], [$qt5_modules], [QT_INCLUDES="$QT_CFLAGS"; have_qt=yes],[have_qt=no]) |
|||
elif test x$bitcoin_qt_want_version = xqt4 || ( test x$bitcoin_qt_want_version = xauto && test x$auto_priority_version = xqt4 ); then |
|||
PKG_CHECK_MODULES([QT], [$qt4_modules], [QT_INCLUDES="$QT_CFLAGS"; have_qt=yes], [have_qt=no]) |
|||
fi |
|||
|
|||
dnl qt version is set to 'auto' and the preferred version wasn't found. Now try the other. |
|||
if test x$have_qt = xno && test x$bitcoin_qt_want_version = xauto; then |
|||
if test x$auto_priority_version = x$qt5; then |
|||
PKG_CHECK_MODULES([QT], [$qt4_modules], [QT_INCLUDES="$QT_CFLAGS"; have_qt=yes; QT_LIB_PREFIX=Qt; bitcoin_qt_got_major_vers=4], [have_qt=no]) |
|||
else |
|||
PKG_CHECK_MODULES([QT], [$qt5_modules], [QT_INCLUDES="$QT_CFLAGS"; have_qt=yes; QT_LIB_PREFIX=Qt5; bitcoin_qt_got_major_vers=5], [have_qt=no]) |
|||
fi |
|||
fi |
|||
if test x$have_qt != xyes; then |
|||
have_qt=no |
|||
BITCOIN_QT_FAIL([Qt dependencies not found]) |
|||
fi |
|||
]) |
|||
BITCOIN_QT_CHECK([ |
|||
PKG_CHECK_MODULES([QT_TEST], [${QT_LIB_PREFIX}Test], [QT_TEST_INCLUDES="$QT_TEST_CFLAGS"; have_qt_test=yes], [have_qt_test=no]) |
|||
if test x$use_dbus != xno; then |
|||
PKG_CHECK_MODULES([QT_DBUS], [${QT_LIB_PREFIX}DBus], [QT_DBUS_INCLUDES="$QT_DBUS_CFLAGS"; have_qt_dbus=yes], [have_qt_dbus=no]) |
|||
fi |
|||
]) |
|||
]) |
|||
true; dnl |
|||
]) |
|||
|
|||
dnl Internal. Find Qt libraries without using pkg-config. Version is deduced |
|||
dnl from the discovered headers. |
|||
dnl Inputs: bitcoin_qt_want_version (from --with-gui=). The version to use. |
|||
dnl If "auto", the version will be discovered by _BITCOIN_QT_CHECK_QT5. |
|||
dnl Outputs: All necessary QT_* variables are set. |
|||
dnl Outputs: bitcoin_qt_got_major_vers is set to "4" or "5". |
|||
dnl Outputs: have_qt_test and have_qt_dbus are set (if applicable) to yes|no. |
|||
AC_DEFUN([_BITCOIN_QT_FIND_LIBS_WITHOUT_PKGCONFIG],[ |
|||
TEMP_CPPFLAGS="$CPPFLAGS" |
|||
TEMP_LIBS="$LIBS" |
|||
BITCOIN_QT_CHECK([ |
|||
if test x$qt_include_path != x; then |
|||
QT_INCLUDES="-I$qt_include_path -I$qt_include_path/QtCore -I$qt_include_path/QtGui -I$qt_include_path/QtWidgets -I$qt_include_path/QtNetwork -I$qt_include_path/QtTest -I$qt_include_path/QtDBus" |
|||
CPPFLAGS="$QT_INCLUDES $CPPFLAGS" |
|||
fi |
|||
]) |
|||
|
|||
BITCOIN_QT_CHECK([AC_CHECK_HEADER([QtPlugin],,BITCOIN_QT_FAIL(QtCore headers missing))]) |
|||
BITCOIN_QT_CHECK([AC_CHECK_HEADER([QApplication],, BITCOIN_QT_FAIL(QtGui headers missing))]) |
|||
BITCOIN_QT_CHECK([AC_CHECK_HEADER([QLocalSocket],, BITCOIN_QT_FAIL(QtNetwork headers missing))]) |
|||
|
|||
BITCOIN_QT_CHECK([ |
|||
if test x$bitcoin_qt_want_version = xauto; then |
|||
_BITCOIN_QT_CHECK_QT5 |
|||
fi |
|||
if test x$bitcoin_cv_qt5 = xyes || test x$bitcoin_qt_want_version = xqt5; then |
|||
QT_LIB_PREFIX=Qt5 |
|||
bitcoin_qt_got_major_vers=5 |
|||
else |
|||
QT_LIB_PREFIX=Qt |
|||
bitcoin_qt_got_major_vers=4 |
|||
fi |
|||
]) |
|||
|
|||
BITCOIN_QT_CHECK([ |
|||
LIBS= |
|||
if test x$qt_lib_path != x; then |
|||
LIBS="$LIBS -L$qt_lib_path" |
|||
fi |
|||
|
|||
if test x$TARGET_OS = xwindows; then |
|||
AC_CHECK_LIB([imm32], [main],, BITCOIN_QT_FAIL(libimm32 not found)) |
|||
fi |
|||
]) |
|||
|
|||
BITCOIN_QT_CHECK(AC_CHECK_LIB([z] ,[main],,AC_MSG_WARN([zlib not found. Assuming qt has it built-in]))) |
|||
BITCOIN_QT_CHECK(AC_CHECK_LIB([png] ,[main],,AC_MSG_WARN([libpng not found. Assuming qt has it built-in]))) |
|||
BITCOIN_QT_CHECK(AC_CHECK_LIB([jpeg] ,[main],,AC_MSG_WARN([libjpeg not found. Assuming qt has it built-in]))) |
|||
BITCOIN_QT_CHECK(AC_SEARCH_LIBS([pcre16_exec], [qtpcre pcre16],,AC_MSG_WARN([libpcre16 not found. Assuming qt has it built-in]))) |
|||
BITCOIN_QT_CHECK(AC_SEARCH_LIBS([hb_ot_tags_from_script] ,[qtharfbuzzng harfbuzz],,AC_MSG_WARN([libharfbuzz not found. Assuming qt has it built-in or support is disabled]))) |
|||
BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}Core] ,[main],,BITCOIN_QT_FAIL(lib$QT_LIB_PREFIXCore not found))) |
|||
BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}Gui] ,[main],,BITCOIN_QT_FAIL(lib$QT_LIB_PREFIXGui not found))) |
|||
BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}Network],[main],,BITCOIN_QT_FAIL(lib$QT_LIB_PREFIXNetwork not found))) |
|||
if test x$bitcoin_qt_got_major_vers = x5; then |
|||
BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}Widgets],[main],,BITCOIN_QT_FAIL(lib$QT_LIB_PREFIXWidgets not found))) |
|||
fi |
|||
QT_LIBS="$LIBS" |
|||
LIBS="$TEMP_LIBS" |
|||
|
|||
BITCOIN_QT_CHECK([ |
|||
LIBS= |
|||
if test x$qt_lib_path != x; then |
|||
LIBS="-L$qt_lib_path" |
|||
fi |
|||
AC_CHECK_LIB([${QT_LIB_PREFIX}Test], [main],, have_qt_test=no) |
|||
AC_CHECK_HEADER([QTest],, have_qt_test=no) |
|||
QT_TEST_LIBS="$LIBS" |
|||
if test x$use_dbus != xno; then |
|||
LIBS= |
|||
if test x$qt_lib_path != x; then |
|||
LIBS="-L$qt_lib_path" |
|||
fi |
|||
AC_CHECK_LIB([${QT_LIB_PREFIX}DBus], [main],, have_qt_dbus=no) |
|||
AC_CHECK_HEADER([QtDBus],, have_qt_dbus=no) |
|||
QT_DBUS_LIBS="$LIBS" |
|||
fi |
|||
]) |
|||
CPPFLAGS="$TEMP_CPPFLAGS" |
|||
LIBS="$TEMP_LIBS" |
|||
]) |
|||
|
@ -1,883 +0,0 @@ |
|||
#!/usr/bin/env python |
|||
|
|||
# |
|||
# Copyright (C) 2011 Patrick "p2k" Schneider <me@p2k-network.org> |
|||
# |
|||
# This program is free software: you can redistribute it and/or modify |
|||
# it under the terms of the GNU General Public License as published by |
|||
# the Free Software Foundation, either version 3 of the License, or |
|||
# (at your option) any later version. |
|||
# |
|||
# This program 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 General Public License for more details. |
|||
# |
|||
# You should have received a copy of the GNU General Public License |
|||
# along with this program. If not, see <http://www.gnu.org/licenses/>. |
|||
# |
|||
|
|||
import subprocess, sys, re, os, shutil, stat, os.path, time |
|||
from string import Template |
|||
from argparse import ArgumentParser |
|||
|
|||
# This is ported from the original macdeployqt with modifications |
|||
|
|||
class FrameworkInfo(object): |
|||
def __init__(self): |
|||
self.frameworkDirectory = "" |
|||
self.frameworkName = "" |
|||
self.frameworkPath = "" |
|||
self.binaryDirectory = "" |
|||
self.binaryName = "" |
|||
self.binaryPath = "" |
|||
self.version = "" |
|||
self.installName = "" |
|||
self.deployedInstallName = "" |
|||
self.sourceFilePath = "" |
|||
self.destinationDirectory = "" |
|||
self.sourceResourcesDirectory = "" |
|||
self.sourceVersionContentsDirectory = "" |
|||
self.sourceContentsDirectory = "" |
|||
self.destinationResourcesDirectory = "" |
|||
self.destinationVersionContentsDirectory = "" |
|||
|
|||
def __eq__(self, other): |
|||
if self.__class__ == other.__class__: |
|||
return self.__dict__ == other.__dict__ |
|||
else: |
|||
return False |
|||
|
|||
def __str__(self): |
|||
return """ Framework name: %s |
|||
Framework directory: %s |
|||
Framework path: %s |
|||
Binary name: %s |
|||
Binary directory: %s |
|||
Binary path: %s |
|||
Version: %s |
|||
Install name: %s |
|||
Deployed install name: %s |
|||
Source file Path: %s |
|||
Deployed Directory (relative to bundle): %s |
|||
""" % (self.frameworkName, |
|||
self.frameworkDirectory, |
|||
self.frameworkPath, |
|||
self.binaryName, |
|||
self.binaryDirectory, |
|||
self.binaryPath, |
|||
self.version, |
|||
self.installName, |
|||
self.deployedInstallName, |
|||
self.sourceFilePath, |
|||
self.destinationDirectory) |
|||
|
|||
def isDylib(self): |
|||
return self.frameworkName.endswith(".dylib") |
|||
|
|||
def isQtFramework(self): |
|||
if self.isDylib(): |
|||
return self.frameworkName.startswith("libQt") |
|||
else: |
|||
return self.frameworkName.startswith("Qt") |
|||
|
|||
reOLine = re.compile(r'^(.+) \(compatibility version [0-9.]+, current version [0-9.]+\)$') |
|||
bundleFrameworkDirectory = "Contents/Frameworks" |
|||
bundleBinaryDirectory = "Contents/MacOS" |
|||
|
|||
@classmethod |
|||
def fromOtoolLibraryLine(cls, line): |
|||
# Note: line must be trimmed |
|||
if line == "": |
|||
return None |
|||
|
|||
# Don't deploy system libraries (exception for libQtuitools and libQtlucene). |
|||
if line.startswith("/System/Library/") or line.startswith("@executable_path") or (line.startswith("/usr/lib/") and "libQt" not in line): |
|||
return None |
|||
|
|||
m = cls.reOLine.match(line) |
|||
if m is None: |
|||
raise RuntimeError("otool line could not be parsed: " + line) |
|||
|
|||
path = m.group(1) |
|||
|
|||
info = cls() |
|||
info.sourceFilePath = path |
|||
info.installName = path |
|||
|
|||
if path.endswith(".dylib"): |
|||
dirname, filename = os.path.split(path) |
|||
info.frameworkName = filename |
|||
info.frameworkDirectory = dirname |
|||
info.frameworkPath = path |
|||
|
|||
info.binaryDirectory = dirname |
|||
info.binaryName = filename |
|||
info.binaryPath = path |
|||
info.version = "-" |
|||
|
|||
info.installName = path |
|||
info.deployedInstallName = "@executable_path/../Frameworks/" + info.binaryName |
|||
info.sourceFilePath = path |
|||
info.destinationDirectory = cls.bundleFrameworkDirectory |
|||
else: |
|||
parts = path.split("/") |
|||
i = 0 |
|||
# Search for the .framework directory |
|||
for part in parts: |
|||
if part.endswith(".framework"): |
|||
break |
|||
i += 1 |
|||
if i == len(parts): |
|||
raise RuntimeError("Could not find .framework or .dylib in otool line: " + line) |
|||
|
|||
info.frameworkName = parts[i] |
|||
info.frameworkDirectory = "/".join(parts[:i]) |
|||
info.frameworkPath = os.path.join(info.frameworkDirectory, info.frameworkName) |
|||
|
|||
info.binaryName = parts[i+3] |
|||
info.binaryDirectory = "/".join(parts[i+1:i+3]) |
|||
info.binaryPath = os.path.join(info.binaryDirectory, info.binaryName) |
|||
info.version = parts[i+2] |
|||
|
|||
info.deployedInstallName = "@executable_path/../Frameworks/" + os.path.join(info.frameworkName, info.binaryPath) |
|||
info.destinationDirectory = os.path.join(cls.bundleFrameworkDirectory, info.frameworkName, info.binaryDirectory) |
|||
|
|||
info.sourceResourcesDirectory = os.path.join(info.frameworkPath, "Resources") |
|||
info.sourceContentsDirectory = os.path.join(info.frameworkPath, "Contents") |
|||
info.sourceVersionContentsDirectory = os.path.join(info.frameworkPath, "Versions", info.version, "Contents") |
|||
info.destinationResourcesDirectory = os.path.join(cls.bundleFrameworkDirectory, info.frameworkName, "Resources") |
|||
info.destinationContentsDirectory = os.path.join(cls.bundleFrameworkDirectory, info.frameworkName, "Contents") |
|||
info.destinationVersionContentsDirectory = os.path.join(cls.bundleFrameworkDirectory, info.frameworkName, "Versions", info.version, "Contents") |
|||
|
|||
return info |
|||
|
|||
class ApplicationBundleInfo(object): |
|||
def __init__(self, path): |
|||
self.path = path |
|||
appName = "Bitcoin-Qt" |
|||
self.binaryPath = os.path.join(path, "Contents", "MacOS", appName) |
|||
if not os.path.exists(self.binaryPath): |
|||
raise RuntimeError("Could not find bundle binary for " + path) |
|||
self.resourcesPath = os.path.join(path, "Contents", "Resources") |
|||
self.pluginPath = os.path.join(path, "Contents", "PlugIns") |
|||
|
|||
class DeploymentInfo(object): |
|||
def __init__(self): |
|||
self.qtPath = None |
|||
self.pluginPath = None |
|||
self.deployedFrameworks = [] |
|||
|
|||
def detectQtPath(self, frameworkDirectory): |
|||
parentDir = os.path.dirname(frameworkDirectory) |
|||
if os.path.exists(os.path.join(parentDir, "translations")): |
|||
# Classic layout, e.g. "/usr/local/Trolltech/Qt-4.x.x" |
|||
self.qtPath = parentDir |
|||
elif os.path.exists(os.path.join(parentDir, "share", "qt4", "translations")): |
|||
# MacPorts layout, e.g. "/opt/local/share/qt4" |
|||
self.qtPath = os.path.join(parentDir, "share", "qt4") |
|||
elif os.path.exists(os.path.join(os.path.dirname(parentDir), "share", "qt4", "translations")): |
|||
# Newer Macports layout |
|||
self.qtPath = os.path.join(os.path.dirname(parentDir), "share", "qt4") |
|||
else: |
|||
self.qtPath = os.getenv("QTDIR", None) |
|||
|
|||
if self.qtPath is not None: |
|||
pluginPath = os.path.join(self.qtPath, "plugins") |
|||
if os.path.exists(pluginPath): |
|||
self.pluginPath = pluginPath |
|||
|
|||
def usesFramework(self, name): |
|||
nameDot = "%s." % name |
|||
libNameDot = "lib%s." % name |
|||
for framework in self.deployedFrameworks: |
|||
if framework.endswith(".framework"): |
|||
if framework.startswith(nameDot): |
|||
return True |
|||
elif framework.endswith(".dylib"): |
|||
if framework.startswith(libNameDot): |
|||
return True |
|||
return False |
|||
|
|||
def getFrameworks(binaryPath, verbose): |
|||
if verbose >= 3: |
|||
print "Inspecting with otool: " + binaryPath |
|||
otoolbin=os.getenv("OTOOL", "otool") |
|||
otool = subprocess.Popen([otoolbin, "-L", binaryPath], stdout=subprocess.PIPE, stderr=subprocess.PIPE) |
|||
o_stdout, o_stderr = otool.communicate() |
|||
if otool.returncode != 0: |
|||
if verbose >= 1: |
|||
sys.stderr.write(o_stderr) |
|||
sys.stderr.flush() |
|||
raise RuntimeError("otool failed with return code %d" % otool.returncode) |
|||
|
|||
otoolLines = o_stdout.split("\n") |
|||
otoolLines.pop(0) # First line is the inspected binary |
|||
if ".framework" in binaryPath or binaryPath.endswith(".dylib"): |
|||
otoolLines.pop(0) # Frameworks and dylibs list themselves as a dependency. |
|||
|
|||
libraries = [] |
|||
for line in otoolLines: |
|||
line = line.replace("@loader_path", os.path.dirname(binaryPath)) |
|||
info = FrameworkInfo.fromOtoolLibraryLine(line.strip()) |
|||
if info is not None: |
|||
if verbose >= 3: |
|||
print "Found framework:" |
|||
print info |
|||
libraries.append(info) |
|||
|
|||
return libraries |
|||
|
|||
def runInstallNameTool(action, *args): |
|||
installnametoolbin=os.getenv("INSTALLNAMETOOL", "install_name_tool") |
|||
subprocess.check_call([installnametoolbin, "-"+action] + list(args)) |
|||
|
|||
def changeInstallName(oldName, newName, binaryPath, verbose): |
|||
if verbose >= 3: |
|||
print "Using install_name_tool:" |
|||
print " in", binaryPath |
|||
print " change reference", oldName |
|||
print " to", newName |
|||
runInstallNameTool("change", oldName, newName, binaryPath) |
|||
|
|||
def changeIdentification(id, binaryPath, verbose): |
|||
if verbose >= 3: |
|||
print "Using install_name_tool:" |
|||
print " change identification in", binaryPath |
|||
print " to", id |
|||
runInstallNameTool("id", id, binaryPath) |
|||
|
|||
def runStrip(binaryPath, verbose): |
|||
stripbin=os.getenv("STRIP", "strip") |
|||
if verbose >= 3: |
|||
print "Using strip:" |
|||
print " stripped", binaryPath |
|||
subprocess.check_call([stripbin, "-x", binaryPath]) |
|||
|
|||
def copyFramework(framework, path, verbose): |
|||
if framework.sourceFilePath.startswith("Qt"): |
|||
#standard place for Nokia Qt installer's frameworks |
|||
fromPath = "/Library/Frameworks/" + framework.sourceFilePath |
|||
else: |
|||
fromPath = framework.sourceFilePath |
|||
toDir = os.path.join(path, framework.destinationDirectory) |
|||
toPath = os.path.join(toDir, framework.binaryName) |
|||
|
|||
if not os.path.exists(fromPath): |
|||
raise RuntimeError("No file at " + fromPath) |
|||
|
|||
if os.path.exists(toPath): |
|||
return None # Already there |
|||
|
|||
if not os.path.exists(toDir): |
|||
os.makedirs(toDir) |
|||
|
|||
shutil.copy2(fromPath, toPath) |
|||
if verbose >= 3: |
|||
print "Copied:", fromPath |
|||
print " to:", toPath |
|||
|
|||
permissions = os.stat(toPath) |
|||
if not permissions.st_mode & stat.S_IWRITE: |
|||
os.chmod(toPath, permissions.st_mode | stat.S_IWRITE) |
|||
|
|||
if not framework.isDylib(): # Copy resources for real frameworks |
|||
|
|||
linkfrom = os.path.join(path, "Contents","Frameworks", framework.frameworkName, "Versions", "Current") |
|||
linkto = framework.version |
|||
if not os.path.exists(linkfrom): |
|||
os.symlink(linkto, linkfrom) |
|||
if verbose >= 2: |
|||
print "Linked:", linkfrom, "->", linkto |
|||
fromResourcesDir = framework.sourceResourcesDirectory |
|||
if os.path.exists(fromResourcesDir): |
|||
toResourcesDir = os.path.join(path, framework.destinationResourcesDirectory) |
|||
shutil.copytree(fromResourcesDir, toResourcesDir, symlinks=True) |
|||
if verbose >= 3: |
|||
print "Copied resources:", fromResourcesDir |
|||
print " to:", toResourcesDir |
|||
fromContentsDir = framework.sourceVersionContentsDirectory |
|||
if not os.path.exists(fromContentsDir): |
|||
fromContentsDir = framework.sourceContentsDirectory |
|||
if os.path.exists(fromContentsDir): |
|||
toContentsDir = os.path.join(path, framework.destinationVersionContentsDirectory) |
|||
shutil.copytree(fromContentsDir, toContentsDir, symlinks=True) |
|||
contentslinkfrom = os.path.join(path, framework.destinationContentsDirectory) |
|||
if verbose >= 3: |
|||
print "Copied Contents:", fromContentsDir |
|||
print " to:", toContentsDir |
|||
elif framework.frameworkName.startswith("libQtGui"): # Copy qt_menu.nib (applies to non-framework layout) |
|||
qtMenuNibSourcePath = os.path.join(framework.frameworkDirectory, "Resources", "qt_menu.nib") |
|||
qtMenuNibDestinationPath = os.path.join(path, "Contents", "Resources", "qt_menu.nib") |
|||
if os.path.exists(qtMenuNibSourcePath) and not os.path.exists(qtMenuNibDestinationPath): |
|||
shutil.copytree(qtMenuNibSourcePath, qtMenuNibDestinationPath, symlinks=True) |
|||
if verbose >= 3: |
|||
print "Copied for libQtGui:", qtMenuNibSourcePath |
|||
print " to:", qtMenuNibDestinationPath |
|||
|
|||
return toPath |
|||
|
|||
def deployFrameworks(frameworks, bundlePath, binaryPath, strip, verbose, deploymentInfo=None): |
|||
if deploymentInfo is None: |
|||
deploymentInfo = DeploymentInfo() |
|||
|
|||
while len(frameworks) > 0: |
|||
framework = frameworks.pop(0) |
|||
deploymentInfo.deployedFrameworks.append(framework.frameworkName) |
|||
|
|||
if verbose >= 2: |
|||
print "Processing", framework.frameworkName, "..." |
|||
|
|||
# Get the Qt path from one of the Qt frameworks |
|||
if deploymentInfo.qtPath is None and framework.isQtFramework(): |
|||
deploymentInfo.detectQtPath(framework.frameworkDirectory) |
|||
|
|||
if framework.installName.startswith("@executable_path") or framework.installName.startswith(bundlePath): |
|||
if verbose >= 2: |
|||
print framework.frameworkName, "already deployed, skipping." |
|||
continue |
|||
|
|||
# install_name_tool the new id into the binary |
|||
changeInstallName(framework.installName, framework.deployedInstallName, binaryPath, verbose) |
|||
|
|||
# Copy farmework to app bundle. |
|||
deployedBinaryPath = copyFramework(framework, bundlePath, verbose) |
|||
# Skip the rest if already was deployed. |
|||
if deployedBinaryPath is None: |
|||
continue |
|||
|
|||
if strip: |
|||
runStrip(deployedBinaryPath, verbose) |
|||
|
|||
# install_name_tool it a new id. |
|||
changeIdentification(framework.deployedInstallName, deployedBinaryPath, verbose) |
|||
# Check for framework dependencies |
|||
dependencies = getFrameworks(deployedBinaryPath, verbose) |
|||
|
|||
for dependency in dependencies: |
|||
changeInstallName(dependency.installName, dependency.deployedInstallName, deployedBinaryPath, verbose) |
|||
|
|||
# Deploy framework if necessary. |
|||
if dependency.frameworkName not in deploymentInfo.deployedFrameworks and dependency not in frameworks: |
|||
frameworks.append(dependency) |
|||
|
|||
return deploymentInfo |
|||
|
|||
def deployFrameworksForAppBundle(applicationBundle, strip, verbose): |
|||
frameworks = getFrameworks(applicationBundle.binaryPath, verbose) |
|||
if len(frameworks) == 0 and verbose >= 1: |
|||
print "Warning: Could not find any external frameworks to deploy in %s." % (applicationBundle.path) |
|||
return DeploymentInfo() |
|||
else: |
|||
return deployFrameworks(frameworks, applicationBundle.path, applicationBundle.binaryPath, strip, verbose) |
|||
|
|||
def deployPlugins(appBundleInfo, deploymentInfo, strip, verbose): |
|||
# Lookup available plugins, exclude unneeded |
|||
plugins = [] |
|||
if deploymentInfo.pluginPath is None: |
|||
return |
|||
for dirpath, dirnames, filenames in os.walk(deploymentInfo.pluginPath): |
|||
pluginDirectory = os.path.relpath(dirpath, deploymentInfo.pluginPath) |
|||
if pluginDirectory == "designer": |
|||
# Skip designer plugins |
|||
continue |
|||
elif pluginDirectory == "phonon" or pluginDirectory == "phonon_backend": |
|||
# Deploy the phonon plugins only if phonon is in use |
|||
if not deploymentInfo.usesFramework("phonon"): |
|||
continue |
|||
elif pluginDirectory == "sqldrivers": |
|||
# Deploy the sql plugins only if QtSql is in use |
|||
if not deploymentInfo.usesFramework("QtSql"): |
|||
continue |
|||
elif pluginDirectory == "script": |
|||
# Deploy the script plugins only if QtScript is in use |
|||
if not deploymentInfo.usesFramework("QtScript"): |
|||
continue |
|||
elif pluginDirectory == "qmltooling" or pluginDirectory == "qml1tooling": |
|||
# Deploy the qml plugins only if QtDeclarative is in use |
|||
if not deploymentInfo.usesFramework("QtDeclarative"): |
|||
continue |
|||
elif pluginDirectory == "bearer": |
|||
# Deploy the bearer plugins only if QtNetwork is in use |
|||
if not deploymentInfo.usesFramework("QtNetwork"): |
|||
continue |
|||
elif pluginDirectory == "position": |
|||
# Deploy the position plugins only if QtPositioning is in use |
|||
if not deploymentInfo.usesFramework("QtPositioning"): |
|||
continue |
|||
elif pluginDirectory == "sensors" or pluginDirectory == "sensorgestures": |
|||
# Deploy the sensor plugins only if QtSensors is in use |
|||
if not deploymentInfo.usesFramework("QtSensors"): |
|||
continue |
|||
elif pluginDirectory == "audio" or pluginDirectory == "playlistformats": |
|||
# Deploy the audio plugins only if QtMultimedia is in use |
|||
if not deploymentInfo.usesFramework("QtMultimedia"): |
|||
continue |
|||
elif pluginDirectory == "mediaservice": |
|||
# Deploy the mediaservice plugins only if QtMultimediaWidgets is in use |
|||
if not deploymentInfo.usesFramework("QtMultimediaWidgets"): |
|||
continue |
|||
|
|||
for pluginName in filenames: |
|||
pluginPath = os.path.join(pluginDirectory, pluginName) |
|||
if pluginName.endswith("_debug.dylib"): |
|||
# Skip debug plugins |
|||
continue |
|||
elif pluginPath == "imageformats/libqsvg.dylib" or pluginPath == "iconengines/libqsvgicon.dylib": |
|||
# Deploy the svg plugins only if QtSvg is in use |
|||
if not deploymentInfo.usesFramework("QtSvg"): |
|||
continue |
|||
elif pluginPath == "accessible/libqtaccessiblecompatwidgets.dylib": |
|||
# Deploy accessibility for Qt3Support only if the Qt3Support is in use |
|||
if not deploymentInfo.usesFramework("Qt3Support"): |
|||
continue |
|||
elif pluginPath == "graphicssystems/libqglgraphicssystem.dylib": |
|||
# Deploy the opengl graphicssystem plugin only if QtOpenGL is in use |
|||
if not deploymentInfo.usesFramework("QtOpenGL"): |
|||
continue |
|||
elif pluginPath == "accessible/libqtaccessiblequick.dylib": |
|||
# Deploy the accessible qtquick plugin only if QtQuick is in use |
|||
if not deploymentInfo.usesFramework("QtQuick"): |
|||
continue |
|||
|
|||
plugins.append((pluginDirectory, pluginName)) |
|||
|
|||
for pluginDirectory, pluginName in plugins: |
|||
if verbose >= 2: |
|||
print "Processing plugin", os.path.join(pluginDirectory, pluginName), "..." |
|||
|
|||
sourcePath = os.path.join(deploymentInfo.pluginPath, pluginDirectory, pluginName) |
|||
destinationDirectory = os.path.join(appBundleInfo.pluginPath, pluginDirectory) |
|||
if not os.path.exists(destinationDirectory): |
|||
os.makedirs(destinationDirectory) |
|||
|
|||
destinationPath = os.path.join(destinationDirectory, pluginName) |
|||
shutil.copy2(sourcePath, destinationPath) |
|||
if verbose >= 3: |
|||
print "Copied:", sourcePath |
|||
print " to:", destinationPath |
|||
|
|||
if strip: |
|||
runStrip(destinationPath, verbose) |
|||
|
|||
dependencies = getFrameworks(destinationPath, verbose) |
|||
|
|||
for dependency in dependencies: |
|||
changeInstallName(dependency.installName, dependency.deployedInstallName, destinationPath, verbose) |
|||
|
|||
# Deploy framework if necessary. |
|||
if dependency.frameworkName not in deploymentInfo.deployedFrameworks: |
|||
deployFrameworks([dependency], appBundleInfo.path, destinationPath, strip, verbose, deploymentInfo) |
|||
|
|||
qt_conf="""[Paths] |
|||
Translations=Resources |
|||
Plugins=PlugIns |
|||
""" |
|||
|
|||
ap = ArgumentParser(description="""Improved version of macdeployqt. |
|||
|
|||
Outputs a ready-to-deploy app in a folder "dist" and optionally wraps it in a .dmg file. |
|||
Note, that the "dist" folder will be deleted before deploying on each run. |
|||
|
|||
Optionally, Qt translation files (.qm) and additional resources can be added to the bundle. |
|||
|
|||
Also optionally signs the .app bundle; set the CODESIGNARGS environment variable to pass arguments |
|||
to the codesign tool. |
|||
E.g. CODESIGNARGS='--sign "Developer ID Application: ..." --keychain /encrypted/foo.keychain'""") |
|||
|
|||
ap.add_argument("app_bundle", nargs=1, metavar="app-bundle", help="application bundle to be deployed") |
|||
ap.add_argument("-verbose", type=int, nargs=1, default=[1], metavar="<0-3>", help="0 = no output, 1 = error/warning (default), 2 = normal, 3 = debug") |
|||
ap.add_argument("-no-plugins", dest="plugins", action="store_false", default=True, help="skip plugin deployment") |
|||
ap.add_argument("-no-strip", dest="strip", action="store_false", default=True, help="don't run 'strip' on the binaries") |
|||
ap.add_argument("-sign", dest="sign", action="store_true", default=False, help="sign .app bundle with codesign tool") |
|||
ap.add_argument("-dmg", nargs="?", const="", metavar="basename", help="create a .dmg disk image; if basename is not specified, a camel-cased version of the app name is used") |
|||
ap.add_argument("-fancy", nargs=1, metavar="plist", default=[], help="make a fancy looking disk image using the given plist file with instructions; requires -dmg to work") |
|||
ap.add_argument("-add-qt-tr", nargs=1, metavar="languages", default=[], help="add Qt translation files to the bundle's ressources; the language list must be separated with commas, not with whitespace") |
|||
ap.add_argument("-translations-dir", nargs=1, metavar="path", default=None, help="Path to Qt's translation files") |
|||
ap.add_argument("-add-resources", nargs="+", metavar="path", default=[], help="list of additional files or folders to be copied into the bundle's resources; must be the last argument") |
|||
|
|||
config = ap.parse_args() |
|||
|
|||
verbose = config.verbose[0] |
|||
|
|||
# ------------------------------------------------ |
|||
|
|||
app_bundle = config.app_bundle[0] |
|||
|
|||
if not os.path.exists(app_bundle): |
|||
if verbose >= 1: |
|||
sys.stderr.write("Error: Could not find app bundle \"%s\"\n" % (app_bundle)) |
|||
sys.exit(1) |
|||
|
|||
app_bundle_name = os.path.splitext(os.path.basename(app_bundle))[0] |
|||
|
|||
# ------------------------------------------------ |
|||
translations_dir = None |
|||
if config.translations_dir and config.translations_dir[0]: |
|||
if os.path.exists(config.translations_dir[0]): |
|||
translations_dir = config.translations_dir[0] |
|||
else: |
|||
if verbose >= 1: |
|||
sys.stderr.write("Error: Could not find translation dir \"%s\"\n" % (translations_dir)) |
|||
sys.exit(1) |
|||
# ------------------------------------------------ |
|||
|
|||
for p in config.add_resources: |
|||
if verbose >= 3: |
|||
print "Checking for \"%s\"..." % p |
|||
if not os.path.exists(p): |
|||
if verbose >= 1: |
|||
sys.stderr.write("Error: Could not find additional resource file \"%s\"\n" % (p)) |
|||
sys.exit(1) |
|||
|
|||
# ------------------------------------------------ |
|||
|
|||
if len(config.fancy) == 1: |
|||
if verbose >= 3: |
|||
print "Fancy: Importing plistlib..." |
|||
try: |
|||
import plistlib |
|||
except ImportError: |
|||
if verbose >= 1: |
|||
sys.stderr.write("Error: Could not import plistlib which is required for fancy disk images.\n") |
|||
sys.exit(1) |
|||
|
|||
p = config.fancy[0] |
|||
if verbose >= 3: |
|||
print "Fancy: Loading \"%s\"..." % p |
|||
if not os.path.exists(p): |
|||
if verbose >= 1: |
|||
sys.stderr.write("Error: Could not find fancy disk image plist at \"%s\"\n" % (p)) |
|||
sys.exit(1) |
|||
|
|||
try: |
|||
fancy = plistlib.readPlist(p) |
|||
except: |
|||
if verbose >= 1: |
|||
sys.stderr.write("Error: Could not parse fancy disk image plist at \"%s\"\n" % (p)) |
|||
sys.exit(1) |
|||
|
|||
try: |
|||
assert not fancy.has_key("window_bounds") or (isinstance(fancy["window_bounds"], list) and len(fancy["window_bounds"]) == 4) |
|||
assert not fancy.has_key("background_picture") or isinstance(fancy["background_picture"], str) |
|||
assert not fancy.has_key("icon_size") or isinstance(fancy["icon_size"], int) |
|||
assert not fancy.has_key("applications_symlink") or isinstance(fancy["applications_symlink"], bool) |
|||
if fancy.has_key("items_position"): |
|||
assert isinstance(fancy["items_position"], dict) |
|||
for key, value in fancy["items_position"].iteritems(): |
|||
assert isinstance(value, list) and len(value) == 2 and isinstance(value[0], int) and isinstance(value[1], int) |
|||
except: |
|||
if verbose >= 1: |
|||
sys.stderr.write("Error: Bad format of fancy disk image plist at \"%s\"\n" % (p)) |
|||
sys.exit(1) |
|||
|
|||
if fancy.has_key("background_picture"): |
|||
bp = fancy["background_picture"] |
|||
if verbose >= 3: |
|||
print "Fancy: Resolving background picture \"%s\"..." % bp |
|||
if not os.path.exists(bp): |
|||
bp = os.path.join(os.path.dirname(p), bp) |
|||
if not os.path.exists(bp): |
|||
if verbose >= 1: |
|||
sys.stderr.write("Error: Could not find background picture at \"%s\" or \"%s\"\n" % (fancy["background_picture"], bp)) |
|||
sys.exit(1) |
|||
else: |
|||
fancy["background_picture"] = bp |
|||
else: |
|||
fancy = None |
|||
|
|||
# ------------------------------------------------ |
|||
|
|||
if os.path.exists("dist"): |
|||
if verbose >= 2: |
|||
print "+ Removing old dist folder +" |
|||
|
|||
shutil.rmtree("dist") |
|||
|
|||
# ------------------------------------------------ |
|||
|
|||
target = os.path.join("dist", "Bitcoin-Qt.app") |
|||
|
|||
if verbose >= 2: |
|||
print "+ Copying source bundle +" |
|||
if verbose >= 3: |
|||
print app_bundle, "->", target |
|||
|
|||
os.mkdir("dist") |
|||
shutil.copytree(app_bundle, target, symlinks=True) |
|||
|
|||
applicationBundle = ApplicationBundleInfo(target) |
|||
|
|||
# ------------------------------------------------ |
|||
|
|||
if verbose >= 2: |
|||
print "+ Deploying frameworks +" |
|||
|
|||
try: |
|||
deploymentInfo = deployFrameworksForAppBundle(applicationBundle, config.strip, verbose) |
|||
if deploymentInfo.qtPath is None: |
|||
deploymentInfo.qtPath = os.getenv("QTDIR", None) |
|||
if deploymentInfo.qtPath is None: |
|||
if verbose >= 1: |
|||
sys.stderr.write("Warning: Could not detect Qt's path, skipping plugin deployment!\n") |
|||
config.plugins = False |
|||
except RuntimeError as e: |
|||
if verbose >= 1: |
|||
sys.stderr.write("Error: %s\n" % str(e)) |
|||
sys.exit(1) |
|||
|
|||
# ------------------------------------------------ |
|||
|
|||
if config.plugins: |
|||
if verbose >= 2: |
|||
print "+ Deploying plugins +" |
|||
|
|||
try: |
|||
deployPlugins(applicationBundle, deploymentInfo, config.strip, verbose) |
|||
except RuntimeError as e: |
|||
if verbose >= 1: |
|||
sys.stderr.write("Error: %s\n" % str(e)) |
|||
sys.exit(1) |
|||
|
|||
# ------------------------------------------------ |
|||
|
|||
if len(config.add_qt_tr) == 0: |
|||
add_qt_tr = [] |
|||
else: |
|||
if translations_dir is not None: |
|||
qt_tr_dir = translations_dir |
|||
else: |
|||
if deploymentInfo.qtPath is not None: |
|||
qt_tr_dir = os.path.join(deploymentInfo.qtPath, "translations") |
|||
else: |
|||
sys.stderr.write("Error: Could not find Qt translation path\n") |
|||
sys.exit(1) |
|||
add_qt_tr = ["qt_%s.qm" % lng for lng in config.add_qt_tr[0].split(",")] |
|||
for lng_file in add_qt_tr: |
|||
p = os.path.join(qt_tr_dir, lng_file) |
|||
if verbose >= 3: |
|||
print "Checking for \"%s\"..." % p |
|||
if not os.path.exists(p): |
|||
if verbose >= 1: |
|||
sys.stderr.write("Error: Could not find Qt translation file \"%s\"\n" % (lng_file)) |
|||
sys.exit(1) |
|||
|
|||
# ------------------------------------------------ |
|||
|
|||
if verbose >= 2: |
|||
print "+ Installing qt.conf +" |
|||
|
|||
f = open(os.path.join(applicationBundle.resourcesPath, "qt.conf"), "wb") |
|||
f.write(qt_conf) |
|||
f.close() |
|||
|
|||
# ------------------------------------------------ |
|||
|
|||
if len(add_qt_tr) > 0 and verbose >= 2: |
|||
print "+ Adding Qt translations +" |
|||
|
|||
for lng_file in add_qt_tr: |
|||
if verbose >= 3: |
|||
print os.path.join(qt_tr_dir, lng_file), "->", os.path.join(applicationBundle.resourcesPath, lng_file) |
|||
shutil.copy2(os.path.join(qt_tr_dir, lng_file), os.path.join(applicationBundle.resourcesPath, lng_file)) |
|||
|
|||
# ------------------------------------------------ |
|||
|
|||
if len(config.add_resources) > 0 and verbose >= 2: |
|||
print "+ Adding additional resources +" |
|||
|
|||
for p in config.add_resources: |
|||
t = os.path.join(applicationBundle.resourcesPath, os.path.basename(p)) |
|||
if verbose >= 3: |
|||
print p, "->", t |
|||
if os.path.isdir(p): |
|||
shutil.copytree(p, t, symlinks=True) |
|||
else: |
|||
shutil.copy2(p, t) |
|||
|
|||
# ------------------------------------------------ |
|||
|
|||
if config.sign and 'CODESIGNARGS' not in os.environ: |
|||
print "You must set the CODESIGNARGS environment variable. Skipping signing." |
|||
elif config.sign: |
|||
if verbose >= 1: |
|||
print "Code-signing app bundle %s"%(target,) |
|||
subprocess.check_call("codesign --force %s %s"%(os.environ['CODESIGNARGS'], target), shell=True) |
|||
|
|||
# ------------------------------------------------ |
|||
|
|||
if config.dmg is not None: |
|||
|
|||
#Patch in check_output for Python 2.6 |
|||
if "check_output" not in dir( subprocess ): |
|||
def f(*popenargs, **kwargs): |
|||
if 'stdout' in kwargs: |
|||
raise ValueError('stdout argument not allowed, it will be overridden.') |
|||
process = subprocess.Popen(stdout=subprocess.PIPE, *popenargs, **kwargs) |
|||
output, unused_err = process.communicate() |
|||
retcode = process.poll() |
|||
if retcode: |
|||
cmd = kwargs.get("args") |
|||
if cmd is None: |
|||
cmd = popenargs[0] |
|||
raise CalledProcessError(retcode, cmd) |
|||
return output |
|||
subprocess.check_output = f |
|||
|
|||
def runHDIUtil(verb, image_basename, **kwargs): |
|||
hdiutil_args = ["hdiutil", verb, image_basename + ".dmg"] |
|||
if kwargs.has_key("capture_stdout"): |
|||
del kwargs["capture_stdout"] |
|||
run = subprocess.check_output |
|||
else: |
|||
if verbose < 2: |
|||
hdiutil_args.append("-quiet") |
|||
elif verbose >= 3: |
|||
hdiutil_args.append("-verbose") |
|||
run = subprocess.check_call |
|||
|
|||
for key, value in kwargs.iteritems(): |
|||
hdiutil_args.append("-" + key) |
|||
if not value is True: |
|||
hdiutil_args.append(str(value)) |
|||
|
|||
return run(hdiutil_args) |
|||
|
|||
if verbose >= 2: |
|||
if fancy is None: |
|||
print "+ Creating .dmg disk image +" |
|||
else: |
|||
print "+ Preparing .dmg disk image +" |
|||
|
|||
if config.dmg != "": |
|||
dmg_name = config.dmg |
|||
else: |
|||
spl = app_bundle_name.split(" ") |
|||
dmg_name = spl[0] + "".join(p.capitalize() for p in spl[1:]) |
|||
|
|||
if fancy is None: |
|||
try: |
|||
runHDIUtil("create", dmg_name, srcfolder="dist", format="UDBZ", volname="Bitcoin-Core", ov=True) |
|||
except subprocess.CalledProcessError as e: |
|||
sys.exit(e.returncode) |
|||
else: |
|||
if verbose >= 3: |
|||
print "Determining size of \"dist\"..." |
|||
size = 0 |
|||
for path, dirs, files in os.walk("dist"): |
|||
for file in files: |
|||
size += os.path.getsize(os.path.join(path, file)) |
|||
size += int(size * 0.15) |
|||
|
|||
if verbose >= 3: |
|||
print "Creating temp image for modification..." |
|||
try: |
|||
runHDIUtil("create", dmg_name + ".temp", srcfolder="dist", format="UDRW", size=size, volname="Bitcoin-Core", ov=True) |
|||
except subprocess.CalledProcessError as e: |
|||
sys.exit(e.returncode) |
|||
|
|||
if verbose >= 3: |
|||
print "Attaching temp image..." |
|||
try: |
|||
output = runHDIUtil("attach", dmg_name + ".temp", readwrite=True, noverify=True, noautoopen=True, capture_stdout=True) |
|||
except subprocess.CalledProcessError as e: |
|||
sys.exit(e.returncode) |
|||
|
|||
m = re.search("/Volumes/(.+$)", output) |
|||
disk_root = m.group(0) |
|||
disk_name = m.group(1) |
|||
|
|||
if verbose >= 2: |
|||
print "+ Applying fancy settings +" |
|||
|
|||
if fancy.has_key("background_picture"): |
|||
bg_path = os.path.join(disk_root, ".background", os.path.basename(fancy["background_picture"])) |
|||
os.mkdir(os.path.dirname(bg_path)) |
|||
if verbose >= 3: |
|||
print fancy["background_picture"], "->", bg_path |
|||
shutil.copy2(fancy["background_picture"], bg_path) |
|||
else: |
|||
bg_path = None |
|||
|
|||
if fancy.get("applications_symlink", False): |
|||
os.symlink("/Applications", os.path.join(disk_root, "Applications")) |
|||
|
|||
# The Python appscript package broke with OSX 10.8 and isn't being fixed. |
|||
# So we now build up an AppleScript string and use the osascript command |
|||
# to make the .dmg file pretty: |
|||
appscript = Template( """ |
|||
on run argv |
|||
tell application "Finder" |
|||
tell disk "$disk" |
|||
open |
|||
set current view of container window to icon view |
|||
set toolbar visible of container window to false |
|||
set statusbar visible of container window to false |
|||
set the bounds of container window to {$window_bounds} |
|||
set theViewOptions to the icon view options of container window |
|||
set arrangement of theViewOptions to not arranged |
|||
set icon size of theViewOptions to $icon_size |
|||
$background_commands |
|||
$items_positions |
|||
close -- close/reopen works around a bug... |
|||
open |
|||
update without registering applications |
|||
delay 5 |
|||
eject |
|||
end tell |
|||
end tell |
|||
end run |
|||
""") |
|||
|
|||
itemscript = Template('set position of item "${item}" of container window to {${position}}') |
|||
items_positions = [] |
|||
if fancy.has_key("items_position"): |
|||
for name, position in fancy["items_position"].iteritems(): |
|||
params = { "item" : name, "position" : ",".join([str(p) for p in position]) } |
|||
items_positions.append(itemscript.substitute(params)) |
|||
|
|||
params = { |
|||
"disk" : "Bitcoin-Core", |
|||
"window_bounds" : "300,300,800,620", |
|||
"icon_size" : "96", |
|||
"background_commands" : "", |
|||
"items_positions" : "\n ".join(items_positions) |
|||
} |
|||
if fancy.has_key("window_bounds"): |
|||
params["window.bounds"] = ",".join([str(p) for p in fancy["window_bounds"]]) |
|||
if fancy.has_key("icon_size"): |
|||
params["icon_size"] = str(fancy["icon_size"]) |
|||
if bg_path is not None: |
|||
# Set background file, then call SetFile to make it invisible. |
|||
# (note: making it invisible first makes set background picture fail) |
|||
bgscript = Template("""set background picture of theViewOptions to file ".background:$bgpic" |
|||
do shell script "SetFile -a V /Volumes/$disk/.background/$bgpic" """) |
|||
params["background_commands"] = bgscript.substitute({"bgpic" : os.path.basename(bg_path), "disk" : params["disk"]}) |
|||
|
|||
s = appscript.substitute(params) |
|||
if verbose >= 2: |
|||
print("Running AppleScript:") |
|||
print(s) |
|||
|
|||
p = subprocess.Popen(['osascript', '-'], stdin=subprocess.PIPE) |
|||
p.communicate(input=s) |
|||
if p.returncode: |
|||
print("Error running osascript.") |
|||
|
|||
if verbose >= 2: |
|||
print "+ Finalizing .dmg disk image +" |
|||
time.sleep(5) |
|||
|
|||
try: |
|||
runHDIUtil("convert", dmg_name + ".temp", format="UDBZ", o=dmg_name + ".dmg", ov=True) |
|||
except subprocess.CalledProcessError as e: |
|||
sys.exit(e.returncode) |
|||
|
|||
os.unlink(dmg_name + ".temp.dmg") |
|||
|
|||
# ------------------------------------------------ |
|||
|
|||
if verbose >= 2: |
|||
print "+ Done +" |
|||
|
|||
sys.exit(0) |
@ -1,421 +0,0 @@ |
|||
bin_PROGRAMS += qt/bitcoin-qt |
|||
EXTRA_LIBRARIES += qt/libbitcoinqt.a |
|||
|
|||
# bitcoin qt core #
|
|||
QT_TS = \
|
|||
qt/locale/bitcoin_ach.ts \
|
|||
qt/locale/bitcoin_af_ZA.ts \
|
|||
qt/locale/bitcoin_ar.ts \
|
|||
qt/locale/bitcoin_be_BY.ts \
|
|||
qt/locale/bitcoin_bg.ts \
|
|||
qt/locale/bitcoin_bs.ts \
|
|||
qt/locale/bitcoin_ca_ES.ts \
|
|||
qt/locale/bitcoin_ca.ts \
|
|||
qt/locale/bitcoin_ca@valencia.ts \
|
|||
qt/locale/bitcoin_cmn.ts \
|
|||
qt/locale/bitcoin_cs.ts \
|
|||
qt/locale/bitcoin_cy.ts \
|
|||
qt/locale/bitcoin_da.ts \
|
|||
qt/locale/bitcoin_de.ts \
|
|||
qt/locale/bitcoin_el_GR.ts \
|
|||
qt/locale/bitcoin_en.ts \
|
|||
qt/locale/bitcoin_eo.ts \
|
|||
qt/locale/bitcoin_es_CL.ts \
|
|||
qt/locale/bitcoin_es_DO.ts \
|
|||
qt/locale/bitcoin_es_MX.ts \
|
|||
qt/locale/bitcoin_es.ts \
|
|||
qt/locale/bitcoin_es_UY.ts \
|
|||
qt/locale/bitcoin_et.ts \
|
|||
qt/locale/bitcoin_eu_ES.ts \
|
|||
qt/locale/bitcoin_fa_IR.ts \
|
|||
qt/locale/bitcoin_fa.ts \
|
|||
qt/locale/bitcoin_fi.ts \
|
|||
qt/locale/bitcoin_fr_CA.ts \
|
|||
qt/locale/bitcoin_fr.ts \
|
|||
qt/locale/bitcoin_gl.ts \
|
|||
qt/locale/bitcoin_gu_IN.ts \
|
|||
qt/locale/bitcoin_he.ts \
|
|||
qt/locale/bitcoin_hi_IN.ts \
|
|||
qt/locale/bitcoin_hr.ts \
|
|||
qt/locale/bitcoin_hu.ts \
|
|||
qt/locale/bitcoin_id_ID.ts \
|
|||
qt/locale/bitcoin_it.ts \
|
|||
qt/locale/bitcoin_ja.ts \
|
|||
qt/locale/bitcoin_ka.ts \
|
|||
qt/locale/bitcoin_kk_KZ.ts \
|
|||
qt/locale/bitcoin_ko_KR.ts \
|
|||
qt/locale/bitcoin_ky.ts \
|
|||
qt/locale/bitcoin_la.ts \
|
|||
qt/locale/bitcoin_lt.ts \
|
|||
qt/locale/bitcoin_lv_LV.ts \
|
|||
qt/locale/bitcoin_mn.ts \
|
|||
qt/locale/bitcoin_ms_MY.ts \
|
|||
qt/locale/bitcoin_nb.ts \
|
|||
qt/locale/bitcoin_nl.ts \
|
|||
qt/locale/bitcoin_pam.ts \
|
|||
qt/locale/bitcoin_pl.ts \
|
|||
qt/locale/bitcoin_pt_BR.ts \
|
|||
qt/locale/bitcoin_pt_PT.ts \
|
|||
qt/locale/bitcoin_ro_RO.ts \
|
|||
qt/locale/bitcoin_ru.ts \
|
|||
qt/locale/bitcoin_sah.ts \
|
|||
qt/locale/bitcoin_sk.ts \
|
|||
qt/locale/bitcoin_sl_SI.ts \
|
|||
qt/locale/bitcoin_sq.ts \
|
|||
qt/locale/bitcoin_sr.ts \
|
|||
qt/locale/bitcoin_sv.ts \
|
|||
qt/locale/bitcoin_th_TH.ts \
|
|||
qt/locale/bitcoin_tr.ts \
|
|||
qt/locale/bitcoin_uk.ts \
|
|||
qt/locale/bitcoin_ur_PK.ts \
|
|||
qt/locale/bitcoin_uz@Cyrl.ts \
|
|||
qt/locale/bitcoin_vi.ts \
|
|||
qt/locale/bitcoin_vi_VN.ts \
|
|||
qt/locale/bitcoin_zh_CN.ts \
|
|||
qt/locale/bitcoin_zh_HK.ts \
|
|||
qt/locale/bitcoin_zh_TW.ts |
|||
|
|||
QT_FORMS_UI = \
|
|||
qt/forms/addressbookpage.ui \
|
|||
qt/forms/askpassphrasedialog.ui \
|
|||
qt/forms/coincontroldialog.ui \
|
|||
qt/forms/editaddressdialog.ui \
|
|||
qt/forms/helpmessagedialog.ui \
|
|||
qt/forms/intro.ui \
|
|||
qt/forms/openuridialog.ui \
|
|||
qt/forms/optionsdialog.ui \
|
|||
qt/forms/overviewpage.ui \
|
|||
qt/forms/receivecoinsdialog.ui \
|
|||
qt/forms/receiverequestdialog.ui \
|
|||
qt/forms/rpcconsole.ui \
|
|||
qt/forms/sendcoinsdialog.ui \
|
|||
qt/forms/sendcoinsentry.ui \
|
|||
qt/forms/signverifymessagedialog.ui \
|
|||
qt/forms/transactiondescdialog.ui |
|||
|
|||
QT_MOC_CPP = \
|
|||
qt/moc_addressbookpage.cpp \
|
|||
qt/moc_addresstablemodel.cpp \
|
|||
qt/moc_askpassphrasedialog.cpp \
|
|||
qt/moc_bitcoinaddressvalidator.cpp \
|
|||
qt/moc_bitcoinamountfield.cpp \
|
|||
qt/moc_bitcoingui.cpp \
|
|||
qt/moc_bitcoinunits.cpp \
|
|||
qt/moc_clientmodel.cpp \
|
|||
qt/moc_coincontroldialog.cpp \
|
|||
qt/moc_coincontroltreewidget.cpp \
|
|||
qt/moc_csvmodelwriter.cpp \
|
|||
qt/moc_editaddressdialog.cpp \
|
|||
qt/moc_guiutil.cpp \
|
|||
qt/moc_intro.cpp \
|
|||
qt/moc_macdockiconhandler.cpp \
|
|||
qt/moc_macnotificationhandler.cpp \
|
|||
qt/moc_notificator.cpp \
|
|||
qt/moc_openuridialog.cpp \
|
|||
qt/moc_optionsdialog.cpp \
|
|||
qt/moc_optionsmodel.cpp \
|
|||
qt/moc_overviewpage.cpp \
|
|||
qt/moc_peertablemodel.cpp \
|
|||
qt/moc_paymentserver.cpp \
|
|||
qt/moc_qvalidatedlineedit.cpp \
|
|||
qt/moc_qvaluecombobox.cpp \
|
|||
qt/moc_receivecoinsdialog.cpp \
|
|||
qt/moc_receiverequestdialog.cpp \
|
|||
qt/moc_recentrequeststablemodel.cpp \
|
|||
qt/moc_rpcconsole.cpp \
|
|||
qt/moc_sendcoinsdialog.cpp \
|
|||
qt/moc_sendcoinsentry.cpp \
|
|||
qt/moc_signverifymessagedialog.cpp \
|
|||
qt/moc_splashscreen.cpp \
|
|||
qt/moc_trafficgraphwidget.cpp \
|
|||
qt/moc_transactiondesc.cpp \
|
|||
qt/moc_transactiondescdialog.cpp \
|
|||
qt/moc_transactionfilterproxy.cpp \
|
|||
qt/moc_transactiontablemodel.cpp \
|
|||
qt/moc_transactionview.cpp \
|
|||
qt/moc_utilitydialog.cpp \
|
|||
qt/moc_walletframe.cpp \
|
|||
qt/moc_walletmodel.cpp \
|
|||
qt/moc_walletview.cpp |
|||
|
|||
BITCOIN_MM = \
|
|||
qt/macdockiconhandler.mm \
|
|||
qt/macnotificationhandler.mm |
|||
|
|||
QT_MOC = \
|
|||
qt/bitcoin.moc \
|
|||
qt/bitcoinamountfield.moc \
|
|||
qt/intro.moc \
|
|||
qt/overviewpage.moc \
|
|||
qt/rpcconsole.moc |
|||
|
|||
QT_QRC_CPP = qt/qrc_bitcoin.cpp |
|||
QT_QRC = qt/bitcoin.qrc |
|||
QT_QRC_LOCALE_CPP = qt/qrc_bitcoin_locale.cpp |
|||
QT_QRC_LOCALE = qt/bitcoin_locale.qrc |
|||
|
|||
PROTOBUF_CC = qt/paymentrequest.pb.cc |
|||
PROTOBUF_H = qt/paymentrequest.pb.h |
|||
PROTOBUF_PROTO = qt/paymentrequest.proto |
|||
|
|||
BITCOIN_QT_H = \
|
|||
qt/addressbookpage.h \
|
|||
qt/addresstablemodel.h \
|
|||
qt/askpassphrasedialog.h \
|
|||
qt/bitcoinaddressvalidator.h \
|
|||
qt/bitcoinamountfield.h \
|
|||
qt/bitcoingui.h \
|
|||
qt/bitcoinunits.h \
|
|||
qt/clientmodel.h \
|
|||
qt/coincontroldialog.h \
|
|||
qt/coincontroltreewidget.h \
|
|||
qt/csvmodelwriter.h \
|
|||
qt/editaddressdialog.h \
|
|||
qt/guiconstants.h \
|
|||
qt/guiutil.h \
|
|||
qt/intro.h \
|
|||
qt/macdockiconhandler.h \
|
|||
qt/macnotificationhandler.h \
|
|||
qt/networkstyle.h \
|
|||
qt/notificator.h \
|
|||
qt/openuridialog.h \
|
|||
qt/optionsdialog.h \
|
|||
qt/optionsmodel.h \
|
|||
qt/overviewpage.h \
|
|||
qt/paymentrequestplus.h \
|
|||
qt/paymentserver.h \
|
|||
qt/peertablemodel.h \
|
|||
qt/qvalidatedlineedit.h \
|
|||
qt/qvaluecombobox.h \
|
|||
qt/receivecoinsdialog.h \
|
|||
qt/receiverequestdialog.h \
|
|||
qt/recentrequeststablemodel.h \
|
|||
qt/rpcconsole.h \
|
|||
qt/scicon.h \
|
|||
qt/sendcoinsdialog.h \
|
|||
qt/sendcoinsentry.h \
|
|||
qt/signverifymessagedialog.h \
|
|||
qt/splashscreen.h \
|
|||
qt/trafficgraphwidget.h \
|
|||
qt/transactiondesc.h \
|
|||
qt/transactiondescdialog.h \
|
|||
qt/transactionfilterproxy.h \
|
|||
qt/transactionrecord.h \
|
|||
qt/transactiontablemodel.h \
|
|||
qt/transactionview.h \
|
|||
qt/utilitydialog.h \
|
|||
qt/walletframe.h \
|
|||
qt/walletmodel.h \
|
|||
qt/walletmodeltransaction.h \
|
|||
qt/walletview.h \
|
|||
qt/winshutdownmonitor.h |
|||
|
|||
RES_ICONS = \
|
|||
qt/res/icons/add.png \
|
|||
qt/res/icons/address-book.png \
|
|||
qt/res/icons/about.png \
|
|||
qt/res/icons/about_qt.png \
|
|||
qt/res/icons/bitcoin.ico \
|
|||
qt/res/icons/bitcoin.png \
|
|||
qt/res/icons/clock1.png \
|
|||
qt/res/icons/clock2.png \
|
|||
qt/res/icons/clock3.png \
|
|||
qt/res/icons/clock4.png \
|
|||
qt/res/icons/clock5.png \
|
|||
qt/res/icons/configure.png \
|
|||
qt/res/icons/connect0.png \
|
|||
qt/res/icons/connect1.png \
|
|||
qt/res/icons/connect2.png \
|
|||
qt/res/icons/connect3.png \
|
|||
qt/res/icons/connect4.png \
|
|||
qt/res/icons/debugwindow.png \
|
|||
qt/res/icons/edit.png \
|
|||
qt/res/icons/editcopy.png \
|
|||
qt/res/icons/editpaste.png \
|
|||
qt/res/icons/export.png \
|
|||
qt/res/icons/eye.png \
|
|||
qt/res/icons/eye_minus.png \
|
|||
qt/res/icons/eye_plus.png \
|
|||
qt/res/icons/filesave.png \
|
|||
qt/res/icons/history.png \
|
|||
qt/res/icons/info.png \
|
|||
qt/res/icons/key.png \
|
|||
qt/res/icons/lock_closed.png \
|
|||
qt/res/icons/lock_open.png \
|
|||
qt/res/icons/open.png \
|
|||
qt/res/icons/overview.png \
|
|||
qt/res/icons/quit.png \
|
|||
qt/res/icons/receive.png \
|
|||
qt/res/icons/remove.png \
|
|||
qt/res/icons/send.png \
|
|||
qt/res/icons/synced.png \
|
|||
qt/res/icons/transaction0.png \
|
|||
qt/res/icons/transaction2.png \
|
|||
qt/res/icons/transaction_conflicted.png \
|
|||
qt/res/icons/tx_inout.png \
|
|||
qt/res/icons/tx_input.png \
|
|||
qt/res/icons/tx_output.png \
|
|||
qt/res/icons/tx_mined.png \
|
|||
qt/res/icons/warning.png \
|
|||
qt/res/icons/verify.png |
|||
|
|||
BITCOIN_QT_CPP = \
|
|||
qt/bitcoinaddressvalidator.cpp \
|
|||
qt/bitcoinamountfield.cpp \
|
|||
qt/bitcoingui.cpp \
|
|||
qt/bitcoinunits.cpp \
|
|||
qt/clientmodel.cpp \
|
|||
qt/csvmodelwriter.cpp \
|
|||
qt/guiutil.cpp \
|
|||
qt/intro.cpp \
|
|||
qt/networkstyle.cpp \
|
|||
qt/notificator.cpp \
|
|||
qt/optionsdialog.cpp \
|
|||
qt/optionsmodel.cpp \
|
|||
qt/peertablemodel.cpp \
|
|||
qt/qvalidatedlineedit.cpp \
|
|||
qt/qvaluecombobox.cpp \
|
|||
qt/rpcconsole.cpp \
|
|||
qt/scicon.cpp \
|
|||
qt/splashscreen.cpp \
|
|||
qt/trafficgraphwidget.cpp \
|
|||
qt/utilitydialog.cpp |
|||
|
|||
if TARGET_WINDOWS |
|||
BITCOIN_QT_CPP += qt/winshutdownmonitor.cpp |
|||
endif |
|||
|
|||
if ENABLE_WALLET |
|||
BITCOIN_QT_CPP += \
|
|||
qt/addressbookpage.cpp \
|
|||
qt/addresstablemodel.cpp \
|
|||
qt/askpassphrasedialog.cpp \
|
|||
qt/coincontroldialog.cpp \
|
|||
qt/coincontroltreewidget.cpp \
|
|||
qt/editaddressdialog.cpp \
|
|||
qt/openuridialog.cpp \
|
|||
qt/overviewpage.cpp \
|
|||
qt/paymentrequestplus.cpp \
|
|||
qt/paymentserver.cpp \
|
|||
qt/receivecoinsdialog.cpp \
|
|||
qt/receiverequestdialog.cpp \
|
|||
qt/recentrequeststablemodel.cpp \
|
|||
qt/sendcoinsdialog.cpp \
|
|||
qt/sendcoinsentry.cpp \
|
|||
qt/signverifymessagedialog.cpp \
|
|||
qt/transactiondesc.cpp \
|
|||
qt/transactiondescdialog.cpp \
|
|||
qt/transactionfilterproxy.cpp \
|
|||
qt/transactionrecord.cpp \
|
|||
qt/transactiontablemodel.cpp \
|
|||
qt/transactionview.cpp \
|
|||
qt/walletframe.cpp \
|
|||
qt/walletmodel.cpp \
|
|||
qt/walletmodeltransaction.cpp \
|
|||
qt/walletview.cpp |
|||
endif |
|||
|
|||
RES_IMAGES = |
|||
|
|||
RES_MOVIES = $(wildcard qt/res/movies/spinner-*.png) |
|||
|
|||
BITCOIN_RC = qt/res/bitcoin-qt-res.rc |
|||
|
|||
BITCOIN_QT_INCLUDES = -I$(builddir)/qt -I$(srcdir)/qt -I$(srcdir)/qt/forms \
|
|||
-I$(builddir)/qt/forms -DQT_NO_KEYWORDS |
|||
|
|||
qt_libbitcoinqt_a_CPPFLAGS = $(BITCOIN_INCLUDES) $(BITCOIN_QT_INCLUDES) \
|
|||
$(QT_INCLUDES) $(QT_DBUS_INCLUDES) $(PROTOBUF_CFLAGS) $(QR_CFLAGS) |
|||
|
|||
qt_libbitcoinqt_a_SOURCES = $(BITCOIN_QT_CPP) $(BITCOIN_QT_H) $(QT_FORMS_UI) \
|
|||
$(QT_QRC) $(QT_QRC_LOCALE) $(QT_TS) $(PROTOBUF_PROTO) $(RES_ICONS) $(RES_IMAGES) $(RES_MOVIES) |
|||
|
|||
nodist_qt_libbitcoinqt_a_SOURCES = $(QT_MOC_CPP) $(QT_MOC) $(PROTOBUF_CC) \
|
|||
$(PROTOBUF_H) $(QT_QRC_CPP) $(QT_QRC_LOCALE_CPP) |
|||
|
|||
# forms/foo.h -> forms/ui_foo.h
|
|||
QT_FORMS_H=$(join $(dir $(QT_FORMS_UI)),$(addprefix ui_, $(notdir $(QT_FORMS_UI:.ui=.h)))) |
|||
|
|||
# Most files will depend on the forms and moc files as includes. Generate them
|
|||
# before anything else.
|
|||
$(QT_MOC): $(QT_FORMS_H) |
|||
$(qt_libbitcoinqt_a_OBJECTS) $(qt_bitcoin_qt_OBJECTS) : | $(QT_MOC) |
|||
|
|||
#Generating these with a half-written protobuf header leads to wacky results.
|
|||
#This makes sure it's done.
|
|||
$(QT_MOC): $(PROTOBUF_H) |
|||
$(QT_MOC_CPP): $(PROTOBUF_H) |
|||
|
|||
# bitcoin-qt binary #
|
|||
qt_bitcoin_qt_CPPFLAGS = $(BITCOIN_INCLUDES) $(BITCOIN_QT_INCLUDES) \
|
|||
$(QT_INCLUDES) $(PROTOBUF_CFLAGS) $(QR_CFLAGS) |
|||
|
|||
qt_bitcoin_qt_SOURCES = qt/bitcoin.cpp |
|||
if TARGET_DARWIN |
|||
qt_bitcoin_qt_SOURCES += $(BITCOIN_MM) |
|||
endif |
|||
if TARGET_WINDOWS |
|||
qt_bitcoin_qt_SOURCES += $(BITCOIN_RC) |
|||
endif |
|||
qt_bitcoin_qt_LDADD = qt/libbitcoinqt.a $(LIBBITCOIN_SERVER) |
|||
if ENABLE_WALLET |
|||
qt_bitcoin_qt_LDADD += $(LIBBITCOIN_WALLET) |
|||
endif |
|||
if ENABLE_ZMQ |
|||
qt_bitcoin_qt_LDADD += $(LIBBITCOIN_ZMQ) $(ZMQ_LIBS) |
|||
endif |
|||
qt_bitcoin_qt_LDADD += $(LIBBITCOIN_CLI) $(LIBBITCOIN_COMMON) $(LIBBITCOIN_UTIL) $(LIBBITCOIN_CRYPTO) $(LIBUNIVALUE) $(LIBLEVELDB) $(LIBMEMENV) \
|
|||
$(BOOST_LIBS) $(QT_LIBS) $(QT_DBUS_LIBS) $(QR_LIBS) $(PROTOBUF_LIBS) $(BDB_LIBS) $(SSL_LIBS) $(CRYPTO_LIBS) $(MINIUPNPC_LIBS) $(LIBSECP256K1) $(LIBZCASH_LIBS) |
|||
qt_bitcoin_qt_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(QT_LDFLAGS) $(LIBTOOL_APP_LDFLAGS) |
|||
qt_bitcoin_qt_LIBTOOLFLAGS = --tag CXX |
|||
|
|||
#locale/foo.ts -> locale/foo.qm
|
|||
QT_QM=$(QT_TS:.ts=.qm) |
|||
|
|||
SECONDARY: $(QT_QM) |
|||
|
|||
qt/bitcoinstrings.cpp: $(libbitcoin_server_a_SOURCES) $(libbitcoin_wallet_a_SOURCES) |
|||
@test -n $(XGETTEXT) || echo "xgettext is required for updating translations" |
|||
$(AM_V_GEN) cd $(srcdir); XGETTEXT=$(XGETTEXT) ../share/qt/extract_strings_qt.py $^ |
|||
|
|||
translate: qt/bitcoinstrings.cpp $(QT_FORMS_UI) $(QT_FORMS_UI) $(BITCOIN_QT_CPP) $(BITCOIN_QT_H) $(BITCOIN_MM) |
|||
@test -n $(LUPDATE) || echo "lupdate is required for updating translations" |
|||
$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(LUPDATE) $^ -locations relative -no-obsolete -ts qt/locale/bitcoin_en.ts |
|||
|
|||
$(QT_QRC_LOCALE_CPP): $(QT_QRC_LOCALE) $(QT_QM) |
|||
@test -f $(RCC) |
|||
@test -f $(@D)/$(<F) || cp -f $< $(@D) |
|||
$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(RCC) -name bitcoin_locale $(@D)/$(<F) | \
|
|||
$(SED) -e '/^\*\*.*Created:/d' -e '/^\*\*.*by:/d' > $@ |
|||
|
|||
$(QT_QRC_CPP): $(QT_QRC) $(QT_FORMS_H) $(RES_ICONS) $(RES_IMAGES) $(RES_MOVIES) $(PROTOBUF_H) |
|||
@test -f $(RCC) |
|||
$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(RCC) -name bitcoin $< | \
|
|||
$(SED) -e '/^\*\*.*Created:/d' -e '/^\*\*.*by:/d' > $@ |
|||
|
|||
CLEAN_QT = $(nodist_qt_libbitcoinqt_a_SOURCES) $(QT_QM) $(QT_FORMS_H) qt/*.gcda qt/*.gcno |
|||
|
|||
CLEANFILES += $(CLEAN_QT) |
|||
|
|||
bitcoin_qt_clean: FORCE |
|||
rm -f $(CLEAN_QT) $(qt_libbitcoinqt_a_OBJECTS) $(qt_bitcoin_qt_OBJECTS) qt/bitcoin-qt$(EXEEXT) $(LIBBITCOINQT) |
|||
|
|||
bitcoin_qt : qt/bitcoin-qt$(EXEEXT) |
|||
|
|||
ui_%.h: %.ui |
|||
@test -f $(UIC) |
|||
@$(MKDIR_P) $(@D) |
|||
$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(UIC) -o $@ $< || (echo "Error creating $@"; false) |
|||
|
|||
%.moc: %.cpp |
|||
$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(MOC) $(QT_INCLUDES) $(MOC_DEFS) $< | \
|
|||
$(SED) -e '/^\*\*.*Created:/d' -e '/^\*\*.*by:/d' > $@ |
|||
|
|||
moc_%.cpp: %.h |
|||
$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(MOC) $(QT_INCLUDES) $(MOC_DEFS) $< | \
|
|||
$(SED) -e '/^\*\*.*Created:/d' -e '/^\*\*.*by:/d' > $@ |
|||
|
|||
%.qm: %.ts |
|||
@test -f $(LRELEASE) |
|||
@$(MKDIR_P) $(@D) |
|||
$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(LRELEASE) -silent $< -qm $@ |
@ -1,51 +0,0 @@ |
|||
bin_PROGRAMS += qt/test/test_bitcoin-qt |
|||
TESTS += qt/test/test_bitcoin-qt |
|||
|
|||
TEST_QT_MOC_CPP = qt/test/moc_uritests.cpp |
|||
|
|||
if ENABLE_WALLET |
|||
TEST_QT_MOC_CPP += qt/test/moc_paymentservertests.cpp |
|||
endif |
|||
|
|||
TEST_QT_H = \
|
|||
qt/test/uritests.h \
|
|||
qt/test/paymentrequestdata.h \
|
|||
qt/test/paymentservertests.h |
|||
|
|||
qt_test_test_bitcoin_qt_CPPFLAGS = $(BITCOIN_INCLUDES) $(BITCOIN_QT_INCLUDES) \
|
|||
$(QT_INCLUDES) $(QT_TEST_INCLUDES) $(PROTOBUF_CFLAGS) |
|||
|
|||
qt_test_test_bitcoin_qt_SOURCES = \
|
|||
qt/test/test_main.cpp \
|
|||
qt/test/uritests.cpp \
|
|||
$(TEST_QT_H) |
|||
if ENABLE_WALLET |
|||
qt_test_test_bitcoin_qt_SOURCES += \
|
|||
qt/test/paymentservertests.cpp |
|||
endif |
|||
|
|||
nodist_qt_test_test_bitcoin_qt_SOURCES = $(TEST_QT_MOC_CPP) |
|||
|
|||
qt_test_test_bitcoin_qt_LDADD = $(LIBBITCOINQT) $(LIBBITCOIN_SERVER) |
|||
if ENABLE_WALLET |
|||
qt_test_test_bitcoin_qt_LDADD += $(LIBBITCOIN_WALLET) |
|||
endif |
|||
if ENABLE_ZMQ |
|||
qt_test_test_bitcoin_qt_LDADD += $(LIBBITCOIN_ZMQ) $(ZMQ_LIBS) |
|||
endif |
|||
qt_test_test_bitcoin_qt_LDADD += $(LIBBITCOIN_CLI) $(LIBBITCOIN_COMMON) $(LIBBITCOIN_UTIL) $(LIBBITCOIN_CRYPTO) $(LIBUNIVALUE) $(LIBLEVELDB) \
|
|||
$(LIBMEMENV) $(BOOST_LIBS) $(QT_DBUS_LIBS) $(QT_TEST_LIBS) $(QT_LIBS) \
|
|||
$(QR_LIBS) $(PROTOBUF_LIBS) $(BDB_LIBS) $(SSL_LIBS) $(CRYPTO_LIBS) $(MINIUPNPC_LIBS) $(LIBSECP256K1) $(LIBZCASH_LIBS) |
|||
qt_test_test_bitcoin_qt_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(QT_LDFLAGS) $(LIBTOOL_APP_LDFLAGS) |
|||
|
|||
CLEAN_BITCOIN_QT_TEST = $(TEST_QT_MOC_CPP) qt/test/*.gcda qt/test/*.gcno |
|||
|
|||
CLEANFILES += $(CLEAN_BITCOIN_QT_TEST) |
|||
|
|||
test_bitcoin_qt : qt/test/test_bitcoin-qt$(EXEEXT) |
|||
|
|||
test_bitcoin_qt_check : qt/test/test_bitcoin-qt$(EXEEXT) FORCE |
|||
$(MAKE) check-TESTS TESTS=$^ |
|||
|
|||
test_bitcoin_qt_clean: FORCE |
|||
rm -f $(CLEAN_BITCOIN_QT_TEST) $(qt_test_test_bitcoin_qt_OBJECTS) |
Loading…
Reference in new issue