Merge pull request #800 from ONLYOFFICE/release/v8.1.0

Release/v8.1.0

build.pro

@@ -1,149 +0,0 @@
-TEMPLATE = subdirs
-
-ROOT_DIR=$$PWD/..
-DEPLOY_DIR=$$PWD/deploy
-CORE_ROOT_DIR=$$ROOT_DIR/core
-
-include($$PWD/common.pri)
-
-CONFIG += ordered
-
-core:CONFIG += core_libraries
-builder:CONFIG += core_libraries
-desktop:CONFIG += core_libraries
-server:CONFIG += core_libraries
-mobile:CONFIG += core_libraries
-
-!core_libraries:CONFIG += no_x2t
-!core_libraries:CONFIG += no_use_common_binary
-!core_libraries:CONFIG += no_tests
-
-core_windows {
-    desktop:CONFIG += core_and_multimedia
-}
-core_linux {
-    desktop:CONFIG += core_and_multimedia
-}
-core_mac {
-    CONFIG += no_desktop_apps
-}
-core_ios {
-    CONFIG += no_use_common_binary
-    CONFIG += no_desktop_apps
-    CONFIG += no_tests
-}
-core_android {
-    CONFIG += no_use_common_binary
-    CONFIG += no_desktop_apps
-    CONFIG += no_tests
-}
-
-core_libraries {
-    addSubProject(cryptopp,         $$CORE_ROOT_DIR/Common/3dParty/cryptopp/project/cryptopp.pro)
-    addSubProject(cfcpp,            $$CORE_ROOT_DIR/Common/cfcpp/cfcpp.pro)
-    addSubProject(unicodeconverter, $$CORE_ROOT_DIR/UnicodeConverter/UnicodeConverter.pro,\
-                                        cryptopp)
-    addSubProject(kernel,           $$CORE_ROOT_DIR/Common/kernel.pro,\
-                                        unicodeconverter)
-    addSubProject(network,          $$CORE_ROOT_DIR/Common/Network/network.pro,\
-                                        kernel unicodeconverter)
-    addSubProject(graphics,         $$CORE_ROOT_DIR/DesktopEditor/graphics/pro/graphics.pro,\
-                                        kernel unicodeconverter)
-    addSubProject(pdffile,          $$CORE_ROOT_DIR/PdfFile/PdfFile.pro,\
-                                        kernel unicodeconverter graphics)
-    addSubProject(djvufile,         $$CORE_ROOT_DIR/DjVuFile/DjVuFile.pro,\
-                                        kernel unicodeconverter graphics pdffile)
-    addSubProject(xpsfile,          $$CORE_ROOT_DIR/XpsFile/XpsFile.pro,\
-                                        kernel unicodeconverter graphics pdffile)
-    addSubProject(htmlrenderer,     $$CORE_ROOT_DIR/HtmlRenderer/htmlrenderer.pro,\
-                                        kernel unicodeconverter graphics)
-    addSubProject(docxrenderer,     $$CORE_ROOT_DIR/DocxRenderer/DocxRenderer.pro,\
-                                        kernel unicodeconverter graphics)
-    addSubProject(htmlfile2,        $$CORE_ROOT_DIR/HtmlFile2/HtmlFile2.pro,\
-                                        kernel unicodeconverter graphics network)
-    addSubProject(doctrenderer,     $$CORE_ROOT_DIR/DesktopEditor/doctrenderer/doctrenderer.pro,\
-                                        kernel unicodeconverter graphics)
-    addSubProject(fb2file,          $$CORE_ROOT_DIR/Fb2File/Fb2File.pro,\
-                                        kernel unicodeconverter graphics)
-    addSubProject(epubfile,         $$CORE_ROOT_DIR/EpubFile/CEpubFile.pro,\
-                                        kernel unicodeconverter graphics htmlfile2)
-}
-!no_x2t {
-    addSubProject(docxformat,   $$CORE_ROOT_DIR/OOXML/Projects/Linux/DocxFormatLib/DocxFormatLib.pro)
-    addSubProject(pptxformat,   $$CORE_ROOT_DIR/OOXML/Projects/Linux/PPTXFormatLib/PPTXFormatLib.pro)
-    addSubProject(xlsbformat,   $$CORE_ROOT_DIR/OOXML/Projects/Linux/XlsbFormatLib/XlsbFormatLib.pro)
-
-    addSubProject(docformat,    $$CORE_ROOT_DIR/MsBinaryFile/Projects/DocFormatLib/Linux/DocFormatLib.pro)
-    addSubProject(pptformat,    $$CORE_ROOT_DIR/MsBinaryFile/Projects/PPTFormatLib/Linux/PPTFormatLib.pro)
-    addSubProject(xlsformat,    $$CORE_ROOT_DIR/MsBinaryFile/Projects/XlsFormatLib/Linux/XlsFormatLib.pro)
-    addSubProject(vbaformat,    $$CORE_ROOT_DIR/MsBinaryFile/Projects/VbaFormatLib/Linux/VbaFormatLib.pro)
-
-    addSubProject(txtxmlformat, $$CORE_ROOT_DIR/TxtFile/Projects/Linux/TxtXmlFormatLib.pro)
-    addSubProject(rtfformat,    $$CORE_ROOT_DIR/RtfFile/Projects/Linux/RtfFormatLib.pro)
-    addSubProject(odffile,      $$CORE_ROOT_DIR/OdfFile/Projects/Linux/OdfFormatLib.pro)
-    
-    addSubProject(bindocument,  $$CORE_ROOT_DIR/OOXML/Projects/Linux/BinDocument/BinDocument.pro)
-
-    addSubProject(x2t,          $$CORE_ROOT_DIR/X2tConverter/build/Qt/X2tConverter.pro,\
-                                    docxformat pptxformat xlsbformat docformat pptformat xlsformat vbaformat txtxmlformat rtfformat odffile cfcpp bindocument fb2file epubfile docxrenderer)
-}
-
-!no_use_common_binary {
-    addSubProject(allfontsgen,    $$CORE_ROOT_DIR/DesktopEditor/AllFontsGen/AllFontsGen.pro,\
-                                      kernel unicodeconverter graphics)
-    addSubProject(allthemesgen,   $$CORE_ROOT_DIR/DesktopEditor/allthemesgen/allthemesgen.pro,\
-                                      kernel unicodeconverter graphics)
-    addSubProject(docbuilder,     $$CORE_ROOT_DIR/DesktopEditor/doctrenderer/app_builder/docbuilder.pro,\
-                                      kernel unicodeconverter graphics doctrenderer)
-    addSubProject(pluginsmanager, $$CORE_ROOT_DIR/DesktopEditor/pluginsmanager/pluginsmanager.pro,\
-                                      kernel)
-    addSubProject(vboxtester,     $$CORE_ROOT_DIR/DesktopEditor/vboxtester/vboxtester.pro,\
-                                      kernel)
-}
-
-!no_tests {
-    addSubProject(standardtester,  $$CORE_ROOT_DIR/Test/Applications/StandardTester/standardtester.pro)
-    addSubProject(x2ttester,       $$CORE_ROOT_DIR/Test/Applications/x2tTester/x2ttester.pro)
-    addSubProject(metafiletester,  $$CORE_ROOT_DIR/Test/Applications/MetafileTester/MetafileTester.pro)
-
-    #TODO:
-    !linux_arm64:addSubProject(ooxml_crypt, $$CORE_ROOT_DIR/OfficeCryptReader/ooxml_crypt/ooxml_crypt.pro)
-}
-
-core_and_multimedia {
-    addSubProject(videoplayer,     $$ROOT_DIR/desktop-sdk/ChromiumBasedEditors/videoplayerlib/videoplayerlib.pro,\
-                                       kernel unicodeconverter graphics)
-}
-desktop {
-    message(desktop)
-    addSubProject(hunspell,             $$CORE_ROOT_DIR/Common/3dParty/hunspell/qt/hunspell.pro)
-    addSubProject(ooxmlsignature,       $$CORE_ROOT_DIR/DesktopEditor/xmlsec/src/ooxmlsignature.pro,\
-                                            kernel unicodeconverter graphics)
-    addSubProject(documentscore,        $$ROOT_DIR/desktop-sdk/ChromiumBasedEditors/lib/ascdocumentscore.pro,\
-                                            kernel unicodeconverter graphics hunspell ooxmlsignature htmlrenderer pdffile djvufile xpsfile)
-    addSubProject(documentscore_helper, $$ROOT_DIR/desktop-sdk/ChromiumBasedEditors/lib/ascdocumentscore_helper.pro,\
-                                            documentscore)
-    !core_mac {
-        addSubProject(qtdocumentscore,  $$ROOT_DIR/desktop-sdk/ChromiumBasedEditors/lib/qt_wrapper/qtascdocumentscore.pro,\
-                                            documentscore)
-    }
-
-    !no_desktop_apps {
-        core_windows:addSubProject(projicons,              $$ROOT_DIR/desktop-apps/win-linux/extras/projicons/ProjIcons.pro,\
-                                                               documentscore videoplayer)
-        core_windows:!build_xp:addSubProject(updatedaemon, $$ROOT_DIR/desktop-apps/win-linux/extras/update-daemon/UpdateDaemon.pro)
-        addSubProject(desktopapp,                          $$ROOT_DIR/desktop-apps/win-linux/ASCDocumentEditor.pro,\
-                                                               documentscore videoplayer)
-    }
-}
-
-mobile {
-    message(mobile)
-    !desktop {
-        addSubProject(hunspell, $$CORE_ROOT_DIR/Common/3dParty/hunspell/qt/hunspell.pro)
-    }
-}
-
-osign {
-    addSubProject(osign, $$CORE_ROOT_DIR/DesktopEditor/xmlsec/src/osign/lib/osign.pro)
-}

defaults

@@ -1,3 +1,3 @@
-sdkjs-plugin="photoeditor, macros, ocr, translator, thesaurus, youtube, highlightcode, drawio, zotero"
-sdkjs-plugin-server="speech, zotero, mendeley, speechrecognition"
+sdkjs-plugin="photoeditor, macros, ocr, translator, thesaurus, youtube, highlightcode, zotero"
+sdkjs-plugin-server="speech, zotero, mendeley, speechrecognition, drawio"
 sdkjs-addons="sdkjs-forms"

make.py

@@ -1,11 +1,14 @@
 #!/usr/bin/env python
 
+import os 
 import sys
-sys.path.append('scripts')
-sys.path.append('scripts/develop')
-sys.path.append('scripts/develop/vendor')
-sys.path.append('scripts/core_common')
-sys.path.append('scripts/core_common/modules')
+__dir__name__ = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(__dir__name__ + '/scripts')
+sys.path.append(__dir__name__ + '/scripts/develop')
+sys.path.append(__dir__name__ + '/scripts/develop/vendor')
+sys.path.append(__dir__name__ + '/scripts/core_common')
+sys.path.append(__dir__name__ + '/scripts/core_common/modules')
+sys.path.append(__dir__name__ + '/scripts/core_common/modules/android')
 import config
 import base
 import build

make_package.py

@@ -68,9 +68,11 @@ utils.delete_file(common.deploy_data)
 if "core" in common.targets:
   package_core.make()
 if "closuremaps_opensource" in common.targets:
-  package_core.deploy_closuremaps("opensource")
+  package_core.deploy_closuremaps_sdkjs("opensource")
+  package_core.deploy_closuremaps_webapps("opensource")
 if "closuremaps_commercial" in common.targets:
-  package_core.deploy_closuremaps("commercial")
+  package_core.deploy_closuremaps_sdkjs("commercial")
+  package_core.deploy_closuremaps_webapps("commercial")
 if "desktop" in common.targets:
   package_desktop.make()
 if "builder" in common.targets:

scripts/base.py

@@ -292,17 +292,34 @@ def copy_exe(src, dst, name):
   copy_file(src + "/" + name + exe_ext, dst + "/" + name + exe_ext)
   return
 
+def readFileCommon(path):
+  file_data = ""
+  try:
+    with open(get_path(path), "r") as file:
+      file_data = file.read()
+  except Exception as e:
+    with open(get_path(path), "r", encoding="utf-8") as file:
+      file_data = file.read()
+  return file_data
+
+def writeFileCommon(path, data):
+  file_data = ""
+  try:
+    with open(get_path(path), "w") as file:
+      file.write(data)
+  except Exception as e:
+    with open(get_path(path), "w", encoding="utf-8") as file:
+      file.write(data)
+  return
+
 def replaceInFile(path, text, textReplace):
   if not is_file(path):
     print("[replaceInFile] file not exist: " + path)
     return
-  filedata = ""
-  with open(get_path(path), "r") as file:
-    filedata = file.read()
+  filedata = readFileCommon(path)
   filedata = filedata.replace(text, textReplace)
   delete_file(path)
-  with open(get_path(path), "w") as file:
-    file.write(filedata)
+  writeFileCommon(path, filedata)
   return
 def replaceInFileUtf8(path, text, textReplace):
   if not is_file(path):
@@ -320,28 +337,21 @@ def replaceInFileRE(path, pattern, textReplace):
   if not is_file(path):
     print("[replaceInFile] file not exist: " + path)
     return
-  filedata = ""
-  with open(get_path(path), "r") as file:
-    filedata = file.read()
+  filedata = readFileCommon(path)
   filedata = re.sub(pattern, textReplace, filedata)
   delete_file(path)
-  with open(get_path(path), "w") as file:
-    file.write(filedata)
+  writeFileCommon(path, filedata)
   return
 
 def readFile(path):
   if not is_file(path):
     return ""
-  filedata = ""
-  with open(get_path(path), "r") as file:
-    filedata = file.read()
-  return filedata
+  return readFileCommon(path)
 
 def writeFile(path, data):
   if is_file(path):
     delete_file(path)
-  with open(get_path(path), "w") as file:
-    file.write(data)
+  writeFileCommon(path, data)
   return
 
 # system cmd methods ------------------------------------
@@ -687,6 +697,22 @@ def check_congig_option_with_platfom(platform, option_name):
     return True
   return False
 
+def correct_makefile_after_qmake(platform, file):
+  if (0 == platform.find("android")):
+    if ("android_arm64_v8a" == platform):
+      replaceInFile(file, "_arm64-v8a.a", ".a")
+      replaceInFile(file, "_arm64-v8a.so", ".so")
+    if ("android_armv7" == platform):
+      replaceInFile(file, "_armeabi-v7a.a", ".a")
+      replaceInFile(file, "_armeabi-v7a.so", ".so")
+    if ("android_x86_64" == platform):
+      replaceInFile(file, "_x86_64.a", ".a")
+      replaceInFile(file, "_x86_64.so", ".so")
+    if ("android_x86" == platform):
+      replaceInFile(file, "_x86.a", ".a")
+      replaceInFile(file, "_x86.so", ".so")
+  return
+
 def qt_config_platform_addon(platform):
   config_addon = ""
   if (0 == platform.find("win")):
@@ -741,6 +767,21 @@ def qt_major_version():
   qt_dir = qt_version()
   return qt_dir.split(".")[0]
 
+def qt_version_decimal():
+  qt_dir = qt_version()
+  return 10 * int(qt_dir.split(".")[0]) + int(qt_dir.split(".")[1])
+
+def qt_config_as_param(value):
+  qt_version = qt_version_decimal()
+  ret_params = []
+  if (66 > qt_version):
+    ret_params.append("CONFIG+=" + value)
+  else:
+    params = value.split()
+    for name in params:
+      ret_params.append("CONFIG+=" + name)
+  return ret_params
+
 def qt_copy_lib(lib, dir):
   qt_dir = get_env("QT_DEPLOY")
   if ("windows" == host_platform()):
@@ -1291,9 +1332,11 @@ def copy_marketplace_plugin(dst_dir, is_name_as_guid=False, is_desktop_local=Fal
     delete_dir(dst_dir_path + "/store/plugin-dev")
   return
 
-def copy_sdkjs_plugins(dst_dir, is_name_as_guid=False, is_desktop_local=False):
+def copy_sdkjs_plugins(dst_dir, is_name_as_guid=False, is_desktop_local=False, isXp=False):
   plugins_dir = __file__script__path__ + "/../../onlyoffice.github.io/sdkjs-plugins/content"
   plugins_list_config = config.option("sdkjs-plugin")
+  if isXp:
+    plugins_list_config="photoeditor, macros, drawio, highlightcode, doc2md"
   if ("" == plugins_list_config):
     return
   plugins_list = plugins_list_config.rsplit(", ")

scripts/build.py

@@ -3,9 +3,13 @@
 import config
 import base
 import os
-import multiprocessing
+import sys
+sys.path.append(os.path.dirname(__file__) + "/..")
+import sln
+import qmake
 
-def make_pro_file(makefiles_dir, pro_file, qmake_config_addon=""):
+# make solution
+def make(solution=""):
   platforms = config.option("platform").split()
   for platform in platforms:
     if not platform in config.platforms:
@@ -14,94 +18,15 @@ def make_pro_file(makefiles_dir, pro_file, qmake_config_addon=""):
     print("------------------------------------------")
     print("BUILD_PLATFORM: " + platform)
     print("------------------------------------------")
-    old_env = dict(os.environ)
 
-    # if you need change output libraries path - set the env variable
-    # base.set_env("DESTDIR_BUILD_OVERRIDE", os.getcwd() + "/out/android/" + config.branding() + "/mobile")
+    if ("" == solution):
+      solution = "./sln.json"
+    projects = sln.get_projects(solution, platform)
 
-    isAndroid = False if (-1 == platform.find("android")) else True
-    if isAndroid:
-      toolchain_platform = "linux-x86_64"
-      if ("mac" == base.host_platform()):
-        toolchain_platform = "darwin-x86_64"
-      base.set_env("ANDROID_NDK_HOST", toolchain_platform)
-      old_path = base.get_env("PATH")
-      new_path = base.qt_setup(platform) + "/bin:"
-      new_path += (base.get_env("ANDROID_NDK_ROOT") + "/toolchains/llvm/prebuilt/" + toolchain_platform + "/bin:")
-      new_path += old_path
-      base.set_env("PATH", new_path)
-      base.set_env("ANDROID_NDK_PLATFORM", "android-21")
-
-    if (-1 != platform.find("ios")):
-      base.hack_xcode_ios()
-
-    # makefile suffix
-    file_suff = platform
-    if (config.check_option("config", "debug")):
-      file_suff += "_debug_"
-    file_suff += config.option("branding")
-
-    # setup qt
-    qt_dir = base.qt_setup(platform)
-    base.set_env("OS_DEPLOY", platform)
-
-    # qmake CONFIG+=...
-    config_param = base.qt_config(platform)
-    if ("" != qmake_config_addon):
-      config_param += (" " + qmake_config_addon)
-
-    # qmake ADDON
-    qmake_addon = []
-    if ("" != config.option("qmake_addon")):
-      qmake_addon = config.option("qmake_addon").split()
-
-    if not base.is_file(qt_dir + "/bin/qmake") and not base.is_file(qt_dir + "/bin/qmake.exe"):
-      print("THIS PLATFORM IS NOT SUPPORTED")
-      continue
-
-    # non windows platform
-    if not base.is_windows():
-      if base.is_file(makefiles_dir + "/build.makefile_" + file_suff):
-        base.delete_file(makefiles_dir + "/build.makefile_" + file_suff)
-      print("make file: " + makefiles_dir + "/build.makefile_" + file_suff)
-      base.cmd(qt_dir + "/bin/qmake", ["-nocache", pro_file, "CONFIG+=" + config_param] + qmake_addon)
-      if ("1" == config.option("clean")):
-        base.cmd_and_return_cwd(base.app_make(), ["clean", "-f", makefiles_dir + "/build.makefile_" + file_suff], True)
-        base.cmd_and_return_cwd(base.app_make(), ["distclean", "-f", makefiles_dir + "/build.makefile_" + file_suff], True)
-        base.cmd(qt_dir + "/bin/qmake", ["-nocache", pro_file, "CONFIG+=" + config_param] + qmake_addon)
-        if not base.is_file(pro_file):
-          base.cmd(qt_dir + "/bin/qmake", ["-nocache", pro_file, "CONFIG+=" + config_param] + qmake_addon)
-      if ("0" != config.option("multiprocess")):
-        base.cmd_and_return_cwd(base.app_make(), ["-f", makefiles_dir + "/build.makefile_" + file_suff, "-j" + str(multiprocessing.cpu_count())])
-      else:
-        base.cmd_and_return_cwd(base.app_make(), ["-f", makefiles_dir + "/build.makefile_" + file_suff])
-    else:
-      qmake_bat = []
-      qmake_bat.append("call \"" + config.option("vs-path") + "/vcvarsall.bat\" " + ("x86" if base.platform_is_32(platform) else "x64"))
-      qmake_bat.append("if exist ./" + makefiles_dir + "/build.makefile_" + file_suff + " del /F ./" + makefiles_dir + "/build.makefile_" + file_suff)
-      qmake_addon_string = ""
-      if ("" != config.option("qmake_addon")):
-        qmake_addon_string = " " + (" ").join(["\"" + addon + "\"" for addon in qmake_addon])
-      qmake_bat.append("call \"" + qt_dir + "/bin/qmake\" -nocache " + pro_file + " \"CONFIG+=" + config_param + "\"" + qmake_addon_string)
-      if ("1" == config.option("clean")):
-        qmake_bat.append("call nmake clean -f " + makefiles_dir + "/build.makefile_" + file_suff)
-        qmake_bat.append("call nmake distclean -f " + makefiles_dir + "/build.makefile_" + file_suff)
-        qmake_bat.append("call \"" + qt_dir + "/bin/qmake\" -nocache " + pro_file + " \"CONFIG+=" + config_param + "\"" + qmake_addon_string)
-      if ("0" != config.option("multiprocess")):
-        qmake_bat.append("set CL=/MP")
-      qmake_bat.append("call nmake -f " + makefiles_dir + "/build.makefile_" + file_suff)
-      base.run_as_bat(qmake_bat)
-      
-    os.environ.clear()
-    os.environ.update(old_env)
-
-    base.delete_file(".qmake.stash")
-
-# make build.pro
-def make():
-  make_pro_file("makefiles", "build.pro")
-  if config.check_option("platform", "ios") and config.check_option("config", "bundle_xcframeworks"):
-    make_pro_file("makefiles", "build.pro", "xcframework_platform_ios_simulator")
+    for pro in projects:
+      qmake.make(platform, pro)
+      if config.check_option("platform", "ios") and config.check_option("config", "bundle_xcframeworks"):
+        qmake.make(platform, pro, "xcframework_platform_ios_simulator")
 
   if config.check_option("module", "builder") and base.is_windows() and "onlyoffice" == config.branding():
     # check replace

scripts/build_js.py

@@ -65,7 +65,8 @@ def make():
     
     build_interface(base_dir + "/../desktop-apps/common/loginpage/build")
     base.copy_file(base_dir + "/../desktop-apps/common/loginpage/deploy/index.html", out_dir + "/desktop/index.html")
-  
+    base.copy_file(base_dir + "/../desktop-apps/common/loginpage/deploy/noconnect.html", out_dir + "/desktop/noconnect.html")
+
   # mobile
   if config.check_option("module", "mobile"):
     build_sdk_native(base_dir + "/../sdkjs/build", False)
@@ -73,20 +74,27 @@ def make():
     base.create_dir(out_dir + "/mobile/sdkjs")
     vendor_dir_src = base_dir + "/../web-apps/vendor/"
     sdk_dir_src = base_dir + "/../sdkjs/deploy/sdkjs/"
+  
+    prefix_js = [
+      vendor_dir_src + "xregexp/xregexp-all-min.js", 
+      base_dir + "/../sdkjs/common/Native/native.js",
+      base_dir + "/../sdkjs-native/common/common.js",
+      base_dir + "/../sdkjs/common/Native/jquery_native.js"
+    ]
 
-    base.join_scripts([vendor_dir_src + "xregexp/xregexp-all-min.js", 
-                   vendor_dir_src + "underscore/underscore-min.js",
-                   base_dir + "/../sdkjs/common/Native/native.js",
-                   base_dir + "/../sdkjs/common/Native/Wrappers/common.js",
-                   base_dir + "/../sdkjs/common/Native/jquery_native.js"], 
-                   out_dir + "/mobile/sdkjs/banners.js")
+    postfix_js = [
+      base_dir + "/../sdkjs/common/libfont/engine/fonts_native.js",
+      base_dir + "/../sdkjs/common/Charts/ChartStyles.js"
+    ]
+
+    base.join_scripts(prefix_js, out_dir + "/mobile/sdkjs/banners.js")
 
     base.create_dir(out_dir + "/mobile/sdkjs/word")
-    base.join_scripts([out_dir + "/mobile/sdkjs/banners.js", sdk_dir_src + "word/sdk-all-min.js", sdk_dir_src + "word/sdk-all.js"], out_dir + "/mobile/sdkjs/word/script.bin")
+    base.join_scripts([out_dir + "/mobile/sdkjs/banners.js", sdk_dir_src + "word/sdk-all-min.js", sdk_dir_src + "word/sdk-all.js"] + postfix_js, out_dir + "/mobile/sdkjs/word/script.bin")
     base.create_dir(out_dir + "/mobile/sdkjs/cell")
-    base.join_scripts([out_dir + "/mobile/sdkjs/banners.js", sdk_dir_src + "cell/sdk-all-min.js", sdk_dir_src + "cell/sdk-all.js"], out_dir + "/mobile/sdkjs/cell/script.bin")
+    base.join_scripts([out_dir + "/mobile/sdkjs/banners.js", sdk_dir_src + "cell/sdk-all-min.js", sdk_dir_src + "cell/sdk-all.js"] + postfix_js, out_dir + "/mobile/sdkjs/cell/script.bin")
     base.create_dir(out_dir + "/mobile/sdkjs/slide")
-    base.join_scripts([out_dir + "/mobile/sdkjs/banners.js", sdk_dir_src + "slide/sdk-all-min.js", sdk_dir_src + "slide/sdk-all.js"], out_dir + "/mobile/sdkjs/slide/script.bin")
+    base.join_scripts([out_dir + "/mobile/sdkjs/banners.js", sdk_dir_src + "slide/sdk-all-min.js", sdk_dir_src + "slide/sdk-all.js"] + postfix_js, out_dir + "/mobile/sdkjs/slide/script.bin")
 
     base.delete_file(out_dir + "/mobile/sdkjs/banners.js")
   return
@@ -132,7 +140,10 @@ def build_sdk_builder(directory):
 def build_sdk_native(directory, minimize=True):
   #_run_npm_cli(directory)
   _run_npm(directory)
-  _run_grunt(directory, get_build_param(minimize) + ["--mobile=true"] + base.sdkjs_addons_param())
+  addons = base.sdkjs_addons_param()
+  if not config.check_option("sdkjs-addons", "sdkjs-native"):
+    addons.append("--addon=sdkjs-native")
+  _run_grunt(directory, get_build_param(minimize) + ["--mobile=true"] + addons)
   return
 
 def build_js_develop(root_dir):

scripts/build_js_native.py

@@ -14,6 +14,9 @@ parser.add_option("--output",
 parser.add_option("--write-version",
                   action="store_true", dest="write_version", default=False,
                   help="Create version file of build")
+parser.add_option("--minimize",
+                  action="store", type="string", dest="minimize", default="0",
+                  help="Is minimized version")
 (options, args) = parser.parse_args(arguments)
 
 def write_version_files(output_dir):
@@ -32,7 +35,11 @@ def write_version_files(output_dir):
 # parse configuration
 config.parse()
 config.parse_defaults()
-config.extend_option("jsminimize", "0")
+
+isMinimize = False
+if ("1" == options.minimize or "true" == options.minimize):
+  isMinimize = True
+config.set_option("jsminimize", "disable")
 
 branding = config.option("branding-name")
 if ("" == branding):
@@ -46,23 +53,30 @@ if (options.output):
 
 base.create_dir(out_dir)
 
-build_js.build_sdk_native(base_dir + "/../sdkjs/build")
+build_js.build_sdk_native(base_dir + "/../sdkjs/build", isMinimize)
 vendor_dir_src = base_dir + "/../web-apps/vendor/"
 sdk_dir_src = base_dir + "/../sdkjs/deploy/sdkjs/"
 
-base.join_scripts([vendor_dir_src + "xregexp/xregexp-all-min.js", 
-               vendor_dir_src + "underscore/underscore-min.js",
-               base_dir + "/../sdkjs/common/Native/native.js",
-               base_dir + "/../sdkjs/common/Native/Wrappers/common.js",
-               base_dir + "/../sdkjs/common/Native/jquery_native.js"], 
-               out_dir + "/banners.js")
+prefix_js = [
+  vendor_dir_src + "xregexp/xregexp-all-min.js", 
+  base_dir + "/../sdkjs/common/Native/native.js",
+  base_dir + "/../sdkjs-native/common/common.js",
+  base_dir + "/../sdkjs/common/Native/jquery_native.js"
+]
+
+postfix_js = [
+  base_dir + "/../sdkjs/common/libfont/engine/fonts_native.js",
+  base_dir + "/../sdkjs/common/Charts/ChartStyles.js"
+]
+
+base.join_scripts(prefix_js, out_dir + "/banners.js")
 
 base.create_dir(out_dir + "/word")
-base.join_scripts([out_dir + "/banners.js", sdk_dir_src + "word/sdk-all-min.js", sdk_dir_src + "word/sdk-all.js"], out_dir + "/word/script.bin")
+base.join_scripts([out_dir + "/banners.js", sdk_dir_src + "word/sdk-all-min.js", sdk_dir_src + "word/sdk-all.js"] + postfix_js, out_dir + "/word/script.bin")
 base.create_dir(out_dir + "/cell")
-base.join_scripts([out_dir + "/banners.js", sdk_dir_src + "cell/sdk-all-min.js", sdk_dir_src + "cell/sdk-all.js"], out_dir + "/cell/script.bin")
+base.join_scripts([out_dir + "/banners.js", sdk_dir_src + "cell/sdk-all-min.js", sdk_dir_src + "cell/sdk-all.js"] + postfix_js, out_dir + "/cell/script.bin")
 base.create_dir(out_dir + "/slide")
-base.join_scripts([out_dir + "/banners.js", sdk_dir_src + "slide/sdk-all-min.js", sdk_dir_src + "slide/sdk-all.js"], out_dir + "/slide/script.bin")
+base.join_scripts([out_dir + "/banners.js", sdk_dir_src + "slide/sdk-all-min.js", sdk_dir_src + "slide/sdk-all.js"] + postfix_js, out_dir + "/slide/script.bin")
 
 base.delete_file(out_dir + "/banners.js")
 

scripts/config.py

@@ -182,6 +182,9 @@ def extend_option(name, value):
   else:
     options[name] = value
 
+def set_option(name, value):
+  options[name] = value
+
 def branding():
   branding = option("branding-name")
   if ("" == branding):

scripts/core_common/modules/android/android_ndk.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python
+
+import sys
+sys.path.append('../../../scripts')
+import base
+import os
+import re
+
+def get_android_ndk_version():
+  env_val = base.get_env("ANDROID_NDK_ROOT")
+  if (env_val == ""):
+    env_val = "21.1.6352462" 
+  return env_val.strip("/").split("/")[-1]
+
+def get_android_ndk_version_major():
+  val = get_android_ndk_version().split(".")[0]
+  val = re.sub("[^0-9]", "", val)
+  return int(val)
+
+def get_sdk_api():
+  if (23 > get_android_ndk_version_major()):
+    return "21"
+  return "23"
+
+global archs
+archs = ["arm64", "arm", "x86_64", "x86"]
+
+global platforms
+platforms = {
+  "arm64" : {
+    "abi"    : "arm64-v8a",
+    "target" : "aarch64-linux-android",
+    "dst"    : "arm64_v8a",
+    "api"    : get_sdk_api(),
+    "old"    : "aarch64-linux-android"
+  },
+  "arm" : {
+    "abi"    : "armeabi-v7a",
+    "target" : "armv7a-linux-androideabi",
+    "dst"    : "armv7",
+    "api"    : get_sdk_api(),
+    "old"    : "arm-linux-android"
+  },
+  "x86_64" : {
+    "arch"   : "x86_64",
+    "target" : "x86_64-linux-android",
+    "dst"    : "x86_64",
+    "api"    : get_sdk_api(),
+    "old"    : "x86_64-linux-android"
+  },
+  "x86" : {
+    "arch"   : "x86",
+    "target" : "i686-linux-android",
+    "dst"    : "x86",
+    "api"    : get_sdk_api(),
+    "old"    : "i686-linux-android"
+  }
+}
+
+# todo: check arm host!
+global host
+
+if ("linux" == base.host_platform()):
+  host = {
+    "name" : "linux",
+    "arch" : "linux-x86_64"
+  }
+else:
+  host = {
+    "name" : "darwin",
+    "arch" : "darwin-x86_64"
+  }
+
+def get_android_ndk_version():
+  #return "26.2.11394342"
+  return "21.1.6352462"
+
+def get_android_ndk_version_major():
+  return int(get_android_ndk_version().split(".")[0])
+
+def get_options_dict_as_array(opts):
+  value = []
+  for key in opts:
+    value.append(key + "=" + opts[key])
+  return value
+
+def get_options_array_as_string(opts):
+  return " ".join(opts)
+
+def ndk_dir():
+  return base.get_env("ANDROID_NDK_ROOT")
+
+def sdk_dir():
+  ndk_path = ndk_dir()
+  if (-1 != ndk_path.find("/ndk/")):
+    return ndk_path + "/../.."
+  return ndk_path + "/.."
+
+def toolchain_dir():
+  return ndk_dir() + "/toolchains/llvm/prebuilt/" + host["arch"]
+
+def prepare_platform(arch, cpp_standard=11):
+  target = platforms[arch]["target"]
+  api = platforms[arch]["api"]
+
+  ndk_directory = ndk_dir()
+  toolchain = toolchain_dir()
+
+  base.set_env("TARGET", target)
+  base.set_env("TOOLCHAIN", toolchain)
+  base.set_env("NDK_STANDARD_ROOT", toolchain)
+  base.set_env("ANDROIDVER", api)
+  base.set_env("ANDROID_API", api)
+
+  base.set_env("AR", toolchain + "/bin/llvm-ar")
+  base.set_env("AS", toolchain + "/bin/llvm-as")
+  base.set_env("LD", toolchain + "/bin/ld")
+  base.set_env("RANLIB", toolchain + "/bin/llvm-ranlib")
+  base.set_env("STRIP", toolchain + "/bin/llvm-strip")
+
+  base.set_env("CC", target + api + "-clang")
+  base.set_env("CXX", target + api + "-clang++")
+
+  ld_flags = "-Wl,--gc-sections,-rpath-link=" + toolchain + "/sysroot/usr/lib/"
+  if (23 > get_android_ndk_version_major()):
+    ld_flags += (" -L" + toolchain + "/" + platforms[arch]["old"] + "/lib")
+    ld_flags += (" -L" + toolchain + "/sysroot/usr/lib/" + platforms[arch]["old"] + "/" + api)
+
+  base.set_env("LDFLAGS", ld_flags)
+  base.set_env("PATH", toolchain + "/bin" + os.pathsep + base.get_env("PATH"))
+
+  cflags = [
+    "-Os",
+    "-ffunction-sections",
+    "-fdata-sections",
+    "-fvisibility=hidden",
+
+    "-Wno-unused-function",
+
+    "-fPIC",
+
+    "-I" + toolchain + "/sysroot/usr/include",
+
+    "-D__ANDROID_API__=" + api,
+    "-DANDROID"
+  ]
+
+  cflags_string = " ".join(cflags)
+  cppflags_string = cflags_string
+  
+  if (cpp_standard >= 11):
+    cppflags_string += " -std=c++11"
+
+  base.set_env("CFLAGS", cflags_string)
+  base.set_env("CXXFLAGS", cppflags_string)
+  base.set_env("CPPPLAGS", cflags_string)
+  return
+
+def extend_cflags(params):
+  base.set_env("CFLAGS", base.get_env("CFLAGS") + " " + params)
+  base.set_env("CPPFLAGS", base.get_env("CFLAGS"))
+  return
+
+def extend_cxxflags(params):
+  base.set_env("CXXFLAGS", base.get_env("CXXFLAGS") + " " + params)
+  return
+
+def extend_ldflags(params):
+  base.set_env("LDFLAGS", base.get_env("LDFLAGS") + " " + params)
+  return

scripts/core_common/modules/android/curl_android.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+
+import sys
+sys.path.append('../../../scripts')
+import base
+import os
+import android_ndk
+
+current_dir = base.get_script_dir() + "/../../core/Common/3dParty/curl"
+current_dir = os.path.abspath(current_dir)
+if not current_dir.endswith("/"):
+  current_dir += "/"
+
+lib_version = "curl-7_68_0"
+lib_name = "curl-7.68.0"
+
+def fetch():
+  if not base.is_dir(current_dir + lib_name):
+    base.cmd("curl", ["-L", "-s", "-o", current_dir + lib_name + ".tar.gz", 
+      "https://github.com/curl/curl/releases/download/" + lib_version + "/" + lib_name + ".tar.gz"])
+    base.cmd("tar", ["xfz", current_dir + lib_name + ".tar.gz", "-C", current_dir])
+  return
+
+def build_host():
+  return
+
+def build_arch(arch):
+  dst_dir = current_dir + "build/android/" + android_ndk.platforms[arch]["dst"]
+  if base.is_dir(dst_dir):
+    return
+
+  android_ndk.prepare_platform(arch)
+
+  ndk_dir = android_ndk.ndk_dir()
+  toolchain = android_ndk.toolchain_dir()
+
+  base.set_env("ANDROID_NDK_HOME", ndk_dir)
+  base.set_env("ANDROID_NDK", ndk_dir)
+
+  arch_build_dir = os.path.abspath(current_dir + "build/android/tmp")
+  base.create_dir(arch_build_dir)
+
+  old_cur = os.getcwd()
+  os.chdir(current_dir + lib_name)
+
+  params = []
+  if ("arm64" == arch):
+    params.append("--host=aarch64-linux-android")
+  elif ("arm" == arch):
+    params.append("--host=arm-linux-androideabi")
+  elif ("x86_64" == arch):
+    params.append("--host=x86_64-linux-android")
+  elif ("x86" == arch):
+    params.append("--host=i686-linux-android")
+
+  openssl_dir = os.path.abspath(current_dir + "../openssl/build/android/" + android_ndk.platforms[arch]["dst"])
+
+  params.append("--enable-ipv6")
+  params.append("--enable-static")
+  params.append("--disable-shared")
+  params.append("--prefix=" + arch_build_dir)
+  params.append("--with-ssl=" + openssl_dir)
+
+  base.cmd("./configure", params)
+
+  base.cmd("make", ["clean"])
+  base.cmd("make", ["-j4"])
+  base.cmd("make", ["install"])
+
+  os.chdir(old_cur)
+
+  base.create_dir(dst_dir)
+  base.copy_file(arch_build_dir + "/lib/libcurl.a", dst_dir)
+  base.copy_dir(arch_build_dir + "/include", current_dir + "build/android/include")
+
+  base.delete_dir(arch_build_dir)
+  return
+
+def make():
+  old_env = dict(os.environ)
+
+  fetch()
+
+  build_host()
+
+  for arch in android_ndk.archs:
+    build_arch(arch)
+
+  os.environ.clear()
+  os.environ.update(old_env)
+  return
+
+if __name__ == "__main__":
+  make()

scripts/core_common/modules/android/icu_android.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python
+
+import sys
+sys.path.append('../../../scripts')
+import base
+import os
+import android_ndk
+
+current_dir = base.get_script_dir() + "/../../core/Common/3dParty/icu/android"
+current_dir = os.path.abspath(current_dir)
+if not current_dir.endswith("/"):
+  current_dir += "/"
+
+icu_major = "58"
+icu_minor = "3"
+
+options = {
+  "--enable-strict"       : "no",
+  "--enable-extras"       : "no",
+  "--enable-draft"        : "yes",
+  "--enable-samples"      : "no",
+  "--enable-tests"        : "no",
+  "--enable-renaming"     : "yes",
+  "--enable-icuio"        : "no",
+  "--enable-layoutex"     : "no",
+  "--with-library-bits"   : "nochange",
+  "--with-library-suffix" : "",
+  "--enable-static"       : "yes",
+  "--enable-shared"       : "no",
+  "--with-data-packaging" : "archive"
+}
+
+cpp_flags_base = [
+  "-Os",
+  "-ffunction-sections",
+  "-fdata-sections",
+  "-fvisibility=hidden",
+  "-fPIC"
+]
+
+cpp_flags = [
+  "-fno-short-wchar",
+  "-fno-short-enums",
+  
+  "-DU_USING_ICU_NAMESPACE=0",
+  "-DU_HAVE_NL_LANGINFO_CODESET=0",
+  "-DU_TIMEZONE=0",
+  "-DU_DISABLE_RENAMING=0",
+  
+  "-DUCONFIG_NO_COLLATION=0",
+  "-DUCONFIG_NO_FORMATTING=0",
+  "-DUCONFIG_NO_LEGACY_CONVERSION=1",
+  "-DUCONFIG_NO_REGULAR_EXPRESSIONS=0",
+  "-DUCONFIG_NO_TRANSLITERATION=0",
+
+  "-DU_STATIC_IMPLEMENTATION"
+]
+
+def fetch_icu():
+  if not base.is_dir(current_dir + "icu"):
+    base.cmd("git", ["clone", "--depth", "1", "--branch", "maint/maint-" + icu_major, "https://github.com/unicode-org/icu.git", current_dir + "icu2"])
+    base.copy_dir(current_dir + "icu2/icu4c", current_dir + "icu")
+    base.delete_dir_with_access_error(current_dir + "icu2")
+    
+    if ("linux" == base.host_platform()):
+      base.replaceInFile(current_dir + "/icu/source/i18n/digitlst.cpp", "xlocale", "locale")
+    if False and ("mac" == base.host_platform()):
+      base.replaceInFile(current_dir + "/icu/source/tools/pkgdata/pkgdata.cpp", "cmd, \"%s %s -o %s%s %s %s%s %s %s\",", "cmd, \"%s %s -o %s%s %s %s %s %s %s\",")
+  return
+
+def build_host():
+  cross_build_dir = os.path.abspath(current_dir + "icu/cross_build")
+  if not base.is_dir(cross_build_dir):
+    base.create_dir(cross_build_dir)
+    os.chdir(cross_build_dir)
+
+    ld_flags = "-pthread"
+    if ("linux" == base.host_platform()):
+      ld_flags += " -Wl,--gc-sections"
+    else:
+      # gcc on OSX does not support --gc-sections
+      ld_flags += " -Wl,-dead_strip"
+
+    base.set_env("LDFLAGS", ld_flags)
+    base.set_env("CPPFLAGS", android_ndk.get_options_array_as_string(cpp_flags_base + cpp_flags))
+
+    host_type = "Linux"
+    if ("mac" == base.host_platform()):
+      host_type = "MacOSX/GCC"
+
+    base.cmd("../source/runConfigureICU", [host_type, "--prefix=" + cross_build_dir] + android_ndk.get_options_dict_as_array(options))
+    base.cmd("make", ["-j4"])
+    base.cmd("make", ["install"])
+
+    base.create_dir(current_dir + "build")
+    base.copy_dir(cross_build_dir + "/include", current_dir + "build/include")
+
+    os.chdir(current_dir)
+  return
+
+def build_arch(arch):
+  dst_dir = current_dir + "build/" + android_ndk.platforms[arch]["dst"]
+  if base.is_dir(dst_dir):
+    return
+
+  android_ndk.prepare_platform(arch)
+  android_ndk.extend_cflags(" ".join(cpp_flags))
+
+  ndk_dir = android_ndk.ndk_dir()
+  toolchain = android_ndk.toolchain_dir()
+
+  cross_build_dir = os.path.abspath(current_dir + "icu/cross_build")
+  arch_build_dir = os.path.abspath(current_dir + "build/tmp")
+  base.create_dir(arch_build_dir)
+  
+  os.chdir(arch_build_dir)
+  base.cmd("./../../icu/source/configure", ["--with-cross-build=" + cross_build_dir] + 
+    android_ndk.get_options_dict_as_array(options) + ["--host=" + android_ndk.platforms[arch]["target"], "--prefix=" + arch_build_dir])
+  base.cmd("make", ["-j4"])
+  os.chdir(current_dir)
+
+  base.create_dir(dst_dir)
+  base.copy_file(arch_build_dir + "/lib/libicuuc.a", dst_dir)
+  base.copy_file(arch_build_dir + "/stubdata/libicudata.a", dst_dir)
+  base.copy_file(arch_build_dir + "/data/out/icudt" + icu_major + "l.dat", dst_dir)
+
+  base.delete_dir(arch_build_dir)
+  return
+
+def make():
+  if not base.is_dir(current_dir):
+    base.create_dir(current_dir)
+
+  old_env = dict(os.environ)
+
+  fetch_icu()
+
+  build_host()
+
+  for arch in android_ndk.archs:
+    build_arch(arch)
+
+  os.environ.clear()
+  os.environ.update(old_env)
+  return
+
+if __name__ == "__main__":
+  make()

scripts/core_common/modules/android/openssl_android.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+
+import sys
+sys.path.append('../../../scripts')
+import base
+import os
+import android_ndk
+
+current_dir = base.get_script_dir() + "/../../core/Common/3dParty/openssl"
+current_dir = os.path.abspath(current_dir)
+if not current_dir.endswith("/"):
+  current_dir += "/"
+
+lib_name="openssl-1.1.1t"
+
+options = [
+  "no-shared",
+  "no-tests",
+  "enable-ssl3",
+  "enable-ssl3-method",
+  "enable-md2",
+  "no-asm"
+]
+
+def fetch():
+  if not base.is_dir(current_dir + lib_name):
+    base.cmd("curl", ["-L", "-s", "-o", current_dir + lib_name + ".tar.gz", 
+      "https://www.openssl.org/source/" + lib_name + ".tar.gz"])
+    base.cmd("tar", ["xfz", current_dir + lib_name + ".tar.gz", "-C", current_dir])
+  return
+
+def build_host():
+  # not needed, just create directories
+  if not base.is_dir(current_dir + "/build"):
+    base.create_dir(current_dir + "/build")
+  if not base.is_dir(current_dir + "/build/android"):
+    base.create_dir(current_dir + "/build/android")
+  return
+
+def build_arch(arch):
+  dst_dir = current_dir + "build/android/" + android_ndk.platforms[arch]["dst"]
+  if base.is_dir(dst_dir):
+    return
+
+  android_ndk.prepare_platform(arch)
+
+  ndk_dir = android_ndk.ndk_dir()
+  toolchain = android_ndk.toolchain_dir()
+
+  base.set_env("ANDROID_NDK_HOME", ndk_dir)
+  base.set_env("ANDROID_NDK", ndk_dir)
+
+  arch_build_dir = os.path.abspath(current_dir + "build/android/tmp")
+  base.create_dir(arch_build_dir)
+
+  old_cur = os.getcwd()
+  os.chdir(current_dir + lib_name)
+
+  base.cmd("./Configure", ["android-" + arch, "--prefix=" + arch_build_dir, "-D__ANDROID_API__=" + android_ndk.platforms[arch]["api"]] + options)
+
+  base.replaceInFile("./Makefile", "LIB_CFLAGS=", "LIB_CFLAGS=-fvisibility=hidden ")
+  base.replaceInFile("./Makefile", "LIB_CXXFLAGS=", "LIB_CXXFLAGS=-fvisibility=hidden ")
+
+  base.cmd("make", ["clean"])
+  base.cmd("make", ["-j4"])
+  base.cmd("make", ["install"])
+
+  os.chdir(old_cur)
+
+  base.create_dir(dst_dir)
+  base.create_dir(dst_dir + "/lib")
+  base.copy_file(arch_build_dir + "/lib/libcrypto.a", dst_dir + "/lib")
+  base.copy_file(arch_build_dir + "/lib/libssl.a", dst_dir + "/lib")
+  base.copy_dir(arch_build_dir + "/include", dst_dir + "/include")
+
+  base.delete_dir(arch_build_dir)
+  return
+
+def make():
+  old_env = dict(os.environ)
+
+  fetch()
+
+  build_host()
+
+  for arch in android_ndk.archs:
+    build_arch(arch)
+
+  os.environ.clear()
+  os.environ.update(old_env)
+  return
+
+if __name__ == "__main__":
+  make()

scripts/core_common/modules/boost_android.py

@@ -1,108 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../..')
-import config
-import base
-import os
-
-platforms = {
-  "arm64_v8a" : {
-    "name" : "arm64-v8a",
-    "toolset" : "arm64v8a", 
-    "clang_triple" : "aarch64-linux-android21", 
-    "tool_triple" : "aarch64-linux-android", 
-    "abi" : "aapcs",
-    "arch" : "arm",
-    "address_model" : "64",
-    "compiler_flags" : "",
-    "linker_flags" : ""
-  },
-  "armv7" : {
-    "name" : "armeabi-v7a",
-    "toolset" : "armeabiv7a", 
-    "clang_triple" : "armv7a-linux-androideabi16", 
-    "tool_triple" : "arm-linux-androideabi", 
-    "abi" : "aapcs",
-    "arch" : "arm",
-    "address_model" : "32",
-    "compiler_flags" : "-march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=softfp",
-    "linker_flags" : "-Wl,--fix-cortex-a8"
-  },
-  "x86" : {
-    "name" : "x86",
-    "toolset" : "x86", 
-    "clang_triple" : "i686-linux-android16", 
-    "tool_triple" : "i686-linux-android", 
-    "abi" : "sysv",
-    "arch" : "x86",
-    "address_model" : "32",
-    "compiler_flags" : "",
-    "linker_flags" : ""
-  },
-  "x86_64" : {
-    "name" : "x86_64",
-    "toolset" : "x8664", 
-    "clang_triple" : "x86_64-linux-android21", 
-    "tool_triple" : "x86_64-linux-android", 
-    "abi" : "sysv",
-    "arch" : "x86",
-    "address_model" : "64",
-    "compiler_flags" : "",
-    "linker_flags" : ""
-  }
-}
-
-base_dir = base.get_script_dir()
-
-def make(platform):
-  tmp_build_dir = base_dir + "/core_common/modules/boost"
-  if (base.is_dir(tmp_build_dir)):
-    base.delete_dir(tmp_build_dir)
-  base.copy_dir(base_dir + "/../tools/android/boost", tmp_build_dir)
-
-  current_platform = platforms[platform]
-
-  if (base.host_platform() == "mac"):
-    source = "prebuilt/linux-x86_64"
-    dest = "prebuilt/darwin-x86_64"
-    base.replaceInFile(tmp_build_dir + "/user-config.jam", source, dest)
-    base.replaceInFile(tmp_build_dir + "/bin/hide/as", source, dest)
-    base.replaceInFile(tmp_build_dir + "/bin/hide/strip", source, dest)
-    base.replaceInFile(tmp_build_dir + "/bin/ar", source, dest)
-    base.replaceInFile(tmp_build_dir + "/bin/clang++", source, dest)
-    base.replaceInFile(tmp_build_dir + "/bin/ranlib", source, dest)
-
-  build_dir_tmp = tmp_build_dir + "/tmp"
-
-  base.cmd("./bootstrap.sh", ["--with-libraries=filesystem,system,date_time,regex", "--prefix=../build/android_" + platform])
-  base.cmd("./b2", ["headers"])
-  base.cmd("./b2", ["--clean"])
-
-  old_path = base.get_env("PATH")
-  base.set_env("PATH", tmp_build_dir + "/bin:" + old_path)
-  base.set_env("NDK_DIR", base.get_env("ANDROID_NDK_ROOT"))
-
-  base.set_env("BFA_CLANG_TRIPLE_FOR_ABI", current_platform["clang_triple"])
-  base.set_env("BFA_TOOL_TRIPLE_FOR_ABI", current_platform["tool_triple"])
-  base.set_env("BFA_COMPILER_FLAGS_FOR_ABI", current_platform["compiler_flags"])
-  base.set_env("BFA_LINKER_FLAGS_FOR_ABI", current_platform["linker_flags"])
-
-  print(current_platform)
-  base.cmd("./b2", ["-q", "-j4",
-    "toolset=clang-" + current_platform["toolset"],
-    "binary-format=elf",
-    "address-model=" + current_platform["address_model"],
-    "architecture=" + current_platform["arch"],
-    "abi=" + current_platform["abi"],
-    "link=static",
-    "threading=multi",
-    "target-os=android",
-    "--user-config=" + tmp_build_dir + "/user-config.jam",
-    "--ignore-site-config",
-    "--layout=system",
-    "install"], True)
-
-  base.set_env("PATH", old_path)
-  base.delete_dir(tmp_build_dir)
-  return

scripts/core_common/modules/boost_qt.py

@@ -5,7 +5,7 @@ sys.path.append('../..')
 import config
 import base
 import os
-import build
+import qmake
 
 def make(src_dir, modules, build_platform="android", qmake_addon=""):
   old_cur = os.getcwd()
@@ -23,17 +23,13 @@ def make(src_dir, modules, build_platform="android", qmake_addon=""):
     pro_file_content.append("TARGET = boost_" + module)
     pro_file_content.append("TEMPLATE = lib")
     pro_file_content.append("CONFIG += staticlib")
+    if (build_platform == "android"):
+      pro_file_content.append("DEFINES += \"_HAS_AUTO_PTR_ETC=0\"")
     pro_file_content.append("")
     pro_file_content.append("CORE_ROOT_DIR = $$PWD/../../../../../..")
     pro_file_content.append("PWD_ROOT_DIR = $$PWD")
     pro_file_content.append("include($$PWD/../../../../../base.pri)")
     pro_file_content.append("")
-    pro_file_content.append("MAKEFILE=$$PWD/build.makefile_$$CORE_BUILDS_PLATFORM_PREFIX")
-    pro_file_content.append("core_debug:MAKEFILE=$$join(MAKEFILE, MAKEFILE, \"\", \"_debug_\")")
-    pro_file_content.append("build_xp:MAKEFILE=$$join(MAKEFILE, MAKEFILE, \"\", \"_xp\")")
-    pro_file_content.append("OO_BRANDING_SUFFIX = $$(OO_BRANDING)")
-    pro_file_content.append("!isEmpty(OO_BRANDING_SUFFIX):MAKEFILE=$$join(MAKEFILE, MAKEFILE, \"\", \"$$OO_BRANDING_SUFFIX\")")
-    pro_file_content.append("")
     pro_file_content.append("BOOST_SOURCES=$$PWD/../..")
     pro_file_content.append("INCLUDEPATH += $$BOOST_SOURCES")
     pro_file_content.append("INCLUDEPATH += $$PWD/include")
@@ -43,7 +39,7 @@ def make(src_dir, modules, build_platform="android", qmake_addon=""):
     pro_file_content.append("DESTDIR = $$BOOST_SOURCES/../build/" + build_platform + "/lib/$$CORE_BUILDS_PLATFORM_PREFIX")
     base.save_as_script(module_dir + "/" + module + ".pro", pro_file_content)
     os.chdir(module_dir)
-    build.make_pro_file("./", module + ".pro", qmake_addon)
+    qmake.make_all_platforms(module_dir + "/" + module + ".pro", qmake_addon)
   
   os.chdir(old_cur)
   return

scripts/core_common/modules/curl.py

@@ -2,21 +2,19 @@
 
 import sys
 sys.path.append('../..')
+sys.path.append('android')
 import config
 import subprocess
 import os
 import base
+import curl_android
 
 def make():
   path = base.get_script_dir() + "/../../core/Common/3dParty/curl"
   old_cur = os.getcwd()
   os.chdir(path)
   if (-1 != config.option("platform").find("android")):
-    if base.is_dir(path + "/build/android"):
-      os.chdir(old_cur)
-      return
-    subprocess.call(["./build-android-curl.sh"])
-
+    curl_android.make()
   elif (-1 != config.option("platform").find("ios")):
     if base.is_dir(path + "/build/ios"):
       os.chdir(old_cur)

scripts/core_common/modules/icu.py

@@ -2,26 +2,48 @@
 
 import sys
 sys.path.append('../..')
+sys.path.append('android')
 import config
 import base
 import os
+import glob
 import icu_android
 
+def fetch_icu(major, minor):
+  base.cmd("git", ["clone", "--depth", "1", "--branch", "maint/maint-" + major, "https://github.com/unicode-org/icu.git", "./icu2"])
+  base.copy_dir("./icu2/icu4c", "./icu")
+  base.delete_dir_with_access_error("icu2")
+  #base.cmd("svn", ["export", "https://github.com/unicode-org/icu/tags/release-" + icu_major + "-" + icu_minor + "/icu4c", "./icu", "--non-interactive", "--trust-server-cert"])
+  return
+
+def clear_module():
+  if base.is_dir("icu"):
+    base.delete_dir_with_access_error("icu")
+
+  # remove build
+  for child in glob.glob("./*"):
+    if base.is_dir(child):
+      base.delete_dir(child)
+
+  return
+
 def make():
   print("[fetch & build]: icu")
 
-  if (-1 != config.option("platform").find("android")):
-    icu_android.make()
-
   base_dir = base.get_script_dir() + "/../../core/Common/3dParty/icu"
   old_cur = os.getcwd()
   os.chdir(base_dir)
 
-  icu_major = "58"
-  icu_minor = "2"
+  base.check_module_version("3", clear_module)
 
+  if (-1 != config.option("platform").find("android")):
+    icu_android.make()
+
+  icu_major = "58"
+  icu_minor = "3"
+  
   if not base.is_dir("icu"):
-    base.cmd("svn", ["export", "https://github.com/unicode-org/icu/tags/release-" + icu_major + "-" + icu_minor + "/icu4c", "./icu", "--non-interactive", "--trust-server-cert"])
+    fetch_icu(icu_major, icu_minor)  
 
   if ("windows" == base.host_platform()):
     platformToolset = "v140"

scripts/core_common/modules/icu_android.py

@@ -1,172 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../..')
-import base
-import os
-
-current_dir = base.get_script_dir() + "/../../core/Common/3dParty/icu/android"
-
-toolshains_dir = current_dir + "/toolchains"
-icu_major = "58"
-icu_minor = "2"
-icu_is_shared = False
-
-current_path = base.get_env("PATH")
-
-platforms = {
-  "arm64" : {
-    "arch" : "aarch64-linux-android",
-    "bin" : "aarch64-linux-android"
-  },
-  "arm" : {
-    "arch" : "arm-linux-androideabi",
-    "bin" : "arm-linux-androideabi"
-  },
-  "x86_64" : {
-    "arch" : "x86_64-linux-android",
-    "bin" : "x86_64-linux-android"
-  },
-  "x86" : {
-    "arch" : "x86-linux-android",
-    "bin" : "i686-linux-android"
-  }
-}
-
-def build_arch(arch, api_version):
-  print("icu build: " + arch + " ----------------------------------------")
-
-  if base.is_dir(current_dir + "/icu/" + arch):
-    base.delete_dir(current_dir + "/icu/" + arch)
-  base.create_dir(current_dir + "/icu/" + arch)
-  os.chdir(current_dir + "/icu/" + arch)
-
-  base.cmd(base.get_env("ANDROID_NDK_ROOT") + "/build/tools/make-standalone-toolchain.sh", [
-    "--platform=android-" + api_version, 
-    "--install-dir=" + current_dir + "/toolchain/" + arch,
-    "--toolchain=" + platforms[arch]["arch"], 
-    "--force"
-    ])
-
-  base.set_env("PATH", current_dir + "/toolchain/" + arch + "/bin:" + current_path)
-
-  command_args = "--prefix=" + current_dir + "/build_tmp/" + arch + " --host=!!!MASK!!! --with-cross-build=" + current_dir + "/icu/cross_build CFLAGS=-Os CXXFLAGS=--std=c++11 CC=!!!MASK!!!-clang CXX=!!!MASK!!!-clang++ AR=!!!MASK!!!-ar RANLIB=!!!MASK!!!-ranlib"
-  if not icu_is_shared:
-    command_args += " --enable-static --enable-shared=no --with-data-packaging=archive CFLAGS=-fPIC CXXFLAGS=-fPIC"
-  command_args = command_args.replace("!!!MASK!!!", platforms[arch]["bin"])
-
-  base.cmd("../source/configure", command_args.split())
-  base.cmd("make", ["-j4"])
-  base.cmd("make", ["install"])
-
-  base.set_env("PATH", current_path)
-  os.chdir(current_dir)
-
-  return
-
-def make():
-  if not base.is_dir(current_dir):
-    base.create_dir(current_dir)
-
-  if base.is_dir(current_dir + "/build"):
-    return
-
-  current_dir_old = os.getcwd()
-
-  print("[fetch & build]: icu_android")
-  os.chdir(current_dir)
-
-  if not base.is_dir("icu"):
-    base.cmd("svn", ["export", "https://github.com/unicode-org/icu/tags/release-" + icu_major + "-" + icu_minor + "/icu4c", "./icu", "--non-interactive", "--trust-server-cert"])
-    if ("linux" == base.host_platform()):
-      base.replaceInFile(current_dir + "/icu/source/i18n/digitlst.cpp", "xlocale", "locale")
-    if ("mac" == base.host_platform()):
-      base.replaceInFile(current_dir + "/icu/source/tools/pkgdata/pkgdata.cpp", "cmd, \"%s %s -o %s%s %s %s%s %s %s\",", "cmd, \"%s %s -o %s%s %s %s %s %s %s\",")
-
-  if not base.is_dir(current_dir + "/icu/cross_build"):
-    base.create_dir(current_dir + "/icu/cross_build")
-    os.chdir(current_dir + "/icu/cross_build")
-    base.cmd("../source/runConfigureICU", ["Linux" if "linux" == base.host_platform() else "MacOSX",
-      "--prefix=" + current_dir + "/icu/cross_build", "CFLAGS=-Os CXXFLAGS=--std=c++11"])
-    base.cmd("make", ["-j4"])
-    base.cmd("make", ["install"], True)
-
-  os.chdir(current_dir)
-
-  build_arch("arm64", "21")
-  build_arch("arm", "16")
-  build_arch("x86_64","21")
-  build_arch("x86", "16")
-
-  os.chdir(current_dir)
-
-  base.create_dir(current_dir + "/build")
-  base.copy_dir(current_dir + "/build_tmp/arm64/include", current_dir + "/build/include")
-
-  if icu_is_shared:
-    base.create_dir(current_dir + "/build/arm64_v8a")
-    base.copy_file(current_dir + "/build_tmp/arm64/lib/libicudata.so." + icu_major + "." + icu_minor, current_dir + "/build/arm64_v8a/libicudata.so")
-    base.copy_file(current_dir + "/build_tmp/arm64/lib/libicuuc.so." + icu_major + "." + icu_minor, current_dir + "/build/arm64_v8a/libicuuc.so")
-
-    base.create_dir(current_dir + "/build/armv7")
-    base.copy_file(current_dir + "/build_tmp/arm/lib/libicudata.so." + icu_major + "." + icu_minor, current_dir + "/build/armv7/libicudata.so")
-    base.copy_file(current_dir + "/build_tmp/arm/lib/libicuuc.so." + icu_major + "." + icu_minor, current_dir + "/build/armv7/libicuuc.so")
-
-    base.create_dir(current_dir + "/build/x86_64")
-    base.copy_file(current_dir + "/build_tmp/x86_64/lib/libicudata.so." + icu_major + "." + icu_minor, current_dir + "/build/x86_64/libicudata.so")
-    base.copy_file(current_dir + "/build_tmp/x86_64/lib/libicuuc.so." + icu_major + "." + icu_minor, current_dir + "/build/x86_64/libicuuc.so")
-
-    base.create_dir(current_dir + "/build/x86")
-    base.copy_file(current_dir + "/build_tmp/x86/lib/libicudata.so." + icu_major + "." + icu_minor, current_dir + "/build/x86/libicudata.so")
-    base.copy_file(current_dir + "/build_tmp/x86/lib/libicuuc.so." + icu_major + "." + icu_minor, current_dir + "/build/x86/libicuuc.so")
-
-    # patch elf information
-    os.chdir(current_dir + "/build")
-    base.cmd("git", ["clone", "https://github.com/NixOS/patchelf.git"])
-    os.chdir("./patchelf")
-    base.cmd("./bootstrap.sh")
-    base.cmd("./configure", ["--prefix=" + current_dir + "/build/patchelf/usr"])
-    base.cmd("make")
-    base.cmd("make", ["install"])
-
-    base.cmd("./usr/bin/patchelf", ["--set-soname", "libicudata.so", "./../arm64_v8a/libicudata.so"])
-    base.cmd("./usr/bin/patchelf", ["--set-soname", "libicuuc.so", "./../arm64_v8a/libicuuc.so"])
-    base.cmd("./usr/bin/patchelf", ["--replace-needed", "libicudata.so." + icu_major, "libicudata.so", "./../arm64_v8a/libicuuc.so"])
-
-    base.cmd("./usr/bin/patchelf", ["--set-soname", "libicudata.so", "./../armv7/libicudata.so"])
-    base.cmd("./usr/bin/patchelf", ["--set-soname", "libicuuc.so", "./../armv7/libicuuc.so"])
-    base.cmd("./usr/bin/patchelf", ["--replace-needed", "libicudata.so." + icu_major, "libicudata.so", "./../armv7/libicuuc.so"])
-
-    base.cmd("./usr/bin/patchelf", ["--set-soname", "libicudata.so", "./../x86_64/libicudata.so"])
-    base.cmd("./usr/bin/patchelf", ["--set-soname", "libicuuc.so", "./../x86_64/libicuuc.so"])
-    base.cmd("./usr/bin/patchelf", ["--replace-needed", "libicudata.so." + icu_major, "libicudata.so", "./../x86_64/libicuuc.so"])
-
-    base.cmd("./usr/bin/patchelf", ["--set-soname", "libicudata.so", "./../x86/libicudata.so"])
-    base.cmd("./usr/bin/patchelf", ["--set-soname", "libicuuc.so", "./../x86/libicuuc.so"])
-    base.cmd("./usr/bin/patchelf", ["--replace-needed", "libicudata.so." + icu_major, "libicudata.so", "./../x86/libicuuc.so"])
-
-    base.delete_dir(current_dir + "/build/patchelf")
-  
-  if not icu_is_shared:
-    base.create_dir(current_dir + "/build/arm64_v8a")
-    base.copy_file(current_dir + "/build_tmp/arm64/lib/libicudata.a", current_dir + "/build/arm64_v8a/libicudata.a")
-    base.copy_file(current_dir + "/build_tmp/arm64/lib/libicuuc.a", current_dir + "/build/arm64_v8a/libicuuc.a")
-    base.copy_file(current_dir + "/icu/arm64/data/out/icudt58l.dat", current_dir + "/build/arm64_v8a/icudt58l.dat")
-
-    base.create_dir(current_dir + "/build/armv7")
-    base.copy_file(current_dir + "/build_tmp/arm/lib/libicudata.a", current_dir + "/build/armv7/libicudata.a")
-    base.copy_file(current_dir + "/build_tmp/arm/lib/libicuuc.a", current_dir + "/build/armv7/libicuuc.a")
-    base.copy_file(current_dir + "/icu/arm/data/out/icudt58l.dat", current_dir + "/build/armv7/icudt58l.dat")
-
-    base.create_dir(current_dir + "/build/x86_64")
-    base.copy_file(current_dir + "/build_tmp/x86_64/lib/libicudata.a", current_dir + "/build/x86_64/libicudata.a")
-    base.copy_file(current_dir + "/build_tmp/x86_64/lib/libicuuc.a", current_dir + "/build/x86_64/libicuuc.a")
-    base.copy_file(current_dir + "/icu/x86_64/data/out/icudt58l.dat", current_dir + "/build/x86_64/icudt58l.dat")
-
-    base.create_dir(current_dir + "/build/x86")
-    base.copy_file(current_dir + "/build_tmp/x86/lib/libicudata.a", current_dir + "/build/x86/libicudata.a")
-    base.copy_file(current_dir + "/build_tmp/x86/lib/libicuuc.a", current_dir + "/build/x86/libicuuc.a")
-    base.copy_file(current_dir + "/icu/x86/data/out/icudt58l.dat", current_dir + "/build/x86/icudt58l.dat")
-
-  os.chdir(current_dir_old)
-  return

scripts/core_common/modules/icu_mac.py

@@ -35,7 +35,7 @@ def restore_icu_defs(current_dir):
   return
 
 icu_major = "58"
-icu_minor = "2"
+icu_minor = "3"
 
 current_dir_old = os.getcwd()
 current_dir = base.get_script_dir() + "/../../core/Common/3dParty/icu"

scripts/core_common/modules/openssl_mobile.py

@@ -1,18 +1,19 @@
 #!/usr/bin/env python
-
+import sys
+sys.path.append('../..')
+sys.path.append('android')
 import base
 import config
 import os
 import subprocess
+import openssl_android
 
 def make():
   path = base.get_script_dir() + "/../../core/Common/3dParty/openssl"
   old_cur = os.getcwd()
   os.chdir(path)
-  base.set_env("ANDROID_HOME", base.get_android_sdk_home())
-
-  if (-1 != config.option("platform").find("android") and not base.is_dir("./build/android")):
-      subprocess.call(["./build-android-openssl.sh"])
+  if (-1 != config.option("platform").find("android")):
+      openssl_android.make()
       
   if (-1 != config.option("platform").find("ios") and not base.is_dir("./build/ios")):
       subprocess.call(["./build-ios-openssl.sh"])

scripts/core_common/modules/v8.py

@@ -93,6 +93,7 @@ def make():
 
   if not base.is_dir("depot_tools"):
     base.cmd("git", ["clone", "https://chromium.googlesource.com/chromium/tools/depot_tools.git"])
+    v8_89.change_bootstrap()
     if ("windows" == base.host_platform()):
       # hack for 32 bit system!!!
       if base.is_file("depot_tools/cipd.ps1"):
@@ -225,6 +226,7 @@ def make_xp():
 
   if not base.is_dir("depot_tools"):
     base.cmd("git", ["clone", "https://chromium.googlesource.com/chromium/tools/depot_tools.git"])
+    v8_89.change_bootstrap()
     if ("windows" == base.host_platform()):
       # hack for 32 bit system!!!
       if base.is_file("depot_tools/cipd.ps1"):
@@ -232,7 +234,7 @@ def make_xp():
   
   # old variant
   #path_to_python2 = "/depot_tools/win_tools-2_7_13_chromium7_bin/python/bin"
-  path_to_python2 = "/depot_tools/bootstrap-2@3_8_10_chromium_26_bin/python/bin"
+  path_to_python2 = "/depot_tools/bootstrap-2@3_8_10_chromium_23_bin/python/bin"
   os.environ["PATH"] = os.pathsep.join([base_dir + "/depot_tools", 
     base_dir + path_to_python2, 
     config.option("vs-path") + "/../Common7/IDE",
@@ -269,6 +271,13 @@ def make_xp():
     "  replaceInFile(file, '<RuntimeLibrary>MultiThreaded</RuntimeLibrary>', '<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>')",
     ]);
 
+  programFilesDir = base.get_env("ProgramFiles")
+  if ("" != base.get_env("ProgramFiles(x86)")):
+    programFilesDir = base.get_env("ProgramFiles(x86)")
+  dev_path = programFilesDir + "\\Microsoft Visual Studio 14.0\\Common7\\IDE"
+  if (base.is_dir(dev_path)):
+    os.environ["PATH"] = dev_path + os.pathsep + os.environ["PATH"]
+
   # add "SET CL=\"/D_ITERATOR_DEBUG_LEVEL=0\"" before devenv for disable _ITERATOR_DEBUG_LEVEL in debug
   if config.check_option("platform", "win_64_xp"):
     if not base.is_dir("win_64/release"):

scripts/core_common/modules/v8_89.py

@@ -7,6 +7,23 @@ import base
 import os
 import subprocess
 
+def change_bootstrap():
+  base.move_file("./depot_tools/bootstrap/manifest.txt", "./depot_tools/bootstrap/manifest.txt.bak")
+  content = "# changed by build_tools\n\n"
+  content += "$VerifiedPlatform windows-amd64 windows-arm64 linux-amd64 mac-amd64 mac-arm64\n\n"
+
+  content += "@Subdir python\n"
+  content += "infra/3pp/tools/cpython/${platform} version:2@2.7.18.chromium.39\n\n"
+
+  content += "@Subdir python3\n"
+  content += "infra/3pp/tools/cpython3/${platform} version:2@3.8.10.chromium.23\n\n"
+
+  content += "@Subdir git\n"
+  content += "infra/3pp/tools/git/${platform} version:2@2.41.0.chromium.11\n"
+
+  base.writeFile("./depot_tools/bootstrap/manifest.txt", content)
+  return
+
 def make_args(args, platform, is_64=True, is_debug=False):
   args_copy = args[:]
   if is_64:
@@ -46,6 +63,12 @@ def ninja_windows_make(args, is_64=True, is_debug=False):
   base.copy_file("./" + directory_out + "/obj/v8_wrappers.ninja", "./" + directory_out + "/obj/v8_wrappers.ninja.bak")
   base.replaceInFile("./" + directory_out + "/obj/v8_wrappers.ninja", "target_output_name = v8_wrappers", "target_output_name = v8_wrappers\nbuild obj/v8_wrappers.obj: cxx ../../../src/base/platform/wrappers.cc")
   base.replaceInFile("./" + directory_out + "/obj/v8_wrappers.ninja", "build obj/v8_wrappers.lib: alink", "build obj/v8_wrappers.lib: alink obj/v8_wrappers.obj")
+
+  win_toolset_wrapper_file = "build/toolchain/win/tool_wrapper.py"
+  win_toolset_wrapper_file_content = base.readFile("build/toolchain/win/tool_wrapper.py")
+  if (-1 == win_toolset_wrapper_file_content.find("line = line.decode('utf8')")):
+    base.replaceInFile(win_toolset_wrapper_file, "for line in link.stdout:\n", "for line in link.stdout:\n      line = line.decode('utf8')\n")
+
   base.cmd("ninja", ["-C", directory_out, "v8_wrappers"])
   base.cmd("ninja", ["-C", directory_out])
   base.delete_file("./" + directory_out + "/obj/v8_wrappers.ninja")
@@ -85,6 +108,7 @@ def make():
   os.chdir(base_dir)
   if not base.is_dir("depot_tools"):
     base.cmd("git", ["clone", "https://chromium.googlesource.com/chromium/tools/depot_tools.git"])
+    change_bootstrap()
 
   os.environ["PATH"] = base_dir + "/depot_tools" + os.pathsep + os.environ["PATH"]
 

scripts/deploy_desktop.py

@@ -106,8 +106,13 @@ def make():
     # dictionaries
     base.copy_dictionaries(git_dir + "/dictionaries", root_dir + "/dictionaries")
 
-    # base.copy_dir(git_dir + "/desktop-apps/common/package/fonts", root_dir + "/fonts") # TODO: remove for ver 7.7 if core-fonts enough
-    base.copy_dir(git_dir + "/core-fonts/opensans", root_dir + "/fonts")
+    base.copy_dir(git_dir  + "/core-fonts/opensans",   root_dir + "/fonts")
+    base.copy_dir(git_dir  + "/core-fonts/asana",      root_dir + "/fonts/asana")
+    base.copy_dir(git_dir  + "/core-fonts/caladea",    root_dir + "/fonts/caladea")
+    base.copy_dir(git_dir  + "/core-fonts/crosextra",  root_dir + "/fonts/crosextra")
+    base.copy_dir(git_dir  + "/core-fonts/openoffice", root_dir + "/fonts/openoffice")
+    base.copy_file(git_dir + "/core-fonts/ASC.ttf",    root_dir + "/fonts/ASC.ttf")
+
     base.copy_file(git_dir + "/desktop-apps/common/package/license/3dparty/3DPARTYLICENSE", root_dir + "/3DPARTYLICENSE")
   
     # cef
@@ -209,11 +214,14 @@ def make():
     base.create_dir(root_dir + "/editors")
     base.copy_dir(base_dir + "/js/" + branding + "/desktop/sdkjs", root_dir + "/editors/sdkjs")
     base.copy_dir(base_dir + "/js/" + branding + "/desktop/web-apps", root_dir + "/editors/web-apps")
+    for file in glob.glob(root_dir + "/editors/web-apps/apps/*/*/*.js.map"):
+      base.delete_file(file)
     base.copy_dir(git_dir + "/desktop-sdk/ChromiumBasedEditors/resources/local", root_dir + "/editors/sdkjs/common/Images/local")
 
     base.create_dir(root_dir + "/editors/sdkjs-plugins")
-    base.copy_marketplace_plugin(root_dir + "/editors/sdkjs-plugins", True, True, True)
-    base.copy_sdkjs_plugins(root_dir + "/editors/sdkjs-plugins", True, True)
+    if not isWindowsXP:
+      base.copy_marketplace_plugin(root_dir + "/editors/sdkjs-plugins", True, True, True)
+    base.copy_sdkjs_plugins(root_dir + "/editors/sdkjs-plugins", True, True, isWindowsXP)
     # remove some default plugins
     if base.is_dir(root_dir + "/editors/sdkjs-plugins/speech"):
       base.delete_dir(root_dir + "/editors/sdkjs-plugins/speech")
@@ -231,6 +239,8 @@ def make():
     base.copy_sdkjs_plugin(git_dir + "/desktop-sdk/ChromiumBasedEditors/plugins", root_dir + "/editors/sdkjs-plugins", "sendto", True)
   
     base.copy_file(base_dir + "/js/" + branding + "/desktop/index.html", root_dir + "/index.html")
+    base.create_dir(root_dir + "/editors/webext")
+    base.copy_file(base_dir + "/js/" + branding + "/desktop/noconnect.html", root_dir + "/editors/webext/noconnect.html")
 
     if isWindowsXP:
       base.create_dir(root_dir + "/providers")

scripts/deploy_server.py

@@ -5,6 +5,7 @@ import base
 
 import re
 import shutil
+import glob
 from tempfile import mkstemp
 
 def make():
@@ -113,6 +114,9 @@ def make():
     js_dir = root_dir
     base.copy_dir(base_dir + "/js/" + branding + "/builder/sdkjs", js_dir + "/sdkjs")
     base.copy_dir(base_dir + "/js/" + branding + "/builder/web-apps", js_dir + "/web-apps")
+    for file in glob.glob(js_dir + "/web-apps/apps/*/*/*.js.map") \
+              + glob.glob(js_dir + "/web-apps/apps/*/mobile/dist/js/*.js.map"):
+      base.delete_file(file)
 
     # add embed worker code
     base.cmd_in_dir(git_dir + "/sdkjs/common/embed", "python", ["make.py", js_dir + "/web-apps/apps/api/documents/api.js"])

scripts/license_checker/Readme.md

@@ -172,6 +172,18 @@ Possible array values:
     ]
     ```
 
+  * `allowListFile` file paths to allow. It is needed if you ignore the directory, but there is a file in it that needs to be checked.
+  **For example:**
+
+    ```json
+    "ignoreListDir": [
+      "sdkjs/develop"
+    ],
+    "allowListFile": [
+      "sdkjs/develop/awesomeFileToAllow.js",
+    ]
+    ```
+
   Any number of configurations can be
   specified, they can overlap
   if we need to check

scripts/package_builder.py

@@ -22,11 +22,7 @@ def s3_upload(files, dst):
   ret = True
   for f in files:
     key = dst + utils.get_basename(f) if dst.endswith("/") else dst
-    aws_kwargs = { "acl": "public-read" }
-    if hasattr(branding, "s3_endpoint_url"):
-      aws_kwargs["endpoint_url"] = branding.s3_endpoint_url
-    upload = utils.s3_upload(
-      f, "s3://" + branding.s3_bucket + "/" + key, **aws_kwargs)
+    upload = utils.s3_upload(f, "s3://" + branding.s3_bucket + "/" + key)
     if upload:
       utils.add_deploy_data(key)
       utils.log("URL: " + branding.s3_base_url + "/" + key)

scripts/package_common.py

@@ -15,16 +15,3 @@ platformPrefixes = {
 
 out_dir = "build_tools/out"
 tsa_server = "http://timestamp.digicert.com"
-vcredist_links = {
-  # Microsoft Visual C++ 2015-2022 Redistributable - 14.38.33130
-  "2022": {
-    "x64": {
-      "url": "https://aka.ms/vs/17/release/vc_redist.x64.exe",
-      "md5": "101b0b9f74cdc6cdbd2570bfe92e302c"
-    },
-    "x86": {
-      "url": "https://aka.ms/vs/17/release/vc_redist.x86.exe",
-      "md5": "0d762264d9765e21c15a58edc43f4706"
-    }
-  }
-}

scripts/package_core.py

@@ -39,49 +39,67 @@ def make_core():
     return
 
   utils.log_h2("core deploy")
-  aws_kwargs = { "acl": "public-read" }
-  if hasattr(branding, "s3_endpoint_url"):
-    aws_kwargs["endpoint_url"]=branding.s3_endpoint_url
   ret = utils.s3_upload(
     core_7z,
-    "s3://" + branding.s3_bucket + "/" + dest_version + "/core.7z",
-    **aws_kwargs)
+    "s3://" + branding.s3_bucket + "/" + dest_version + "/core.7z")
   if ret:
     utils.log("URL: " + branding.s3_base_url + "/" + dest_version + "/core.7z")
     utils.add_deploy_data(dest_version + "/core.7z")
     ret = utils.s3_sync(
       "s3://" + branding.s3_bucket + "/" + dest_version + "/",
       "s3://" + branding.s3_bucket + "/" + dest_latest + "/",
-      delete=True, **aws_kwargs)
+      delete=True)
     utils.log("URL: " + branding.s3_base_url + "/" + dest_latest + "/core.7z")
   utils.set_summary("core deploy", ret)
   return
 
-def deploy_closuremaps(license):
+def deploy_closuremaps_sdkjs(license):
   if not common.deploy: return
-  utils.log_h1("CLOSURE MAPS")
-  utils.set_cwd(utils.get_path("sdkjs/build/maps"))
+  utils.log_h1("SDKJS CLOSURE MAPS")
 
-  maps = utils.glob_path("*.js.map")
-  if not maps:
+  maps = utils.glob_path("sdkjs/build/maps/*.js.map")
+  if maps:
+    for m in maps: utils.log("- " + m)
+  else:
     utils.log_err("files do not exist")
-    utils.set_summary("closure maps " + license + " deploy", False)
+    utils.set_summary("sdkjs closure maps %s deploy" % license, False)
     return
 
-  utils.log_h2("closure maps " + license + " deploy")
-  aws_kwargs = {}
-  if hasattr(branding, "s3_endpoint_url"):
-    aws_kwargs["endpoint_url"]=branding.s3_endpoint_url
+  utils.log_h2("sdkjs closure maps %s deploy" % license)
   ret = True
   for f in maps:
-    key = "closure-maps/%s/%s/%s/%s" % (license, common.version, common.build, f)
-    upload = utils.s3_upload(
-      f, "s3://" + branding.s3_bucket + "/" + key, **aws_kwargs)
+    base = utils.get_basename(f)
+    key = "closure-maps/sdkjs/%s/%s/%s/%s" % (license, common.version, common.build, base)
+    upload = utils.s3_upload(f, "s3://" + branding.s3_bucket + "/" + key)
     ret &= upload
     if upload:
       utils.log("URL: " + branding.s3_base_url + "/" + key)
       utils.add_deploy_data(key)
-  utils.set_summary("closure maps " + license + " deploy", ret)
-
-  utils.set_cwd(common.workspace_dir)
+  utils.set_summary("sdkjs closure maps %s deploy" % license, ret)
+  return
+
+def deploy_closuremaps_webapps(license):
+  if not common.deploy: return
+  utils.log_h1("WEB-APPS CLOSURE MAPS")
+
+  maps = utils.glob_path("web-apps/deploy/web-apps/apps/*/*/*.js.map") \
+       + utils.glob_path("web-apps/deploy/web-apps/apps/*/mobile/dist/js/*.js.map")
+  if maps:
+    for m in maps: utils.log("- " + m)
+  else:
+    utils.log_err("files do not exist")
+    utils.set_summary("web-apps closure maps %s deploy" % license, False)
+    return
+
+  utils.log_h2("web-apps closure maps %s deploy" % license)
+  ret = True
+  for f in maps:
+    base = utils.get_relpath(f, "web-apps/deploy/web-apps/apps").replace("/", "_")
+    key = "closure-maps/web-apps/%s/%s/%s/%s" % (license, common.version, common.build, base)
+    upload = utils.s3_upload(f, "s3://" + branding.s3_bucket + "/" + key)
+    ret &= upload
+    if upload:
+      utils.log("URL: " + branding.s3_base_url + "/" + key)
+      utils.add_deploy_data(key)
+  utils.set_summary("web-apps closure maps %s deploy" % license, ret)
   return

scripts/package_desktop.py

@@ -24,11 +24,7 @@ def s3_upload(files, dst):
   ret = True
   for f in files:
     key = dst + utils.get_basename(f) if dst.endswith("/") else dst
-    aws_kwargs = { "acl": "public-read" }
-    if hasattr(branding, "s3_endpoint_url"):
-      aws_kwargs["endpoint_url"] = branding.s3_endpoint_url
-    upload = utils.s3_upload(
-      f, "s3://" + branding.s3_bucket + "/" + key, **aws_kwargs)
+    upload = utils.s3_upload(f, "s3://" + branding.s3_bucket + "/" + key)
     if upload:
       utils.add_deploy_data(key)
       utils.log("URL: " + branding.s3_base_url + "/" + key)
@@ -67,16 +63,14 @@ def make_windows():
   if common.clean:
     utils.log_h2("desktop clean")
     utils.delete_dir("build")
-    # utils.delete_dir("data\\vcredist")
     utils.delete_dir("DesktopEditors-cache")
     utils.delete_files("*.exe")
     utils.delete_files("*.msi")
     utils.delete_files("*.aic")
     utils.delete_files("*.tmp")
     utils.delete_files("*.zip")
+    utils.delete_files("data\\*.exe")
     utils.delete_files("update\\*.exe")
-    utils.delete_files("update\\*.xml")
-    utils.delete_files("update\\*.html")
 
   utils.log_h2("copy arifacts")
   source_dir = "%s\\build_tools\\out\\%s\\%s" \
@@ -90,7 +84,7 @@ def make_windows():
 
   make_zip()
 
-  if not download_vcredist("2022"):
+  if not download_vcredist():
     utils.set_summary("desktop inno build", False)
     utils.set_summary("desktop inno standalone build", False)
     utils.set_summary("desktop inno update build", False)
@@ -133,18 +127,36 @@ def make_zip():
     utils.set_summary("desktop zip deploy", ret)
   return
 
-def download_vcredist(year):
-  utils.log_h2("vcredist " + year + " download")
+def download_vcredist():
+  vcredist = {
+    # Microsoft Visual C++ 2015-2022 Redistributable - 14.38.33135
+    "windows_x64": {
+      "url": "https://aka.ms/vs/17/release/vc_redist.x64.exe",
+      "md5": "a8a68bcc74b5022467f12587baf1ef93"
+    },
+    "windows_x86": {
+      "url": "https://aka.ms/vs/17/release/vc_redist.x86.exe",
+      "md5": "9882a328c8414274555845fa6b542d1e"
+    },
+    # Microsoft Visual C++ 2015-2019 Redistributable - 14.27.29114
+    "windows_x64_xp": {
+      "url": "https://download.visualstudio.microsoft.com/download/pr/722d59e4-0671-477e-b9b1-b8da7d4bd60b/591CBE3A269AFBCC025681B968A29CD191DF3C6204712CBDC9BA1CB632BA6068/VC_redist.x64.exe",
+      "md5": "bc8e3e714b727b3bb18614bd6a51a3d3"
+    },
+    "windows_x86_xp": {
+      "url": "https://download.visualstudio.microsoft.com/download/pr/c168313d-1754-40d4-8928-18632c2e2a71/D305BAA965C9CD1B44EBCD53635EE9ECC6D85B54210E2764C8836F4E9DEFA345/VC_redist.x86.exe",
+      "md5": "ec3bee79a85ae8e3581a8c181b336d1e"
+    }
+  }
+  vcredist_file = "data\\vcredist_%s.exe" % arch_list[common.platform]
 
-  arch = arch_list[common.platform]
-  link = common.vcredist_links[year][arch]["url"]
-  md5 = common.vcredist_links[year][arch]["md5"]
-  vcredist_file = "data\\vcredist\\vcredist_%s_%s.exe" % (year, arch)
-
-  utils.log_h2(vcredist_file)
-  utils.create_dir(utils.get_dirname(vcredist_file))
-  ret = utils.download_file(link, vcredist_file, md5, verbose=True)
-  utils.set_summary("vcredist " + year + " download", ret)
+  utils.log_h2("vcredist download " + vcredist_file)
+  ret = utils.download_file(
+    vcredist[common.platform]["url"],
+    vcredist_file,
+    vcredist[common.platform]["md5"],
+    verbose=True)
+  utils.set_summary("vcredist download", ret)
   return ret
 
 def make_inno():
@@ -227,94 +239,15 @@ def make_update_files():
 def make_advinst():
   utils.log_h2("desktop advinst build")
 
-  msi_build = {
-    "windows_x64": "MsiBuild64",
-    "windows_x86": "MsiBuild32"
-  }[common.platform]
-
-  if not branding.onlyoffice:
-    multimedia_dir = common.workspace_dir + "\\" + common.branding + "\\multimedia"
-    utils.copy_file(branding_dir + "\\dictionary.ail", "dictionary.ail")
-    utils.copy_dir_content(branding_dir + "\\data", "data", ".bmp")
-    utils.copy_dir_content(branding_dir + "\\data", "data", ".png")
-    utils.copy_dir_content(
-      branding_dir + "\\..\\..\\extras\\projicons\\res",
-      "..\\..\\extras\\projicons\\res",
-      ".ico")
-    utils.copy_file(
-      branding_dir + "\\..\\..\\..\\common\\package\\license\\eula_" + common.branding + ".rtf",
-      "..\\..\\..\\common\\package\\license\\agpl-3.0.rtf")
-    utils.copy_file(
-      multimedia_dir + "\\imageviewer\\icons\\ico\\" + common.branding + ".ico",
-      "..\\..\\extras\\projicons\\res\\gallery.ico")
-    utils.copy_file(
-      multimedia_dir + "\\videoplayer\\icons\\" + common.branding + ".ico",
-      "..\\..\\extras\\projicons\\res\\media.ico")
-
-  utils.write_file(desktop_dir + "\\converter\\package.config", "package=msi")
-
-  aic_content = [";aic"]
-  if not common.sign:
-    aic_content += [
-      "ResetSig"
-    ]
-  if branding.onlyoffice:
-    for path in utils.glob_path(desktop_dir + "\\editors\\web-apps\\apps\\*\\main\\resources\\help"):
-      utils.delete_dir(path)
-    aic_content += [
-      "DelFolder CUSTOM_PATH"
-    ]
-  else:
-    aic_content += [
-      "SetProperty UpgradeCode=\"" + branding.desktop_upgrade_code + "\"",
-      "AddUpgradeCode {47EEF706-B0E4-4C43-944B-E5F914B92B79} \
-        -min_ver 7.1.1 -include_min_ver \
-        -max_ver 7.2.2 -include_max_ver \
-        -include_lang 1049 \
-        -property_name UPGRADE_2 -enable_migrate",
-      "DelLanguage 1029 -buildname " + msi_build,
-      "DelLanguage 1031 -buildname " + msi_build,
-      "DelLanguage 1041 -buildname " + msi_build,
-      "DelLanguage 1046 -buildname " + msi_build,
-      "DelLanguage 2070 -buildname " + msi_build,
-      "DelLanguage 1060 -buildname " + msi_build,
-      "DelLanguage 1036 -buildname " + msi_build,
-      "DelLanguage 3082 -buildname " + msi_build,
-      "DelLanguage 1033 -buildname " + msi_build,
-      "SetCurrentFeature ExtendedFeature",
-      "NewSync CUSTOM_PATH " + viewer_dir,
-      "UpdateFile CUSTOM_PATH\\ImageViewer.exe " + viewer_dir + "\\ImageViewer.exe",
-      "UpdateFile CUSTOM_PATH\\VideoPlayer.exe " + viewer_dir + "\\VideoPlayer.exe",
-      "SetProperty ProductName=\"" + branding.desktop_product_name_full + "\"",
-      "SetProperty ASCC_REG_PREFIX=" + branding.ascc_reg_prefix
-    ]
-    if common.platform == "windows_x86":
-      aic_content += [
-        "SetComponentAttribute -feature_name ExtendedFeature -unset -64bit_component"
-      ]
-  if common.platform == "windows_x86":
-    aic_content += [
-      "SetComponentAttribute -feature_name MainFeature -unset -64bit_component",
-      "SetComponentAttribute -feature_name FileProgIds -unset -64bit_component",
-      "SetComponentAttribute -feature_name FileOpenWith -unset -64bit_component",
-      "SetComponentAttribute -feature_name FileProgramCapatibilities -unset -64bit_component",
-      "SetComponentAttribute -feature_name FileTypeAssociations -unset -64bit_component",
-      "SetComponentAttribute -feature_name FileNewTemplates -unset -64bit_component"
-    ]
-  aic_content += [
-    "SetCurrentFeature MainFeature",
-    "NewSync APPDIR " + desktop_dir,
-    "UpdateFile APPDIR\\DesktopEditors.exe " + desktop_dir + "\\DesktopEditors.exe",
-    "UpdateFile APPDIR\\updatesvc.exe " + desktop_dir + "\\updatesvc.exe",
-    "SetProperty VERSION=\"" + package_version + "\"",
-    "SetProperty VERSION_SHORT=\"" + re.sub(r"^(\d+\.\d+).+", "\\1", package_version) + "\"",
-    "SetVersion " + package_version,
-    "SetPackageName " + advinst_file + " -buildname " + msi_build,
-    "Rebuild -buildslist " + msi_build
+  args = [
+    "-Version", package_version,
+    "-Arch", arch_list[common.platform]
   ]
-  utils.write_file("DesktopEditors.aic", "\r\n".join(aic_content), "utf-8-sig")
-  ret = utils.cmd("AdvancedInstaller.com", "/execute", \
-    "DesktopEditors.aip", "DesktopEditors.aic", verbose=True)
+  if common.sign:
+    args += ["-Sign"]
+  if not branding.onlyoffice:
+    args += ["-BrandingDir", branding_dir]
+  ret = utils.ps1("make_advinst.ps1", args, verbose=True)
   utils.set_summary("desktop advinst build", ret)
 
   if common.deploy and ret:
@@ -446,17 +379,6 @@ def make_sparkle_updates():
   )
   utils.set_summary("desktop sparkle files build", ret)
 
-  utils.log("")
-  utils.log_h3("generate checksums")
-  utils.sh(
-      "md5 *.zip *.delta > md5sums.txt",
-      chdir="build/update", verbose=True
-  )
-  utils.sh(
-      "shasum -a 256 *.zip *.delta > sha256sums.txt",
-      chdir="build/update", verbose=True
-  )
-
   if common.deploy:
     utils.log_h2("desktop sparkle files deploy")
     ret = s3_upload(

scripts/package_mobile.py

@@ -22,18 +22,14 @@ def make_mobile():
     utils.sh("rm -rfv *.zip", verbose=True)
 
   utils.log_h2("mobile build")
-  ret = utils.sh("zip -r " + zip_file + " ./android* ./js", verbose=True)
+  ret = utils.sh("zip -r " + zip_file + " ./android ./ios", verbose=True)
   utils.set_summary("mobile build", ret)
 
   if common.deploy:
     if ret:
       utils.log_h2("mobile deploy")
       key = "mobile/android/" + zip_file
-      aws_kwargs = { "acl": "public-read" }
-      if hasattr(branding, "s3_endpoint_url"):
-        aws_kwargs["endpoint_url"] = branding.s3_endpoint_url
-      ret = utils.s3_upload(
-        zip_file, "s3://" + branding.s3_bucket + "/" + key, **aws_kwargs)
+      ret = utils.s3_upload(zip_file, "s3://" + branding.s3_bucket + "/" + key)
       if ret:
         utils.add_deploy_data(key)
         utils.log("URL: " + branding.s3_base_url + "/" + key)

scripts/package_server.py

@@ -19,11 +19,7 @@ def s3_upload(files, dst):
   ret = True
   for f in files:
     key = dst + utils.get_basename(f) if dst.endswith("/") else dst
-    aws_kwargs = { "acl": "public-read" }
-    if hasattr(branding, "s3_endpoint_url"):
-      aws_kwargs["endpoint_url"] = branding.s3_endpoint_url
-    upload = utils.s3_upload(
-      f, "s3://" + branding.s3_bucket + "/" + key, **aws_kwargs)
+    upload = utils.s3_upload(f, "s3://" + branding.s3_bucket + "/" + key)
     if upload:
       utils.add_deploy_data(key)
       utils.log("URL: " + branding.s3_base_url + "/" + key)

scripts/package_utils.py

@@ -73,6 +73,9 @@ def get_path(path):
     return path.replace("/", "\\")
   return path
 
+def get_relpath(path, rel_path):
+  return os.path.relpath(get_path(path), get_path(rel_path))
+
 def get_abspath(path):
   return os.path.abspath(get_path(path))
 

scripts/qmake.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python
+
+import os
+import sys
+
+__dir__name__ = os.path.dirname(__file__)
+sys.path.append(__dir__name__ + '/core_common/modules/android')
+
+import base
+import config
+import android_ndk
+import multiprocessing
+
+def get_make_file_suffix(platform):
+  suffix = platform
+  if config.check_option("config", "debug"):
+    suffix += "_debug_"
+  suffix += config.option("branding")
+  return suffix
+
+def get_j_num():
+  if ("0" != config.option("multiprocess")):
+    return ["-j" + str(multiprocessing.cpu_count())]
+  return []
+
+def check_support_platform(platform):
+  qt_dir = base.qt_setup(platform)
+  if not base.is_file(qt_dir + "/bin/qmake") and not base.is_file(qt_dir + "/bin/qmake.exe"):
+    return False
+  return True
+
+def make(platform, project, qmake_config_addon=""):
+  # check platform
+  if not check_support_platform(platform):
+    print("THIS PLATFORM IS NOT SUPPORTED")
+    return
+
+  old_env = dict(os.environ)
+  
+  # qt
+  qt_dir = base.qt_setup(platform)
+  base.set_env("OS_DEPLOY", platform)
+
+  # pro & makefile
+  file_pro = os.path.abspath(project)
+
+  pro_dir = os.path.dirname(file_pro)
+  if (pro_dir.endswith("/.")):
+    pro_dir = pro_dir[:-2]
+  if (pro_dir.endswith("/")):
+    pro_dir = pro_dir[:-1]
+
+  makefile_name = "Makefile." + get_make_file_suffix(platform) 
+  makefile = pro_dir + "/" + makefile_name
+  stash_file = pro_dir + "/.qmake.stash"
+
+  old_cur = os.getcwd()
+  os.chdir(pro_dir)
+
+  if (base.is_file(stash_file)):
+    base.delete_file(stash_file)
+  if (base.is_file(makefile)):
+    base.delete_file(makefile)
+
+  base.set_env("DEST_MAKEFILE_NAME", "./" + makefile_name)
+
+  # setup android env
+  if (-1 != platform.find("android")):
+    base.set_env("ANDROID_NDK_HOST", android_ndk.host["arch"])
+    base.set_env("ANDROID_NDK_PLATFORM", "android-" + android_ndk.get_sdk_api())
+    base.set_env("PATH", qt_dir + "/bin:" + android_ndk.toolchain_dir() + "/bin:" + base.get_env("PATH"))
+
+  # setup ios env
+  if (-1 != platform.find("ios")):
+    base.hack_xcode_ios()
+
+  if base.is_file(makefile):
+    base.delete_file(makefile)
+
+  config_param = base.qt_config(platform)
+  if ("" != qmake_config_addon):
+    config_param += (" " + qmake_config_addon)
+
+  # qmake ADDON
+  qmake_addon = []
+  if ("" != config.option("qmake_addon")):
+    qmake_addon = config.option("qmake_addon").split()
+
+  clean_params = ["clean", "-f", makefile]
+  distclean_params = ["distclean", "-f", makefile]
+  build_params = ["-nocache", file_pro] + base.qt_config_as_param(config_param) + qmake_addon
+
+  qmake_app = qt_dir + "/bin/qmake"
+  # non windows platform
+  if not base.is_windows():
+    base.cmd(qmake_app, build_params)
+    base.correct_makefile_after_qmake(platform, makefile)
+    if ("1" == config.option("clean")):
+      base.cmd_and_return_cwd("make", clean_params, True)
+      base.cmd_and_return_cwd("make", distclean_params, True)
+      base.cmd(qmake_app, build_params)
+      base.correct_makefile_after_qmake(platform, makefile)
+    base.cmd_and_return_cwd("make", ["-f", makefile] + get_j_num())
+  else:
+    config_params_array = base.qt_config_as_param(config_param)
+    config_params_string = ""
+    for item in config_params_array:
+      config_params_string += (" \"" + item + "\"")
+    qmake_addon_string = " ".join(qmake_addon)
+    if ("" != qmake_addon_string):
+      qmake_addon_string = " " + qmake_addon_string
+
+    qmake_bat = []
+    qmake_bat.append("call \"" + config.option("vs-path") + "/vcvarsall.bat\" " + ("x86" if base.platform_is_32(platform) else "x64"))
+    qmake_addon_string = ""
+    if ("" != config.option("qmake_addon")):
+      qmake_addon_string = " " + (" ").join(["\"" + addon + "\"" for addon in qmake_addon])
+    qmake_bat.append("call \"" + qmake_app + "\" -nocache " + file_pro + config_params_string + qmake_addon_string)
+    if ("1" == config.option("clean")):
+      qmake_bat.append("call nmake " + " ".join(clean_params))
+      qmake_bat.append("call nmake " + " ".join(distclean_params))
+      qmake_bat.append("call \"" + qmake_app + "\" -nocache " + file_pro + config_params_string + qmake_addon_string)
+    if ("0" != config.option("multiprocess")):
+      qmake_bat.append("set CL=/MP")
+    qmake_bat.append("call nmake -f " + makefile)
+    base.run_as_bat(qmake_bat)
+
+  if (base.is_file(stash_file)):
+    base.delete_file(stash_file)
+
+  os.chdir(old_cur)
+
+  os.environ.clear()
+  os.environ.update(old_env)
+  return
+
+def make_all_platforms(project, qmake_config_addon=""):
+  platforms = config.option("platform").split()
+  for platform in platforms:
+    if not platform in config.platforms:
+      continue
+
+    print("------------------------------------------")
+    print("BUILD_PLATFORM: " + platform)
+    print("------------------------------------------")
+    make(platform, project, qmake_config_addon)
+  return

scripts/sln.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python
+
+import sys
+sys.path.append('scripts')
+import config
+import json
+import os
+
+is_log = False
+
+def is_exist_in_array(projects, proj):
+  for p in projects:
+    if p == proj:
+      return True
+  return False
+
+def adjust_project_params(params):
+  ret_params = params
+  
+  # check aliases
+  all_windows = []
+  all_windows_xp = []
+  all_linux = []
+  all_mac = []
+  all_android = []
+
+  for i in config.platforms:
+    if (0 == i.find("win")):
+      all_windows.append(i)
+      if (-1 != i.find("xp")):
+        all_windows_xp.append(i)
+    elif (0 == i.find("linux")):
+      all_linux.append(i)
+    elif (0 == i.find("mac")):
+      all_mac.append(i)
+    elif (0 == i.find("android")):
+      all_android.append(i)
+
+  if is_exist_in_array(params, "win"):
+    ret_params += all_windows
+  if is_exist_in_array(params, "!win"):
+    ret_params += ["!" + x for x in all_windows]
+
+  if is_exist_in_array(params, "win_xp"):
+    ret_params += all_windows_xp
+  if is_exist_in_array(params, "!win_xp"):
+    ret_params += ["!" + x for x in all_windows_xp]
+
+  if is_exist_in_array(params, "linux"):
+    ret_params += all_linux
+  if is_exist_in_array(params, "!linux"):
+    ret_params += ["!" + x for x in all_linux]
+
+  if is_exist_in_array(params, "mac"):
+    ret_params += all_mac
+  if is_exist_in_array(params, "!mac"):
+    ret_params += ["!" + x for x in all_mac]
+
+  if is_exist_in_array(params, "android"):
+    ret_params += all_android
+  if is_exist_in_array(params, "!android"):
+    ret_params += ["!" + x for x in all_android]
+
+  return ret_params
+
+def get_projects(pro_json_path, platform):
+  json_path = os.path.abspath(pro_json_path)
+  data = json.load(open(json_path))
+
+  root_dir_json = "../"
+  if ("root" in data):
+    root_dir_json = data["root"]
+
+  root_dir = os.path.dirname(json_path)
+  if ("/" != root_dir[-1] and "\\" != root_dir[-1]):
+    root_dir += "/"
+  root_dir += root_dir_json
+
+  result = []
+  modules = config.option("module").split(" ")
+  for module in modules:
+    if (module == ""):
+      continue
+    if not module in data:
+      continue
+    
+    # check aliases to modules
+    records_src = data[module]
+    records = []
+
+    for rec in records_src:
+      if rec in data:
+        records += data[rec]
+      else:
+        records.append(rec)
+
+    for rec in records:
+      params = []
+      record = rec
+      if (0 == rec.find("[")):
+        pos = rec.find("]")
+        if (-1 == pos):
+          continue
+        record = rec[pos+1:]
+        header = rec[1:pos].replace(" ", "")
+        params_tmp = rec[1:pos].split(",")
+        for par in params_tmp:
+          if (par != ""):
+            params.append(par)
+
+        params = adjust_project_params(params)
+
+      if is_exist_in_array(result, record):
+        continue
+
+      if is_log:
+        print("params: " + ",".join(params))
+        print("file: " + record)
+
+      if is_exist_in_array(params, "!" + platform):
+        continue
+
+      platform_records = []
+      platform_records += config.platforms
+      platform_records += ["win", "win_xp", "linux", "mac", "android"]
+
+      # if one platform exists => all needed must exists
+      is_needed_platform_exist = False
+      for pl in platform_records:
+        if is_exist_in_array(params, pl):
+          is_needed_platform_exist = True;
+          break
+
+      # if one config exists => all needed must exists
+      is_needed_config_exist = False
+      for item in params:
+        if (0 == item.find("!")):
+          continue
+        if is_exist_in_array(platform_records, item):
+          continue
+        is_needed_config_exist = True
+        break;
+
+      if is_needed_platform_exist:
+        if not is_exist_in_array(params, platform):
+          continue
+
+      config_params = config.option("config").split(" ") + config.option("features").split(" ")
+      config_params = [x for x in config_params if x]      
+
+      is_append = True
+      for conf in config_params:
+        if is_exist_in_array(params, "!" + conf):
+          is_append = False
+          break
+        if is_needed_config_exist and not is_exist_in_array(params, conf):
+          is_append = False
+          break
+      if is_append:
+        result.append(root_dir + record)
+
+  if is_log:
+    print(result)
+  return result
+
+# test example
+if __name__ == '__main__':
+  # test
+  config.parse()
+
+  is_log = True
+  projects = get_projects("./../sln.json", "win_64")

sln.json

@@ -0,0 +1,100 @@
+{
+  "root" : "../",
+
+  "core" : [
+
+    "core/Common/3dParty/cryptopp/project/cryptopp.pro",
+    "core/Common/cfcpp/cfcpp.pro",
+
+    "core/UnicodeConverter/UnicodeConverter.pro",
+    "core/Common/kernel.pro",
+    "core/Common/Network/network.pro",
+    
+    "core/DesktopEditor/graphics/pro/graphics.pro",
+    
+    "core/PdfFile/PdfFile.pro",
+    "core/DjVuFile/DjVuFile.pro",
+    "core/XpsFile/XpsFile.pro",
+    "core/HtmlFile2/HtmlFile2.pro",
+    "core/Fb2File/Fb2File.pro",
+    "core/EpubFile/CEpubFile.pro",
+    
+    "core/HtmlRenderer/htmlrenderer.pro",
+    "core/DocxRenderer/DocxRenderer.pro",   
+
+    "core/DesktopEditor/doctrenderer/doctrenderer.pro",
+
+    "[!no_x2t]core/OOXML/Projects/Linux/DocxFormatLib/DocxFormatLib.pro",
+    "[!no_x2t]core/OOXML/Projects/Linux/PPTXFormatLib/PPTXFormatLib.pro",
+    "[!no_x2t]core/OOXML/Projects/Linux/XlsbFormatLib/XlsbFormatLib.pro",
+
+    "[!no_x2t]core/MsBinaryFile/Projects/DocFormatLib/Linux/DocFormatLib.pro",
+    "[!no_x2t]core/MsBinaryFile/Projects/PPTFormatLib/Linux/PPTFormatLib.pro",
+    "[!no_x2t]core/MsBinaryFile/Projects/XlsFormatLib/Linux/XlsFormatLib.pro",
+    "[!no_x2t]core/MsBinaryFile/Projects/VbaFormatLib/Linux/VbaFormatLib.pro",
+
+    "[!no_x2t]core/TxtFile/Projects/Linux/TxtXmlFormatLib.pro",
+    "[!no_x2t]core/RtfFile/Projects/Linux/RtfFormatLib.pro",
+    "[!no_x2t]core/OdfFile/Projects/Linux/OdfFormatLib.pro",
+
+    "[!no_x2t]core/OOXML/Projects/Linux/BinDocument/BinDocument.pro",
+
+    "[!no_x2t]core/X2tConverter/build/Qt/X2tConverter.pro",
+
+    "[win,linux,mac]core/DesktopEditor/AllFontsGen/AllFontsGen.pro",
+    "[win,linux,mac]core/DesktopEditor/allthemesgen/allthemesgen.pro",
+
+    "[win,linux,mac]core/DesktopEditor/doctrenderer/app_builder/docbuilder.pro",
+
+    "[win,linux,mac]core/DesktopEditor/pluginsmanager/pluginsmanager.pro",
+
+    "[win,linux,mac,!linux_arm64]core/OfficeCryptReader/ooxml_crypt/ooxml_crypt.pro",
+
+    "[win,linux,mac,!no_tests]core/DesktopEditor/vboxtester/vboxtester.pro",
+    "[win,linux,mac,!no_tests]core/Test/Applications/StandardTester/standardtester.pro",
+    "[win,linux,mac,!no_tests]core/Test/Applications/x2tTester/x2ttester.pro",
+    "[win,linux,mac,!no_tests]core/Test/Applications/MetafileTester/MetafileTester.pro"
+
+  ],
+
+  "builder" : [
+    "core"
+  ],
+
+  "server" : [
+    "core"
+  ],
+
+  "multimedia" : [
+    "[win,linux]desktop-sdk/ChromiumBasedEditors/videoplayerlib/videoplayerlib.pro"
+  ],
+  
+  "spell" : [
+    "[win,linux,mac]core/Common/3dParty/hunspell/qt/hunspell.pro"
+  ],
+
+  "desktop" : [
+    "core",
+    "spell",
+    "multimedia",
+    
+    "core/DesktopEditor/xmlsec/src/ooxmlsignature.pro",
+
+    "desktop-sdk/ChromiumBasedEditors/lib/ascdocumentscore.pro",
+    "desktop-sdk/ChromiumBasedEditors/lib/ascdocumentscore_helper.pro",
+
+    "[win,linux]desktop-sdk/ChromiumBasedEditors/lib/qt_wrapper/qtascdocumentscore.pro",
+    "[win,linux]desktop-apps/win-linux/ASCDocumentEditor.pro",
+    
+    "[win]desktop-apps/win-linux/extras/projicons/ProjIcons.pro",
+    "[win,!win_xp]desktop-apps/win-linux/extras/update-daemon/UpdateDaemon.pro"
+  ],
+
+  "mobile" : [
+    "core"
+  ],
+
+  "osign" : [
+    "[win,linux,mac]core/DesktopEditor/xmlsec/src/osign/lib/osign.pro"
+  ]
+}

version

@@ -1 +1 @@
-7.6.0
+8.0.1