Fix debug build

Reviewed-on: https://git.onlyoffice.com/ONLYOFFICE/core/pulls/763

.gitignore

@@ -46,5 +46,6 @@ DesktopEditor/fontengine/js/common/freetype-2.10.4
 
 .qtc_clangd
 Common/3dParty/openssl/openssl/
+Common/3dParty/libxml/libxml2/
 
 msvc_make.bat

3DPARTY.md

@@ -16,3 +16,14 @@
 - cryptopp ([BSL](https://raw.githubusercontent.com/weidai11/cryptopp/master/License.txt))
 - openssl ([Apache-2.0](https://raw.githubusercontent.com/openssl/openssl/master/LICENSE.txt))
 - v8 ([3-clause BSD License](https://raw.githubusercontent.com/v8/v8/main/LICENSE))
+- googletest ([3-clause BSD License](https://raw.githubusercontent.com/google/googletest/refs/heads/main/LICENSE))
+- glm ([MIT](https://raw.githubusercontent.com/g-truc/glm/refs/heads/master/copying.txt))
+- mdds ([MIT](https://raw.githubusercontent.com/kohei-us/mdds/refs/heads/master/LICENSES/MIT.txt))
+- librevenge ([MPL-2](https://raw.githubusercontent.com/Distrotech/librevenge/refs/heads/distrotech-librevenge/COPYING.MPL))
+- libodfgen ([MPL-2](https://raw.githubusercontent.com/Distrotech/libodfgen/refs/heads/master/COPYING.MPL))
+- libetonyek ([MPL-2](https://raw.githubusercontent.com/LibreOffice/libetonyek/refs/heads/master/COPYING))
+- md4c ([MIT](https://raw.githubusercontent.com/mity/md4c/refs/heads/master/LICENSE.md))
+- libheif([MIT](https://raw.githubusercontent.com/strukturag/libheif/refs/heads/master/COPYING))
+- libde265([MIT](https://raw.githubusercontent.com/strukturag/libde265/refs/heads/master/COPYING))
+- x265([GPL 2.0](https://bitbucket.org/multicoreware/x265_git/raw/cfee9638c82b655c5887cedbdf1aa856f81b906a/COPYING))
+- pole([FREE](https://github.com/otofoto/Pole/blob/master/pole/LICENSE))

Apple/IWork.cpp

@@ -1,3 +1,38 @@
+/*
+ * Copyright (C) Ascensio System SIA, 2009-2026
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation, together with the
+ * additional terms provided in the LICENSE file.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
+ * details, see the GNU AGPL at: https://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA by email at info@onlyoffice.com
+ * or by postal mail at 20A-6 Ernesta Birznieka-Upisha Street, Riga,
+ * LV-1050, Latvia, European Union.
+ *
+ * The interactive user interfaces in modified versions of the Program
+ * are required to display Appropriate Legal Notices in accordance with
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * No trademark rights are granted under this License.
+ *
+ * All non-code elements of the Product, including illustrations,
+ * icon sets, and technical writing content, are licensed under the
+ * Creative Commons Attribution-ShareAlike 4.0 International License:
+ * https://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ * This license applies only to such non-code elements and does not
+ * modify or replace the licensing terms applicable to the Program's
+ * source code, which remains licensed under the GNU Affero General
+ * Public License v3.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
 #include "IWork.h"
 #include "../DesktopEditor/common/File.h"
 #include "../DesktopEditor/common/Directory.h"
@@ -53,7 +88,7 @@ bool GetRVNGInputStream(const DATA_TYPE_INPUTFILE& sFile, std::shared_ptr<librev
 
 IWorkFileType CIWorkFile::GetType(const std::wstring& sFile) const
 {
-	//TODO:: так как на данный момент мы работает только напрямую с файлом, то работа с директорией нам пока не нужна
+	//TODO:: since currently we work directly with file only, directory handling is not needed yet
 	if (NSDirectory::PathIsDirectory(sFile))
 		return IWorkFileType::None;
 
@@ -107,7 +142,7 @@ int Convert(const std::wstring& wsOutputFile, std::shared_ptr<librevenge::RVNGIn
 
 int CIWorkFile::Convert2Odf(const std::wstring& sFile, const std::wstring& sOutputFile) const
 {
-	//TODO:: так как на данный момент мы работает только напрямую с файлом, то работа с директорией нам пока не нужна
+	//TODO:: since currently we work directly with file only, directory handling is not needed yet
 	if (NSDirectory::PathIsDirectory(sFile))
 		return -1;
 

Apple/IWork.h

@@ -1,3 +1,38 @@
+/*
+ * Copyright (C) Ascensio System SIA, 2009-2026
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation, together with the
+ * additional terms provided in the LICENSE file.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
+ * details, see the GNU AGPL at: https://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA by email at info@onlyoffice.com
+ * or by postal mail at 20A-6 Ernesta Birznieka-Upisha Street, Riga,
+ * LV-1050, Latvia, European Union.
+ *
+ * The interactive user interfaces in modified versions of the Program
+ * are required to display Appropriate Legal Notices in accordance with
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * No trademark rights are granted under this License.
+ *
+ * All non-code elements of the Product, including illustrations,
+ * icon sets, and technical writing content, are licensed under the
+ * Creative Commons Attribution-ShareAlike 4.0 International License:
+ * https://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ * This license applies only to such non-code elements and does not
+ * modify or replace the licensing terms applicable to the Program's
+ * source code, which remains licensed under the GNU Affero General
+ * Public License v3.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
 #ifndef _IWORKFILE_IWORKFILE_H
 #define _IWORKFILE_IWORKFILE_H
 

Apple/IWork.pro

@@ -1,3 +1,36 @@
+# Copyright (C) Ascensio System SIA, 2009-2026
+#
+# This program is a free software product. You can redistribute it and/or
+# modify it under the terms of the GNU Affero General Public License (AGPL)
+# version 3 as published by the Free Software Foundation, together with the
+# additional terms provided in the LICENSE file.
+#
+# This program is distributed WITHOUT ANY WARRANTY; without even the implied
+# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
+# details, see the GNU AGPL at: https://www.gnu.org/licenses/agpl-3.0.html
+#
+# You can contact Ascensio System SIA by email at info@onlyoffice.com
+# or by postal mail at 20A-6 Ernesta Birznieka-Upisha Street, Riga,
+# LV-1050, Latvia, European Union.
+#
+# The interactive user interfaces in modified versions of the Program
+# are required to display Appropriate Legal Notices in accordance with
+# Section 5 of the GNU AGPL version 3.
+#
+# No trademark rights are granted under this License.
+#
+# All non-code elements of the Product, including illustrations,
+# icon sets, and technical writing content, are licensed under the
+# Creative Commons Attribution-ShareAlike 4.0 International License:
+# https://creativecommons.org/licenses/by-sa/4.0/legalcode
+#
+# This license applies only to such non-code elements and does not
+# modify or replace the licensing terms applicable to the Program's
+# source code, which remains licensed under the GNU Affero General
+# Public License v3.
+#
+# SPDX-License-Identifier: AGPL-3.0-only
+
 QT -= core
 QT -= gui
 

Apple/test/main.cpp

@@ -1,33 +1,36 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * Copyright (C) Ascensio System SIA, 2009-2026
  *
  * This program is a free software product. You can redistribute it and/or
  * modify it under the terms of the GNU Affero General Public License (AGPL)
- * version 3 as published by the Free Software Foundation. In accordance with
- * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
- * that Ascensio System SIA expressly excludes the warranty of non-infringement
- * of any third-party rights.
+ * version 3 as published by the Free Software Foundation, together with the
+ * additional terms provided in the LICENSE file.
  *
  * This program is distributed WITHOUT ANY WARRANTY; without even the implied
- * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
- * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
+ * details, see the GNU AGPL at: https://www.gnu.org/licenses/agpl-3.0.html
  *
- * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
- * street, Riga, Latvia, EU, LV-1050.
+ * You can contact Ascensio System SIA by email at info@onlyoffice.com
+ * or by postal mail at 20A-6 Ernesta Birznieka-Upisha Street, Riga,
+ * LV-1050, Latvia, European Union.
  *
- * The  interactive user interfaces in modified source and object code versions
- * of the Program must display Appropriate Legal Notices, as required under
+ * The interactive user interfaces in modified versions of the Program
+ * are required to display Appropriate Legal Notices in accordance with
  * Section 5 of the GNU AGPL version 3.
  *
- * Pursuant to Section 7(b) of the License you must retain the original Product
- * logo when distributing the program. Pursuant to Section 7(e) we decline to
- * grant you any rights under trademark law for use of our trademarks.
+ * No trademark rights are granted under this License.
  *
- * All the Product's GUI elements, including illustrations and icon sets, as
- * well as technical writing content are licensed under the terms of the
- * Creative Commons Attribution-ShareAlike 4.0 International. See the License
- * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ * All non-code elements of the Product, including illustrations,
+ * icon sets, and technical writing content, are licensed under the
+ * Creative Commons Attribution-ShareAlike 4.0 International License:
+ * https://creativecommons.org/licenses/by-sa/4.0/legalcode
  *
+ * This license applies only to such non-code elements and does not
+ * modify or replace the licensing terms applicable to the Program's
+ * source code, which remains licensed under the GNU Affero General
+ * Public License v3.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
  */
 
 #include "../IWork.h"

Apple/test/test.pro

@@ -1,3 +1,36 @@
+# Copyright (C) Ascensio System SIA, 2009-2026
+#
+# This program is a free software product. You can redistribute it and/or
+# modify it under the terms of the GNU Affero General Public License (AGPL)
+# version 3 as published by the Free Software Foundation, together with the
+# additional terms provided in the LICENSE file.
+#
+# This program is distributed WITHOUT ANY WARRANTY; without even the implied
+# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
+# details, see the GNU AGPL at: https://www.gnu.org/licenses/agpl-3.0.html
+#
+# You can contact Ascensio System SIA by email at info@onlyoffice.com
+# or by postal mail at 20A-6 Ernesta Birznieka-Upisha Street, Riga,
+# LV-1050, Latvia, European Union.
+#
+# The interactive user interfaces in modified versions of the Program
+# are required to display Appropriate Legal Notices in accordance with
+# Section 5 of the GNU AGPL version 3.
+#
+# No trademark rights are granted under this License.
+#
+# All non-code elements of the Product, including illustrations,
+# icon sets, and technical writing content, are licensed under the
+# Creative Commons Attribution-ShareAlike 4.0 International License:
+# https://creativecommons.org/licenses/by-sa/4.0/legalcode
+#
+# This license applies only to such non-code elements and does not
+# modify or replace the licensing terms applicable to the Program's
+# source code, which remains licensed under the GNU Affero General
+# Public License v3.
+#
+# SPDX-License-Identifier: AGPL-3.0-only
+
 CONFIG -= qt
 QT -= core gui
 

Common/.gitignore

@@ -0,0 +1 @@
+**/module.version

Common/3dParty/apple/fetch.py

@@ -6,12 +6,13 @@ import os
 if not base.is_dir("glm"):
     base.cmd("git", ["clone", "https://github.com/g-truc/glm.git"])
     base.cmd_in_dir("glm", "git", ["checkout", "33b4a621a697a305bc3a7610d290677b96beb181", "--quiet"])
+    base.replaceInFile("./glm/glm/detail/func_common.inl", "vec<L, T, Q> v;", "vec<L, T, Q> v{};")
 
 if not base.is_dir("mdds"):
     base.cmd("git", ["clone", "https://github.com/kohei-us/mdds.git"])
     base.cmd_in_dir("mdds", "git", ["checkout", "0783158939c6ce4b0b1b89e345ab983ccb0f0ad0"], "--quiet")
 
-    fix_cpp_version  = "#if __cplusplus < 201402L\n"
+    fix_cpp_version  = "#if __cplusplus < 201703L\n"
     fix_cpp_version += "#ifndef _MSC_VER\n"
     fix_cpp_version += "namespace std {\n"
     fix_cpp_version += "  template<bool __v>\n"

Common/3dParty/boost/boost.pri

@@ -4,6 +4,7 @@ CORE_BOOST_LIBS = $$PWD/build/$$CORE_BUILDS_PLATFORM_PREFIX/lib
 core_ios:CONFIG += disable_enum_constexpr_conversion
 core_android:CONFIG += disable_enum_constexpr_conversion
 core_mac:CONFIG += disable_enum_constexpr_conversion
+core_linux_clang:CONFIG += disable_enum_constexpr_conversion
 
 core_android {
     INCLUDEPATH += $$PWD/build/android/include
@@ -25,14 +26,21 @@ bundle_xcframeworks {
     }
 }
 
+core_win_arm64 {
+    DEFINES += MICROSOFT_WINDOWS_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS=0
+}
+
 core_windows {
     VS_VERSION=140
     VS_DEBUG=
     VS_ARCH=x64
     core_debug:VS_DEBUG=gd-
     core_win_32:VS_ARCH=x32
+    core_win_arm64:VS_ARCH=a64
     vs2019:VS_VERSION=142
 
+    DEFINES += BOOST_USE_WINDOWS_H BOOST_WINAPI_NO_REDECLARATIONS
+
     BOOST_POSTFIX = -vc$${VS_VERSION}-mt-$${VS_DEBUG}$${VS_ARCH}-1_72
 
     core_boost_libs:LIBS += -L$$CORE_BOOST_LIBS -llibboost_system$$BOOST_POSTFIX -llibboost_filesystem$$BOOST_POSTFIX

Common/3dParty/boost/patches/mpl_integral_wrapper.patch

@@ -0,0 +1,36 @@
+<<<<<<<
+#if BOOST_WORKAROUND(__EDG_VERSION__, <= 243)
+ private:
+    BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, next_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1)));
+    BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, prior_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1)));
+ public:
+    typedef AUX_WRAPPER_INST(next_value) next;
+    typedef AUX_WRAPPER_INST(prior_value) prior;
+#elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \
+    || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(502)) \
+    || (BOOST_WORKAROUND(__HP_aCC, <= 53800) && (BOOST_WORKAROUND(__hpxstd98, != 1)))
+    typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1)) ) next;
+    typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1)) ) prior;
+#else
+    typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (value + 1)) ) next;
+    typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (value - 1)) ) prior;
+#endif
+=======
+#if BOOST_WORKAROUND(__EDG_VERSION__, <= 243) \
+    || defined(__clang__)
+ private:
+    BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, next_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1)));
+    BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, prior_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1)));
+ public:
+    typedef AUX_WRAPPER_INST(next_value) next;
+    typedef AUX_WRAPPER_INST(prior_value) prior;
+#elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \
+    || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(502)) \
+    || (BOOST_WORKAROUND(__HP_aCC, <= 53800) && (BOOST_WORKAROUND(__hpxstd98, != 1)))
+    typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1)) ) next;
+    typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1)) ) prior;
+#else
+    typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (value + 1)) ) next;
+    typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (value - 1)) ) prior;
+#endif
+>>>>>>>

Common/3dParty/brotli/.gitignore

@@ -0,0 +1,2 @@
+brotli/
+module.version

Common/3dParty/brotli/brotli.pri

@@ -0,0 +1,9 @@
+SRC_DIR = $$PWD/brotli/c
+DEFINES += FT_CONFIG_OPTION_USE_BROTLI
+
+INCLUDEPATH += \
+  $$SRC_DIR/include
+
+SOURCES += $$files($$SRC_DIR/common/*.c)
+SOURCES += $$files($$SRC_DIR/dec/*.c)
+#SOURCES += $$files($$SRC_DIR/enc/*.c)

Common/3dParty/brotli/make.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+
+import sys
+import os
+sys.path.append("../../../../build_tools/scripts")
+import base
+
+def clear_module():
+  if base.is_dir("brotli"):
+    base.delete_dir_with_access_error("brotli")
+  return
+
+base.check_module_version("1", clear_module)
+
+# fetch harfbuzz
+if not base.is_dir("brotli"):
+  base.cmd("git", ["clone", "https://github.com/google/brotli.git"])
+  os.chdir("brotli")
+  base.cmd("git", ["checkout", "a47d7475063eb223c87632eed806c0070e70da29"])
+  os.chdir("../")

Common/3dParty/harfbuzz/test/main.cpp

@@ -0,0 +1,818 @@
+// https://android.googlesource.com/platform/external/harfbuzz/+/ics-mr0/contrib/tables/script-properties.h
+
+/*
+ * https://unicode.org/reports/tr29/
+
+As far as a user is concerned, the underlying representation of text is not important,
+but it is important that an editing interface present a uniform implementation of what
+the user thinks of as characters. Grapheme clusters can be treated as units, by default,
+for processes such as the formatting of drop caps, as well as the implementation of text
+selection, arrow key movement or backspacing through text, and so forth. For example,
+when a grapheme cluster is represented internally by a character sequence consisting of
+base character + accents, then using the right arrow key would skip from the start of the
+base character to the end of the last accent.
+
+This document defines a default specification for grapheme clusters. It may be customized
+ for particular languages, operations, or other situations. For example, arrow key movement
+could be tailored by language, or could use knowledge specific to particular fonts to move
+in a more granular manner, in circumstances where it would be useful to edit individual
+components. This could apply, for example, to the complex editorial requirements for the
+Northern Thai script Tai Tham (Lanna). Similarly, editing a grapheme cluster element by
+element may be preferable in some circumstances. For example, on a given system the backspace
+key might delete by code point, while the delete key may delete an entire cluster.
+ * */
+
+#include "../../../core/DesktopEditor/common/File.h"
+#include "../../../core/DesktopEditor/raster/BgraFrame.h"
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+#include FT_OUTLINE_H
+
+#include <hb-ft.h>
+#include <hb-ot.h>
+#include <hb.h>
+
+class CDrawer
+{
+public:
+	CBgraFrame m_oFrame;
+	BYTE *pixels;
+	int width;
+	int height;
+	int pitch;
+	BYTE Rshift;
+	BYTE Gshift;
+	BYTE Bshift;
+	BYTE Ashift;
+
+public:
+	CDrawer(int w, int h)
+	{
+		width = w;
+		height = h;
+		pitch = 4 * width;
+		m_oFrame.put_Width(width);
+		m_oFrame.put_Height(height);
+		m_oFrame.put_Stride(pitch);
+
+		int size = 4 * width * height;
+		BYTE *pPixels = new BYTE[size];
+		for (int i = 0; i < size; i += 4)
+		{
+			pPixels[i] = 0xFF;
+			pPixels[i + 1] = 0xFF;
+			pPixels[i + 2] = 0xFF;
+			pPixels[i + 3] = 0xFF;
+		}
+		pixels = pPixels;
+		m_oFrame.put_Data(pPixels);
+
+		Bshift = 24;
+		Gshift = 16;
+		Rshift = 8;
+		Ashift = 0;
+	}
+	void Save()
+	{
+		m_oFrame.SaveFile(NSFile::GetProcessDirectory() + L"/output.png", 4);
+	}
+};
+
+#define NUM_EXAMPLES 3
+
+/* fonts */
+const char *fonts_paths[NUM_EXAMPLES] = {
+	"C:/Windows/Fonts/calibri.ttf",
+	//"C:/Windows/Fonts/arial.ttf",
+	"C:/Users/korol/AppData/Local/Microsoft/Windows/Fonts/ArabicTest.ttf",
+	"C:/Windows/Fonts/simsun.ttc"
+};
+
+#define NUM_GLYPH_TYPES 5
+const char *num_glyph_types[NUM_GLYPH_TYPES] = {"UNCLASSIFIED", "BASE_GLYPH", "LIGATURE", "MARK", "COMPONENT"};
+
+/* tranlations courtesy of google */
+const char *texts[NUM_EXAMPLES] = {
+	"fi",
+	"لا لآ لأ لا",
+	"懶惰的姜貓"
+};
+
+const hb_direction_t text_directions[NUM_EXAMPLES] = {
+	HB_DIRECTION_LTR,
+	HB_DIRECTION_RTL,
+	HB_DIRECTION_TTB,
+};
+
+const int text_skip[NUM_EXAMPLES] = {
+	0,
+	0,
+	1,
+};
+
+/* XXX: These are not correct, though it doesn't seem to break anything
+ *      regardless of their value. */
+const char *languages[NUM_EXAMPLES] = {
+	"en",
+	"ar",
+	"ch",
+};
+
+const hb_script_t scripts[NUM_EXAMPLES] = {
+	HB_SCRIPT_LATIN,
+	HB_SCRIPT_ARABIC,
+	HB_SCRIPT_HAN,
+};
+
+enum
+{
+	ENGLISH = 0,
+	ARABIC,
+	CHINESE
+};
+
+typedef struct _spanner_baton_t
+{
+	/* rendering part - assumes 32bpp surface */
+	uint32_t *pixels;					// set to the glyph's origin.
+	uint32_t *first_pixel, *last_pixel; // bounds check
+	uint32_t pitch;
+	uint32_t rshift;
+	uint32_t gshift;
+	uint32_t bshift;
+	uint32_t ashift;
+
+	/* sizing part */
+	int min_span_x;
+	int max_span_x;
+	int min_y;
+	int max_y;
+} spanner_baton_t;
+
+/* This spanner is write only, suitable for write-only mapped buffers,
+   but can cause dark streaks where glyphs overlap, like in arabic scripts.
+
+   Note how spanners don't clip against surface width - resize the window
+   and see what it leads to. */
+void spanner_wo(int y, int count, const FT_Span *spans, void *user)
+{
+	spanner_baton_t *baton = (spanner_baton_t *)user;
+	uint32_t *scanline = baton->pixels - y * ((int)baton->pitch / 4);
+	if (scanline < baton->first_pixel)
+		return;
+	for (int i = 0; i < count; i++)
+	{
+		uint32_t color = ((spans[i].coverage / 2) << baton->rshift) | ((spans[i].coverage / 2) << baton->gshift) | ((spans[i].coverage / 2) << baton->bshift);
+
+		uint32_t *start = scanline + spans[i].x;
+		if (start + spans[i].len > baton->last_pixel)
+			return;
+
+		for (int x = 0; x < spans[i].len; x++)
+			*start++ = color;
+	}
+}
+
+/* This spanner does read/modify/write, trading performance for accuracy.
+   The color here is simply half coverage value in all channels,
+   effectively mid-gray.
+   Suitable for when artifacts mostly do come up and annoy.
+   This might be optimized if one does rmw only for some values of x.
+   But since the whole buffer has to be rw anyway, and the previous value
+   is probably still in the cache, there's little point to. */
+void spanner_rw(int y, int count, const FT_Span *spans, void *user)
+{
+	spanner_baton_t *baton = (spanner_baton_t *)user;
+	uint32_t *scanline = baton->pixels - y * ((int)baton->pitch / 4);
+	if (scanline < baton->first_pixel)
+		return;
+
+	for (int i = 0; i < count; i++)
+	{
+		uint32_t color = ((spans[i].coverage / 2) << baton->rshift) | ((spans[i].coverage / 2) << baton->gshift) | ((spans[i].coverage / 2) << baton->bshift);
+		uint32_t *start = scanline + spans[i].x;
+		if (start + spans[i].len > baton->last_pixel)
+			return;
+
+		for (int x = 0; x < spans[i].len; x++)
+			*start++ |= color;
+	}
+}
+
+/*  This spanner is for obtaining exact bounding box for the string.
+	Unfortunately this can't be done without rendering it (or pretending to).
+	After this runs, we get min and max values of coordinates used.
+*/
+void spanner_sizer(int y, int count, const FT_Span *spans, void *user)
+{
+	spanner_baton_t *baton = (spanner_baton_t *)user;
+
+	if (y < baton->min_y)
+		baton->min_y = y;
+	if (y > baton->max_y)
+		baton->max_y = y;
+	for (int i = 0; i < count; i++)
+	{
+		if (spans[i].x + spans[i].len > baton->max_span_x)
+			baton->max_span_x = spans[i].x + spans[i].len;
+		if (spans[i].x < baton->min_span_x)
+			baton->min_span_x = spans[i].x;
+	}
+}
+
+FT_SpanFunc spanner = spanner_wo;
+
+void ftfdump(FT_Face ftf)
+{
+	for (int i = 0; i < ftf->num_charmaps; i++)
+	{
+		printf(
+			"%d: %s %s %c%c%c%c plat=%hu id=%hu\n", i, ftf->family_name, ftf->style_name, ftf->charmaps[i]->encoding >> 24, (ftf->charmaps[i]->encoding >> 16) & 0xff,
+			(ftf->charmaps[i]->encoding >> 8) & 0xff, (ftf->charmaps[i]->encoding) & 0xff, ftf->charmaps[i]->platform_id, ftf->charmaps[i]->encoding_id);
+	}
+}
+
+/*  See http://www.microsoft.com/typography/otspec/name.htm
+	for a list of some possible platform-encoding pairs.
+	We're interested in 0-3 aka 3-1 - UCS-2.
+	Otherwise, fail. If a font has some unicode map, but lacks
+	UCS-2 - it is a broken or irrelevant font. What exactly
+	Freetype will select on face load (it promises most wide
+	unicode, and if that will be slower that UCS-2 - left as
+	an excercise to check. */
+int force_ucs2_charmap(FT_Face ftf)
+{
+	for (int i = 0; i < ftf->num_charmaps; i++)
+		if (((ftf->charmaps[i]->platform_id == 0) && (ftf->charmaps[i]->encoding_id == 3)) || ((ftf->charmaps[i]->platform_id == 3) && (ftf->charmaps[i]->encoding_id == 1)))
+			return FT_Set_Charmap(ftf, ftf->charmaps[i]);
+	return -1;
+}
+
+void hline(CDrawer *s, int min_x, int max_x, int y, uint32_t color)
+{
+	if (y < 0)
+		y = 0;
+	uint32_t *pix = (uint32_t *)s->pixels + (y * s->pitch) / 4 + min_x;
+	uint32_t *end = (uint32_t *)s->pixels + (y * s->pitch) / 4 + max_x;
+
+	while (pix - 1 != end)
+		*pix++ = color;
+}
+
+void vline(CDrawer *s, int min_y, int max_y, int x, uint32_t color)
+{
+	if (min_y < 0)
+		min_y = 0;
+
+	uint32_t *pix = (uint32_t *)s->pixels + (min_y * s->pitch) / 4 + x;
+	uint32_t *end = (uint32_t *)s->pixels + (max_y * s->pitch) / 4 + x;
+
+	while (pix - s->pitch / 4 != end)
+	{
+		*pix = color;
+		pix += s->pitch / 4;
+	}
+}
+
+void assert(const bool &valid)
+{
+	// TODO:
+}
+
+#define MAIN_CC_NO_PRIVATE_API
+#ifndef MAIN_CC_NO_PRIVATE_API
+/* Only this part of this mini app uses private API */
+#include "hb-open-file.hh"
+#include "hb-ot-layout-gdef-table.hh"
+#include "hb-ot-layout-gsubgpos.hh"
+#include "hb-static.cc"
+
+using namespace OT;
+
+static void print_layout_info_using_private_api(hb_blob_t *blob)
+{
+	const char *font_data = hb_blob_get_data(blob, nullptr);
+	hb_blob_t *font_blob = hb_sanitize_context_t().sanitize_blob<OpenTypeFontFile>(blob);
+	const OpenTypeFontFile *sanitized = font_blob->as<OpenTypeFontFile>();
+	if (!font_blob->data)
+	{
+		printf("Sanitization of the file wasn't successful. Exit");
+		exit(1);
+	}
+	const OpenTypeFontFile &ot = *sanitized;
+
+	switch (ot.get_tag())
+	{
+	case OpenTypeFontFile::TrueTypeTag:
+		printf("OpenType font with TrueType outlines\n");
+		break;
+	case OpenTypeFontFile::CFFTag:
+		printf("OpenType font with CFF (Type1) outlines\n");
+		break;
+	case OpenTypeFontFile::TTCTag:
+		printf("TrueType Collection of OpenType fonts\n");
+		break;
+	case OpenTypeFontFile::TrueTag:
+		printf("Obsolete Apple TrueType font\n");
+		break;
+	case OpenTypeFontFile::Typ1Tag:
+		printf("Obsolete Apple Type1 font in SFNT container\n");
+		break;
+	case OpenTypeFontFile::DFontTag:
+		printf("DFont Mac Resource Fork\n");
+		break;
+	default:
+		printf("Unknown font format\n");
+		break;
+	}
+
+	unsigned num_faces = hb_face_count(blob);
+	printf("%d font(s) found in file\n", num_faces);
+	for (unsigned n_font = 0; n_font < num_faces; ++n_font)
+	{
+		const OpenTypeFontFace &font = ot.get_face(n_font);
+		printf("Font %d of %d:\n", n_font, num_faces);
+
+		unsigned num_tables = font.get_table_count();
+		printf("  %d table(s) found in font\n", num_tables);
+		for (unsigned n_table = 0; n_table < num_tables; ++n_table)
+		{
+			const OpenTypeTable &table = font.get_table(n_table);
+			printf("  Table %2d of %2d: %.4s (0x%08x+0x%08x)\n", n_table, num_tables, (const char *)table.tag, (unsigned)table.offset, (unsigned)table.length);
+
+			switch (table.tag)
+			{
+
+			case HB_OT_TAG_GSUB:
+			case HB_OT_TAG_GPOS:
+			{
+
+				const GSUBGPOS &g = *reinterpret_cast<const GSUBGPOS *>(font_data + table.offset);
+
+				unsigned num_scripts = g.get_script_count();
+				printf("    %d script(s) found in table\n", num_scripts);
+				for (unsigned n_script = 0; n_script < num_scripts; ++n_script)
+				{
+					const Script &script = g.get_script(n_script);
+					printf("    Script %2d of %2d: %.4s\n", n_script, num_scripts, (const char *)g.get_script_tag(n_script));
+
+					if (!script.has_default_lang_sys())
+						printf("      No default language system\n");
+					int num_langsys = script.get_lang_sys_count();
+					printf("      %d language system(s) found in script\n", num_langsys);
+					for (int n_langsys = script.has_default_lang_sys() ? -1 : 0; n_langsys < num_langsys; ++n_langsys)
+					{
+						const LangSys &langsys = n_langsys == -1 ? script.get_default_lang_sys() : script.get_lang_sys(n_langsys);
+						if (n_langsys == -1)
+							printf("      Default Language System\n");
+						else
+							printf("      Language System %2d of %2d: %.4s\n", n_langsys, num_langsys, (const char *)script.get_lang_sys_tag(n_langsys));
+						if (!langsys.has_required_feature())
+							printf("        No required feature\n");
+						else
+							printf("        Required feature index: %d\n", langsys.get_required_feature_index());
+
+						unsigned num_features = langsys.get_feature_count();
+						printf("        %d feature(s) found in language system\n", num_features);
+						for (unsigned n_feature = 0; n_feature < num_features; ++n_feature)
+						{
+							printf("        Feature index %2d of %2d: %d\n", n_feature, num_features, langsys.get_feature_index(n_feature));
+						}
+					}
+				}
+
+				unsigned num_features = g.get_feature_count();
+				printf("    %d feature(s) found in table\n", num_features);
+				for (unsigned n_feature = 0; n_feature < num_features; ++n_feature)
+				{
+					const Feature &feature = g.get_feature(n_feature);
+					unsigned num_lookups = feature.get_lookup_count();
+					printf("    Feature %2d of %2d: %c%c%c%c\n", n_feature, num_features, HB_UNTAG(g.get_feature_tag(n_feature)));
+
+					printf("        %d lookup(s) found in feature\n", num_lookups);
+					for (unsigned n_lookup = 0; n_lookup < num_lookups; ++n_lookup)
+					{
+						printf("        Lookup index %2d of %2d: %d\n", n_lookup, num_lookups, feature.get_lookup_index(n_lookup));
+					}
+				}
+
+				unsigned num_lookups = g.get_lookup_count();
+				printf("    %d lookup(s) found in table\n", num_lookups);
+				for (unsigned n_lookup = 0; n_lookup < num_lookups; ++n_lookup)
+				{
+					const Lookup &lookup = g.get_lookup(n_lookup);
+					printf("    Lookup %2d of %2d: type %d, props 0x%04X\n", n_lookup, num_lookups, lookup.get_type(), lookup.get_props());
+				}
+			}
+			break;
+
+			case GDEF::tableTag:
+			{
+
+				const GDEF &gdef = *reinterpret_cast<const GDEF *>(font_data + table.offset);
+
+				printf("    Has %sglyph classes\n", gdef.has_glyph_classes() ? "" : "no ");
+				printf("    Has %smark attachment types\n", gdef.has_mark_attachment_types() ? "" : "no ");
+				printf("    Has %sattach points\n", gdef.has_attach_points() ? "" : "no ");
+				printf("    Has %slig carets\n", gdef.has_lig_carets() ? "" : "no ");
+				printf("    Has %smark sets\n", gdef.has_mark_sets() ? "" : "no ");
+
+				hb_position_t caret_array[16];
+				unsigned int caret_count = 16;
+
+				unsigned int num_carets = gdef.get_lig_carets(nullptr, HB_DIRECTION_LTR, 302, 0, &caret_count, caret_array);
+				int y = 0;
+				++y;
+
+				break;
+			}
+			}
+		}
+	}
+}
+/* end of private API use */
+#endif
+
+struct hb_feature_test {
+	hb_tag_t tag;
+	uint32_t value;
+};
+
+int main(int argc, char *argv[])
+{
+	// hb_blob_t* blobFileTest = hb_blob_create_from_file("C:/Windows/Fonts/calibri.ttf");
+	// print_layout_info_using_private_api(blobFileTest);
+
+	int ptSize = 40 * 64;
+	int device_hdpi = 72;
+	int device_vdpi = 72;
+
+	/* Init freetype */
+	FT_Library ft_library;
+	assert(!FT_Init_FreeType(&ft_library));
+
+	/* Load our fonts */
+	FT_Face ft_face[NUM_EXAMPLES];
+	assert(!FT_New_Face(ft_library, fonts_paths[0], 0, &ft_face[ENGLISH]));
+	assert(!FT_Set_Char_Size(ft_face[ENGLISH], 0, ptSize, device_hdpi, device_vdpi));
+	ftfdump(ft_face[ENGLISH]); // wonderful world of encodings ...
+	// force_ucs2_charmap(ft_face[ENGLISH]); // which we ignore.
+
+	assert(!FT_New_Face(ft_library, fonts_paths[1], 0, &ft_face[ARABIC]));
+	assert(!FT_Set_Char_Size(ft_face[ARABIC], 0, ptSize, device_hdpi, device_vdpi));
+	ftfdump(ft_face[ARABIC]);
+	// force_ucs2_charmap(ft_face[ARABIC]);
+
+	assert(!FT_New_Face(ft_library, fonts_paths[2], 0, &ft_face[CHINESE]));
+	assert(!FT_Set_Char_Size(ft_face[CHINESE], 0, ptSize, device_hdpi, device_vdpi));
+	ftfdump(ft_face[CHINESE]);
+	// force_ucs2_charmap(ft_face[CHINESE]);
+
+	/* Get our harfbuzz font structs */
+	hb_font_t *hb_ft_font[NUM_EXAMPLES];
+	hb_ft_font[ENGLISH] = hb_ft_font_create(ft_face[ENGLISH], NULL);
+
+	// hb_blob_t* blobFile = hb_blob_create_from_file(sFont1.c_str());
+	// hb_face_t* faceFile = hb_face_create(blobFile, 0);
+	// hb_ft_font[ENGLISH] = hb_font_create(faceFile);
+
+	hb_ft_font[ARABIC] = hb_ft_font_create(ft_face[ARABIC], NULL);
+	hb_ft_font[CHINESE] = hb_ft_font_create(ft_face[CHINESE], NULL);
+
+	hb_ft_font_set_funcs(hb_ft_font[ENGLISH]);
+	hb_ft_font_set_funcs(hb_ft_font[ARABIC]);
+	hb_ft_font_set_funcs(hb_ft_font[CHINESE]);
+
+	/** Setup our SDL window **/
+	int width = 800;
+	int height = 600;
+	int bpp = 32;
+
+	CDrawer oDrawer(width, height);
+
+	/* Create a buffer for harfbuzz to use */
+	hb_buffer_t *buf = hb_buffer_create();
+	for (int i = 0; i < NUM_EXAMPLES; ++i)
+	{
+		if (text_skip[i])
+			continue;
+
+		hb_buffer_set_direction(buf, text_directions[i]); /* or LTR */
+		hb_buffer_set_script(buf, scripts[i]);			  /* see hb-unicode.h */
+		hb_buffer_set_language(buf, hb_language_from_string(languages[i], strlen(languages[i])));
+		// hb_buffer_set_cluster_level (buf, HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES);
+		// hb_buffer_set_cluster_level (buf, HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS);
+		hb_buffer_set_cluster_level(buf, HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES);
+
+		hb_feature_test features[] {
+			{HB_TAG('r','l','i','g'), 1},
+			{HB_TAG('l','i','g','a'), 0},
+			{HB_TAG('c','l','i','g'), 1},
+			{HB_TAG('h','l','i','g'), 1},
+			{HB_TAG('d','l','i','g'), 1},
+			{HB_TAG('k','e','r','n'), 2},
+			{0, 0}
+		};
+
+		int userfeatures_count = 0;
+		hb_feature_t userfeatures[100];
+
+		hb_feature_test* current_feature = features;
+		while (current_feature->tag != 0)
+		{
+			if (current_feature->value != 2)
+			{
+				userfeatures[userfeatures_count].tag   = current_feature->tag;
+				userfeatures[userfeatures_count].value = current_feature->value;
+				userfeatures[userfeatures_count].start = HB_FEATURE_GLOBAL_START;
+				userfeatures[userfeatures_count].end   = HB_FEATURE_GLOBAL_END;
+				userfeatures_count++;
+			}
+			current_feature++;
+		}
+
+		/* Layout the text */
+		hb_buffer_add_utf8(buf, texts[i], strlen(texts[i]), 0, strlen(texts[i]));
+
+		// detect script by codes
+		hb_buffer_guess_segment_properties(buf);
+
+		// const char*const pHbShapers[] = { "graphite2", "coretext_aat", "ot", "fallback", nullptr };
+		// bool ok = hb_shape_full(hb_ft_font[i], buf, userfeatures, userfeatures_count, pHbShapers);
+
+		hb_shape(hb_ft_font[i], buf, (userfeatures_count != 0) ? userfeatures : NULL, userfeatures_count);
+
+		unsigned int glyph_count;
+		hb_glyph_info_t *glyph_info = hb_buffer_get_glyph_infos(buf, &glyph_count);
+		hb_glyph_position_t *glyph_pos = hb_buffer_get_glyph_positions(buf, &glyph_count);
+
+#if 1
+		hb_position_t caret_array[16];
+		unsigned int caret_count = 16;
+
+		unsigned int num_carets = hb_ot_layout_get_ligature_carets(hb_ft_font[i], text_directions[i], glyph_info[0].codepoint, -1, &caret_count, caret_array);
+#endif
+
+		/* set up rendering via spanners */
+		spanner_baton_t stuffbaton;
+
+		FT_Raster_Params ftr_params;
+		ftr_params.target = 0;
+		ftr_params.flags = FT_RASTER_FLAG_DIRECT | FT_RASTER_FLAG_AA;
+		ftr_params.user = &stuffbaton;
+		ftr_params.black_spans = 0;
+		ftr_params.bit_set = 0;
+		ftr_params.bit_test = 0;
+
+		/* Calculate string bounding box in pixels */
+		ftr_params.gray_spans = spanner_sizer;
+
+		/* See http://www.freetype.org/freetype2/docs/glyphs/glyphs-3.html */
+
+		int max_x = INT_MIN; // largest coordinate a pixel has been set at, or the pen was advanced to.
+		int min_x = INT_MAX; // smallest coordinate a pixel has been set at, or the pen was advanced to.
+		int max_y = INT_MIN; // this is max topside bearing along the string.
+		int min_y = INT_MAX; // this is max value of (height - topbearing) along the string.
+		/*  Naturally, the above comments swap their meaning between horizontal and vertical scripts,
+			since the pen changes the axis it is advanced along.
+			However, their differences still make up the bounding box for the string.
+			Also note that all this is in FT coordinate system where y axis points upwards.
+		 */
+
+		int sizer_x = 0;
+		int sizer_y = 0; /* in FT coordinate system. */
+
+		printf("----------------------------------------------------\n");
+		for (unsigned j = 0; j < glyph_count; ++j)
+		{
+			hb_ot_layout_glyph_class_t glyph_type = hb_ot_layout_get_glyph_class(hb_font_get_face(hb_ft_font[i]), glyph_info[j].codepoint);
+			hb_glyph_flags_t glyph_type_flags = hb_glyph_info_get_glyph_flags(&glyph_info[j]);
+			printf(
+				"glyph(%s, flags: %d): gid:%d, cluster:%d, [%d, %d, %d, %d, %d]\n", num_glyph_types[glyph_type], glyph_type_flags, (int)glyph_info[j].codepoint, (int)glyph_info[j].cluster,
+				glyph_pos[j].x_advance, glyph_pos[j].y_advance, glyph_pos[j].x_offset, glyph_pos[j].y_offset, glyph_pos[j].var);
+		}
+
+		FT_Error fterr;
+		for (unsigned j = 0; j < glyph_count; ++j)
+		{
+			if ((fterr = FT_Load_Glyph(ft_face[i], glyph_info[j].codepoint, 0)))
+			{
+				printf("load %08x failed fterr=%d.\n", glyph_info[j].codepoint, fterr);
+			}
+			else
+			{
+				if (ft_face[i]->glyph->format != FT_GLYPH_FORMAT_OUTLINE)
+				{
+					printf("glyph->format = %4s\n", (char *)&ft_face[i]->glyph->format);
+				}
+				else
+				{
+					int gx = sizer_x + (glyph_pos[j].x_offset / 64);
+					int gy = sizer_y + (glyph_pos[j].y_offset / 64); // note how the sign differs from the rendering pass
+
+					stuffbaton.min_span_x = INT_MAX;
+					stuffbaton.max_span_x = INT_MIN;
+					stuffbaton.min_y = INT_MAX;
+					stuffbaton.max_y = INT_MIN;
+
+					if ((fterr = FT_Outline_Render(ft_library, &ft_face[i]->glyph->outline, &ftr_params)))
+						printf("FT_Outline_Render() failed err=%d\n", fterr);
+
+					if (stuffbaton.min_span_x != INT_MAX)
+					{
+						/* Update values if the spanner was actually called. */
+						if (min_x > stuffbaton.min_span_x + gx)
+							min_x = stuffbaton.min_span_x + gx;
+
+						if (max_x < stuffbaton.max_span_x + gx)
+							max_x = stuffbaton.max_span_x + gx;
+
+						if (min_y > stuffbaton.min_y + gy)
+							min_y = stuffbaton.min_y + gy;
+
+						if (max_y < stuffbaton.max_y + gy)
+							max_y = stuffbaton.max_y + gy;
+					}
+					else
+					{
+						/* The spanner wasn't called at all - an empty glyph, like space. */
+						if (min_x > gx)
+							min_x = gx;
+						if (max_x < gx)
+							max_x = gx;
+						if (min_y > gy)
+							min_y = gy;
+						if (max_y < gy)
+							max_y = gy;
+					}
+				}
+			}
+
+			sizer_x += glyph_pos[j].x_advance / 64;
+			sizer_y += glyph_pos[j].y_advance / 64; // note how the sign differs from the rendering pass
+		}
+		/* Still have to take into account last glyph's advance. Or not? */
+		if (min_x > sizer_x)
+			min_x = sizer_x;
+		if (max_x < sizer_x)
+			max_x = sizer_x;
+		if (min_y > sizer_y)
+			min_y = sizer_y;
+		if (max_y < sizer_y)
+			max_y = sizer_y;
+
+		/* The bounding box */
+		int bbox_w = max_x - min_x;
+		int bbox_h = max_y - min_y;
+
+		/* Two offsets below position the bounding box with respect to the 'origin',
+			which is sort of origin of string's first glyph.
+
+			baseline_offset - offset perpendecular to the baseline to the topmost (horizontal),
+							  or leftmost (vertical) pixel drawn.
+
+			baseline_shift  - offset along the baseline, from the first drawn glyph's origin
+							  to the leftmost (horizontal), or topmost (vertical) pixel drawn.
+
+			Thus those offsets allow positioning the bounding box to fit the rendered string,
+			as they are in fact offsets from the point given to the renderer, to the top left
+			corner of the bounding box.
+
+			NB: baseline is defined as y==0 for horizontal and x==0 for vertical scripts.
+			(0,0) here is where the first glyph's origin ended up after shaping, not taking
+			into account glyph_pos[0].xy_offset (yeah, my head hurts too).
+		*/
+
+		int baseline_offset;
+		int baseline_shift;
+
+		if (HB_DIRECTION_IS_HORIZONTAL(hb_buffer_get_direction(buf)))
+		{
+			baseline_offset = max_y;
+			baseline_shift = min_x;
+		}
+		if (HB_DIRECTION_IS_VERTICAL(hb_buffer_get_direction(buf)))
+		{
+			baseline_offset = min_x;
+			baseline_shift = max_y;
+		}
+
+		/* The pen/baseline start coordinates in window coordinate system
+			- with those text placement in the window is controlled.
+			- note that for RTL scripts pen still goes LTR */
+		int x = 0, y = 50 + i * 75;
+		if (i == ENGLISH)
+		{
+			x = 20;
+		} /* left justify */
+		if (i == ARABIC)
+		{
+			x = width - bbox_w - 20;
+		} /* right justify */
+		if (i == CHINESE)
+		{
+			x = width / 2 - bbox_w / 2;
+		} /* center, and for TTB script h_advance is half-width. */
+
+		/* Draw baseline and the bounding box */
+		/* The below is complicated since we simultaneously
+		   convert to the window coordinate system. */
+		int left, right, top, bottom;
+
+		if (HB_DIRECTION_IS_HORIZONTAL(hb_buffer_get_direction(buf)))
+		{
+			/* bounding box in window coordinates without offsets */
+			left = x;
+			right = x + bbox_w;
+			top = y - bbox_h;
+			bottom = y;
+
+			/* apply offsets */
+			left += baseline_shift;
+			right += baseline_shift;
+			top -= baseline_offset - bbox_h;
+			bottom -= baseline_offset - bbox_h;
+
+			/* draw the baseline */
+			hline(&oDrawer, x, x + bbox_w, y, 0x0000ff00);
+		}
+
+		if (HB_DIRECTION_IS_VERTICAL(hb_buffer_get_direction(buf)))
+		{
+			left = x;
+			right = x + bbox_w;
+			top = y;
+			bottom = y + bbox_h;
+
+			left += baseline_offset;
+			right += baseline_offset;
+			top -= baseline_shift;
+			bottom -= baseline_shift;
+
+			vline(&oDrawer, y, y + bbox_h, x, 0x0000ff00);
+		}
+
+		/* +1/-1 are for the bbox borders be the next pixel outside the bbox itself */
+		hline(&oDrawer, left - 1, right + 1, top - 1, 0xffff0000);
+		hline(&oDrawer, left - 1, right + 1, bottom + 1, 0xffff0000);
+		vline(&oDrawer, top - 1, bottom + 1, left - 1, 0xffff0000);
+		vline(&oDrawer, top - 1, bottom + 1, right + 1, 0xffff0000);
+
+		/* set rendering spanner */
+		ftr_params.gray_spans = spanner;
+
+		/* initialize rendering part of the baton */
+		stuffbaton.pixels = NULL;
+		stuffbaton.first_pixel = (uint32_t *)oDrawer.pixels;
+		stuffbaton.last_pixel = (uint32_t *)(((uint8_t *)oDrawer.pixels) + oDrawer.pitch * oDrawer.height);
+		stuffbaton.pitch = oDrawer.pitch;
+		stuffbaton.rshift = oDrawer.Rshift;
+		stuffbaton.gshift = oDrawer.Gshift;
+		stuffbaton.bshift = oDrawer.Bshift;
+
+		/* render */
+		for (unsigned j = 0; j < glyph_count; ++j)
+		{
+			if ((fterr = FT_Load_Glyph(ft_face[i], glyph_info[j].codepoint, 0)))
+			{
+				printf("load %08x failed fterr=%d.\n", glyph_info[j].codepoint, fterr);
+			}
+			else
+			{
+				if (ft_face[i]->glyph->format != FT_GLYPH_FORMAT_OUTLINE)
+				{
+					printf("glyph->format = %4s\n", (char *)&ft_face[i]->glyph->format);
+				}
+				else
+				{
+					int gx = x + (glyph_pos[j].x_offset / 64);
+					int gy = y - (glyph_pos[j].y_offset / 64);
+
+					stuffbaton.pixels = (uint32_t *)(((uint8_t *)oDrawer.pixels) + gy * oDrawer.pitch) + gx;
+
+					if ((fterr = FT_Outline_Render(ft_library, &ft_face[i]->glyph->outline, &ftr_params)))
+						printf("FT_Outline_Render() failed err=%d\n", fterr);
+				}
+			}
+
+			x += glyph_pos[j].x_advance / 64;
+			y -= glyph_pos[j].y_advance / 64;
+		}
+
+		/* clean up the buffer, but don't kill it just yet */
+		hb_buffer_clear_contents(buf);
+	}
+
+	/* Cleanup */
+	hb_buffer_destroy(buf);
+	for (int i = 0; i < NUM_EXAMPLES; ++i)
+		hb_font_destroy(hb_ft_font[i]);
+
+	FT_Done_FreeType(ft_library);
+
+	oDrawer.Save();
+
+	return 0;
+}

Common/3dParty/harfbuzz/test/test.pro

@@ -0,0 +1,19 @@
+CONFIG -= qt
+TARGET = test
+TEMPLATE = app
+CONFIG += console
+CONFIG -= app_bundle
+
+CORE_ROOT_DIR = $$PWD/../../../../../core
+PWD_ROOT_DIR = $$PWD
+include($$CORE_ROOT_DIR/Common/base.pri)
+
+include($$CORE_ROOT_DIR/DesktopEditor/graphics/pro/freetype.pri)
+include($$CORE_ROOT_DIR/Common/3dParty/harfbuzz/harfbuzz.pri)
+
+SOURCES += main.cpp
+
+ADD_DEPENDENCY(UnicodeConverter, kernel, graphics)
+DESTDIR = $$PWD/build
+
+

Common/3dParty/heif/.gitignore

@@ -0,0 +1,4 @@
+x265_git
+libde265
+libheif
+ios-cmake

Common/3dParty/heif/heif.pri

@@ -0,0 +1,42 @@
+DEFINES += LIBHEIF_STATIC_BUILD
+
+HEIF_BUILDS_PLATFORM_PREFIX = $$CORE_BUILDS_PLATFORM_PREFIX
+core_ios : xcframework_platform_ios_simulator {
+	HEIF_BUILDS_PLATFORM_PREFIX = ios_simulator
+}
+
+HEIF_BUILD_PATH = $$PWD/libheif/build/$$HEIF_BUILDS_PLATFORM_PREFIX/$$CORE_BUILDS_CONFIGURATION_PREFIX
+
+INCLUDEPATH += \
+	$$PWD/libheif/libheif/api \
+	$$HEIF_BUILD_PATH				# for heif_version.h
+
+core_windows {
+	core_debug {
+		BUILD_TYPE = Debug
+	} else {
+		BUILD_TYPE = Release
+	}
+
+	LIBS += \
+		-L$$PWD/x265_git/build/$$HEIF_BUILDS_PLATFORM_PREFIX/$$CORE_BUILDS_CONFIGURATION_PREFIX/$$BUILD_TYPE -lx265-static \
+		-L$$PWD/libde265/build/$$HEIF_BUILDS_PLATFORM_PREFIX/$$CORE_BUILDS_CONFIGURATION_PREFIX/libde265/$$BUILD_TYPE -llibde265 \
+		-L$$HEIF_BUILD_PATH/libheif/$$BUILD_TYPE -lheif
+}
+
+core_linux | core_android {
+	# we need to wrap x265 and de265 libraries in `whole-archive` flags to avoid "undefined symbol" errors when later linking with graphics.so
+	LIBS += \
+		-Wl,--whole-archive \
+		-L$$PWD/x265_git/build/$$HEIF_BUILDS_PLATFORM_PREFIX/$$CORE_BUILDS_CONFIGURATION_PREFIX -lx265 \
+		-L$$PWD/libde265/build/$$HEIF_BUILDS_PLATFORM_PREFIX/$$CORE_BUILDS_CONFIGURATION_PREFIX/libde265 -lde265 \
+		-Wl,--no-whole-archive \
+		-L$$HEIF_BUILD_PATH/libheif -lheif
+}
+
+core_mac | core_ios {
+	LIBS += \
+		-L$$PWD/x265_git/build/$$HEIF_BUILDS_PLATFORM_PREFIX/$$CORE_BUILDS_CONFIGURATION_PREFIX -lx265 \
+		-L$$PWD/libde265/build/$$HEIF_BUILDS_PLATFORM_PREFIX/$$CORE_BUILDS_CONFIGURATION_PREFIX/libde265 -lde265 \
+		-L$$HEIF_BUILD_PATH/libheif -lheif
+}

Common/3dParty/html/css/CssCalculator.pri

@@ -3,6 +3,8 @@ DEPENDPATH += $$PWD
 
 CORE_ROOT_DIR = $$PWD/../../../..
 
+include($$CORE_ROOT_DIR/Common/3dParty/boost/boost.pri)
+
 css_calculator_without_xhtml {
 	HEADERS += \
 		$$PWD/src/CCssCalculator_Private.h \

Common/3dParty/html/css/src/CCompiledStyle.cpp

@@ -7,25 +7,26 @@
 #include <iterator>
 #include <map>
 
-#include <iostream>
 #include "../../../../../DesktopEditor/common/File.h"
 #include "StaticFunctions.h"
 #include "ConstValues.h"
 
-#define DEFAULT_FONT_SIZE 14
+#define DEFAULT_FONT_SIZE 12
 
 namespace NSCSS
 {
 	typedef std::map<std::wstring, std::wstring>::const_iterator styles_iterator;
 
-	CCompiledStyle::CCompiledStyle() : m_nDpi(96), m_UnitMeasure(Point), m_dCoreFontSize(DEFAULT_FONT_SIZE)
+	CCompiledStyle::CCompiledStyle()
+		: m_nDpi(96), m_UnitMeasure(Point), m_dCoreFontSize(DEFAULT_FONT_SIZE)
 	{}
 
 	CCompiledStyle::CCompiledStyle(const CCompiledStyle& oStyle) :
 		m_arParentsStyles(oStyle.m_arParentsStyles), m_sId(oStyle.m_sId),
 		m_nDpi(oStyle.m_nDpi), m_UnitMeasure(oStyle.m_UnitMeasure), m_dCoreFontSize(oStyle.m_dCoreFontSize),
 		m_oFont(oStyle.m_oFont), m_oMargin(oStyle.m_oMargin), m_oPadding(oStyle.m_oPadding), m_oBackground(oStyle.m_oBackground),
-		m_oText(oStyle.m_oText), m_oBorder(oStyle.m_oBorder), m_oDisplay(oStyle.m_oDisplay), m_oTransform(oStyle.m_oTransform){}
+		m_oText(oStyle.m_oText), m_oBorder(oStyle.m_oBorder), m_oDisplay(oStyle.m_oDisplay), m_oTransform(oStyle.m_oTransform)
+	{}
 
 	CCompiledStyle::~CCompiledStyle()
 	{
@@ -34,6 +35,8 @@ namespace NSCSS
 
 	CCompiledStyle& CCompiledStyle::operator+= (const CCompiledStyle &oElement)
 	{
+		m_arParentsStyles.insert(oElement.m_arParentsStyles.begin(), oElement.m_arParentsStyles.end());
+
 		if (oElement.Empty())
 			return *this;
 
@@ -69,6 +72,8 @@ namespace NSCSS
 		m_oDisplay      = oElement.m_oDisplay;
 		m_oTransform    = oElement.m_oTransform;
 
+		m_arParentsStyles = oElement.m_arParentsStyles;
+
 		return *this;
 	}
 
@@ -109,7 +114,8 @@ namespace NSCSS
 	bool CCompiledStyle::Empty() const
 	{
 		return m_oBackground.Empty() && m_oBorder.Empty() && m_oFont.Empty() &&
-		       m_oMargin.Empty() && m_oPadding.Empty() && m_oText.Empty() && m_oDisplay.Empty();
+		       m_oMargin.Empty() && m_oPadding.Empty() && m_oText.Empty() &&
+		       m_oDisplay.Empty() && m_oTransform.Empty();
 	}
 
 	void CCompiledStyle::AddPropSel(const std::wstring& sProperty, const std::wstring& sValue, const unsigned int unLevel, const bool& bHardMode)
@@ -314,6 +320,7 @@ namespace NSCSS
 				}
 				//BORDER TOP
 				CASE(L"border-top"):
+				CASE(L"mso-border-top-alt"):
 				{
 					m_oBorder.SetTopSide(pPropertie.second, unLevel, bHardMode);
 					break;
@@ -335,6 +342,7 @@ namespace NSCSS
 				}
 				//BORDER RIGHT
 				CASE(L"border-right"):
+				CASE(L"mso-border-right-alt"):
 				{
 					m_oBorder.SetRightSide(pPropertie.second, unLevel, bHardMode);
 					break;
@@ -356,6 +364,7 @@ namespace NSCSS
 				}
 				//BORDER bottom
 				CASE(L"border-bottom"):
+				CASE(L"mso-border-bottom-alt"):
 				{
 					m_oBorder.SetBottomSide(pPropertie.second, unLevel, bHardMode);
 					break;
@@ -377,6 +386,7 @@ namespace NSCSS
 				}
 				//BORDER LEFT
 				CASE(L"border-left"):
+				CASE(L"mso-border-left-alt"):
 				{
 					m_oBorder.SetLeftSide(pPropertie.second, unLevel, bHardMode);
 					break;
@@ -435,6 +445,11 @@ namespace NSCSS
 					m_oDisplay.SetVAlign(pPropertie.second, unLevel, bHardMode);
 					break;
 				}
+				CASE(L"white-space"):
+				{
+					m_oDisplay.SetWhiteSpace(pPropertie.second, unLevel, bHardMode);
+					break;
+				}
 				//TRANSFORM
 				CASE(L"transform"):
 				{
@@ -521,7 +536,7 @@ namespace NSCSS
 	{
 		return m_sId;
 	}
-	
+
 	bool CCompiledStyle::HaveThisParent(const std::wstring &wsParentName) const
 	{
 		return m_arParentsStyles.end() != m_arParentsStyles.find(wsParentName);

Common/3dParty/html/css/src/CCompiledStyle.h

@@ -1,9 +1,6 @@
 #ifndef CCOMPILEDSTYLE_H
 #define CCOMPILEDSTYLE_H
 
-#include "CssCalculator_global.h"
-#include "ConstValues.h"
-
 #include <map>
 #include <set>
 #include <vector>

Common/3dParty/html/css/src/CCssCalculator.cpp

@@ -13,14 +13,9 @@ namespace NSCSS
 		delete m_pInternal;
 	}
 
-	CCompiledStyle CCssCalculator::GetCompiledStyle(const std::vector<CNode> &arSelectors) const
+	bool CCssCalculator::CalculateCompiledStyle(std::vector<CNode>& arSelectors) const
 	{
-		return m_pInternal->GetCompiledStyle(arSelectors);
-	}
-
-	bool CCssCalculator::GetCompiledStyle(CCompiledStyle &oStyle, const std::vector<CNode> &arSelectors) const
-	{
-		return m_pInternal->GetCompiledStyle(oStyle, arSelectors);
+		return m_pInternal->CalculateCompiledStyle(arSelectors);
 	}
 
 	std::wstring CCssCalculator::CalculateStyleId(const CNode& oNode)
@@ -63,6 +58,11 @@ namespace NSCSS
 		return m_pInternal->GetDpi();
 	}
 
+	bool CCssCalculator::HaveStylesById(const std::wstring& wsId) const
+	{
+		return m_pInternal->HaveStylesById(wsId);
+	}
+
 	void CCssCalculator::ClearPageData()
 	{
 		m_pInternal->ClearPageData();

Common/3dParty/html/css/src/CCssCalculator.h

@@ -2,10 +2,8 @@
 #define CCSSCALCULATOR_H
 
 #include "CssCalculator_global.h"
-#include "CCompiledStyle.h"
-#include "ConstValues.h"
-#include <iostream>
-#include <map>
+#include "StyleProperties.h"
+#include "CNode.h"
 #include <vector>
 
 namespace NSCSS
@@ -19,8 +17,7 @@ namespace NSCSS
 		CCssCalculator();
 		~CCssCalculator();
 
-		CCompiledStyle GetCompiledStyle(const std::vector<CNode> &arSelectors) const;
-		bool GetCompiledStyle(CCompiledStyle& oStyle, const std::vector<CNode> &arSelectors) const;
+		bool CalculateCompiledStyle(std::vector<CNode>& arSelectors) const;
 
 		std::wstring CalculateStyleId(const CNode& oNode);
 		bool CalculatePageStyle(NSProperties::CPage& oPageData, const std::vector<CNode> &arSelectors);
@@ -35,6 +32,8 @@ namespace NSCSS
 		std::wstring GetEncoding()   const;
 		unsigned short int GetDpi()  const;
 
+		bool HaveStylesById(const std::wstring& wsId) const;
+
 		void ClearPageData();
 		void ClearEmbeddedStyles();
 		void ClearAllowedStyleFiles();

Common/3dParty/html/css/src/CCssCalculator_Private.cpp

@@ -2,8 +2,6 @@
 
 #include <string>
 #include <vector>
-#include <fstream>
-#include <cmath>
 #include <algorithm>
 #include <numeric>
 
@@ -17,29 +15,33 @@ inline static std::wstring StringifyValueList(const KatanaArray* oValues);
 inline static std::wstring StringifyValue(const KatanaValue* oValue);
 inline static bool         IsTableElement(const std::wstring& wsNameTag);
 
-bool operator<(const std::vector<NSCSS::CNode> &arLeftSelectors, const std::vector<NSCSS::CNode> &arRightSelectors)
-{
-	const size_t& sizeLeftSelectors = arLeftSelectors.size();
-	const size_t& sizeRightSelectors = arRightSelectors.size();
-
-	if (sizeLeftSelectors < sizeRightSelectors)
-		return true;
-	else if (sizeLeftSelectors > sizeRightSelectors)
-		return false;
-
-	for (size_t i = 0; i < arLeftSelectors.size(); ++i)
-	{
-		if (arLeftSelectors[i] < arRightSelectors[i])
-			return true;
-	}
-
-	return false;
-}
-
 namespace NSCSS
 {
+	bool operator<(const std::vector<NSCSS::CNode> &arLeftSelectors, const std::vector<NSCSS::CNode> &arRightSelectors)
+	{
+		if (arLeftSelectors.size() < arRightSelectors.size())
+			return true;
+		else if (arLeftSelectors.size() > arRightSelectors.size())
+			return false;
+
+		for (size_t i = 0; i < arLeftSelectors.size(); ++i)
+		{
+			if (arLeftSelectors[i] == arRightSelectors[i])
+				continue;
+
+			if (arLeftSelectors[i] < arRightSelectors[i])
+				return true;
+			else if (arRightSelectors[i] < arLeftSelectors[i])
+				return false;
+		}
+
+		return false;
+	}
+
 	CStyleStorage::CStyleStorage()
-	{}
+	{
+		InitDefaultStyles();
+	}
 
 	CStyleStorage::~CStyleStorage()
 	{
@@ -64,6 +66,7 @@ namespace NSCSS
 		m_arEmptyStyleFiles.clear();
 
 		ClearEmbeddedStyles();
+		ClearDefaultStyles();
 		ClearAllowedStyleFiles();
 
 		#ifdef CSS_CALCULATOR_WITH_XHTML
@@ -186,7 +189,7 @@ namespace NSCSS
 	}
 	#endif
 
-	const CElement* CStyleStorage::FindElement(const std::wstring& wsSelector)
+	const CElement* CStyleStorage::FindElement(const std::wstring& wsSelector) const
 	{
 		if (wsSelector.empty())
 			return nullptr;
@@ -210,6 +213,16 @@ namespace NSCSS
 		return nullptr;
 	}
 
+	const CElement* CStyleStorage::FindDefaultElement(const std::wstring& wsSelector) const
+	{
+		if (wsSelector.empty())
+			return nullptr;
+
+		const CElement* pFoundElement = FindSelectorFromStyleData(wsSelector, m_mDefaultStyleData);
+
+		return (nullptr != pFoundElement) ? pFoundElement : nullptr;
+	}
+
 	void CStyleStorage::AddStyles(const std::string& sStyle, std::map<std::wstring, CElement*>& mStyleData)
 	{
 		if (sStyle.empty())
@@ -229,6 +242,15 @@ namespace NSCSS
 		m_mEmbeddedStyleData.clear();
 	}
 
+	void CStyleStorage::ClearDefaultStyles()
+	{
+		for (std::map<std::wstring, CElement*>::iterator oIter = m_mDefaultStyleData.begin(); oIter != m_mDefaultStyleData.end(); ++oIter)
+			if (oIter->second != nullptr)
+				delete oIter->second;
+
+		m_mDefaultStyleData.clear();
+	}
+
 	void CStyleStorage::ClearAllowedStyleFiles()
 	{
 		m_arAllowedStyleFiles.clear();
@@ -472,7 +494,7 @@ namespace NSCSS
 		}
 	}
 
-	const CElement* CStyleStorage::FindSelectorFromStyleData(const std::wstring& wsSelector, const std::map<std::wstring, CElement*>& mStyleData)
+	const CElement* CStyleStorage::FindSelectorFromStyleData(const std::wstring& wsSelector, const std::map<std::wstring, CElement*>& mStyleData) const
 	{
 		std::map<std::wstring, CElement*>::const_iterator itFound = mStyleData.find(wsSelector);
 
@@ -482,15 +504,141 @@ namespace NSCSS
 		return nullptr;
 	}
 
-	CCssCalculator_Private::CCssCalculator_Private() : m_nDpi(96), m_nCountNodes(0), m_sEncoding(L"UTF-8"){}
+	void CStyleStorage::InitDefaultStyles()
+	{
+		m_mDefaultStyleData[L"b"] = new CElement(L"b", {{L"font-weight", L"bold"}});
+		m_mDefaultStyleData[L"center"] = new CElement(L"center", {{L"text-align", L"center"}});
+		m_mDefaultStyleData[L"i"] = new CElement(L"i", {{L"font-style", L"italic"}});
+		m_mDefaultStyleData[L"code"] = new CElement(L"code", {{L"font-family", L"Courier New"}});
+		m_mDefaultStyleData[L"kbd"] = new CElement(L"kbd", {{L"font-family", L"Courier New"},
+		                                                    {L"font_weight", L"bold"}});
+		m_mDefaultStyleData[L"s"] = new CElement(L"s", {{L"text-decoration", L"line-through"}});
+		m_mDefaultStyleData[L"u"] = new CElement(L"u", {{L"text-decoration", L"underline"}});
+		m_mDefaultStyleData[L"mark"] = new CElement(L"mark", {{L"background-color", L"yellow"}});
+		m_mDefaultStyleData[L"sup"] = new CElement(L"sup", {{L"vertical-align", L"top"}});
+		m_mDefaultStyleData[L"sub"] = new CElement(L"sub", {{L"vertical-align", L"bottom"}});
+		m_mDefaultStyleData[L"dd"] = new CElement(L"dd", {{L"margin-left", L"720tw"}});
+		m_mDefaultStyleData[L"pre"] = new CElement(L"pre", {{L"font-family", L"Courier New"},
+		                                                    {L"margin-top", L"0"},
+		                                                    {L"margin-bottom", L"0"}});
+		m_mDefaultStyleData[L"blockquote"] = new CElement(L"blockquote", {{L"margin", L"0px"}});
+		m_mDefaultStyleData[L"ul"] = new CElement(L"ul", {{L"margin-top", L"100tw"},
+		                                                  {L"margin-bottom", L"100tw"}});
+		m_mDefaultStyleData[L"textarea"] = new CElement(L"textarea", {{L"border", L"1px solid black"}});
+		m_mDefaultStyleData[L"th"] = new CElement(L"b", {{L"font-weight", L"bold"}});
+	}
+
+	CCssCalculator_Private::CCssCalculator_Private()
+		: m_nDpi(96), m_nCountNodes(0), m_sEncoding(L"UTF-8")
+	{
+	}
 
 	CCssCalculator_Private::~CCssCalculator_Private()
 	{}
 
 	#ifdef CSS_CALCULATOR_WITH_XHTML
+	bool CCssCalculator_Private::CalculateCompiledStyle(std::vector<CNode>& arSelectors)
+	{
+		if (arSelectors.empty())
+			return false;
+
+		if (L"#text" == arSelectors.back().m_wsName)
+		{
+			if (arSelectors.size() > 1 && arSelectors.back().m_pCompiledStyle->Empty())
+				*arSelectors.back().m_pCompiledStyle += *(arSelectors.end() - 2)->m_pCompiledStyle;
+
+			if(arSelectors.crend() != std::find_if(arSelectors.crbegin(), arSelectors.crend(),
+			                                       [](const CNode& oNode){ return IsTableElement(oNode.m_wsName); }))
+			{
+				arSelectors.back().m_pCompiledStyle->m_oBackground.Clear();
+				arSelectors.back().m_pCompiledStyle->m_oBorder.Clear();
+			}
+
+			if (arSelectors.size() > 1)
+				arSelectors.back().m_pCompiledStyle->AddParent(arSelectors[arSelectors.size() - 2].m_wsName);
+
+			arSelectors.back().m_pCompiledStyle->SetID(L"text-" + std::to_wstring(++m_nCountNodes));
+
+			return true;
+		}
+
+		const std::map<std::vector<CNode>, CCompiledStyle>::const_iterator oItem = m_mUsedStyles.find(arSelectors);
+
+		if (oItem != m_mUsedStyles.cend() && (arSelectors.back().m_wsId.empty() || !HaveStylesById(arSelectors.back().m_wsId)))
+		{
+			arSelectors.back().SetCompiledStyle(new CCompiledStyle(oItem->second));
+			return true;
+		}
+
+		if (!arSelectors.back().m_pCompiledStyle->Empty())
+			return true;
+
+		arSelectors.back().m_pCompiledStyle->SetDpi(m_nDpi);
+		unsigned int unStart = 0;
+
+		std::vector<CNode>::const_reverse_iterator itFound = std::find_if(arSelectors.crbegin(), arSelectors.crend(), [](const CNode& oNode){ return !oNode.m_pCompiledStyle->Empty(); });
+
+		if (itFound != arSelectors.crend())
+			unStart = itFound.base() - arSelectors.cbegin();
+
+		std::vector<std::wstring> arNodes = CalculateAllNodes(arSelectors, unStart, arSelectors.size());
+		std::vector<std::wstring> arPrevNodes = CalculateAllNodes(arSelectors, 0, unStart);
+		bool bInTable = false;
+
+		for (size_t i = 0; i < unStart; ++i)
+		{
+			if (!bInTable)
+				bInTable = IsTableElement(arSelectors[i].m_wsName);
+			else
+				break;
+		}
+
+		for (size_t i = unStart; i < arSelectors.size(); ++i)
+		{
+			if (0 != i)
+				*arSelectors[i].m_pCompiledStyle += *arSelectors[i - 1].m_pCompiledStyle;
+
+			if (i != arSelectors.size() - 1)
+				arSelectors[i].m_pCompiledStyle->AddParent(arSelectors[i].m_wsName);
+
+			if (!bInTable)
+				bInTable = IsTableElement(arSelectors[i].m_wsName);
+
+			if (bInTable)
+			{
+				arSelectors[i].m_pCompiledStyle->m_oBackground.Clear();
+				arSelectors[i].m_pCompiledStyle->m_oBorder.Clear();
+				arSelectors[i].m_pCompiledStyle->m_oDisplay.Clear();
+			}
+
+			arSelectors[i].m_pCompiledStyle->AddStyle(arSelectors[i].m_mAttributes, i + 1);
+
+			for (const CElement* oElement : FindElements(arNodes, arPrevNodes))
+				arSelectors[i].m_pCompiledStyle->AddStyle(oElement->GetStyle(), i + 1);
+
+			if (!arSelectors[i].m_wsStyle.empty())
+				arSelectors[i].m_pCompiledStyle->AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
+
+			// Reset some external styles that are overridden inside the table
+			if (bInTable && i < arSelectors.size() - 1)
+			{
+				arSelectors[i].m_pCompiledStyle->m_oFont.GetLineHeight().Clear();
+				arSelectors[i].m_pCompiledStyle->m_oPadding.Clear();
+				arSelectors[i].m_pCompiledStyle->m_oMargin.Clear();
+			}
+		}
+
+		arSelectors.back().m_pCompiledStyle->SetID(CalculateStyleId(arSelectors.back()));
+
+		if (!arSelectors.back().m_pCompiledStyle->Empty())
+			m_mUsedStyles[arSelectors] = *arSelectors.back().m_pCompiledStyle;
+
+		return true;
+	}
+
 	void CCssCalculator_Private::SetPageData(NSProperties::CPage &oPage, const std::map<std::wstring, std::wstring> &mData, unsigned int unLevel, bool bHardMode)
 	{
-		//TODO:: пересмотреть данный метод
+		//TODO:: review this method
 		m_oStyleStorage.SetPageData(oPage, mData, unLevel, bHardMode);
 	}
 
@@ -505,11 +653,14 @@ namespace NSCSS
 	}
 	#endif
 
-	std::vector<std::wstring> CCssCalculator_Private::CalculateAllNodes(const std::vector<CNode> &arSelectors)
+	std::vector<std::wstring> CCssCalculator_Private::CalculateAllNodes(const std::vector<CNode> &arSelectors, unsigned int unStart, unsigned int unEnd)
 	{
+		if ((0 != unEnd && (unEnd < unStart || unEnd > arSelectors.size())) || (unStart == unEnd))
+			return std::vector<std::wstring>();
+
 		std::vector<std::wstring> arNodes;
-		
-		for (std::vector<CNode>::const_reverse_iterator oNode = arSelectors.rbegin(); oNode != arSelectors.rend(); ++oNode)
+
+		for (std::vector<CNode>::const_reverse_iterator oNode = arSelectors.rbegin() + ((0 != unEnd) ? (arSelectors.size() - unEnd) : 0); oNode != arSelectors.rend() - unStart; ++oNode)
 		{
 			if (!oNode->m_wsName.empty())
 				arNodes.push_back(oNode->m_wsName);
@@ -521,8 +672,8 @@ namespace NSCSS
 					std::vector<std::wstring> arClasses = NS_STATIC_FUNCTIONS::GetWordsW(oNode->m_wsClass, false, L" ");
 
 					arNodes.push_back(std::accumulate(arClasses.begin(), arClasses.end(), std::wstring(),
-													  [](std::wstring sRes, const std::wstring& sClass)
-														{return sRes += L'.' + sClass + L' ';}));
+					                                  [](std::wstring sRes, const std::wstring& sClass)
+					                                  {return sRes += L'.' + sClass + L' ';}));
 				}
 				else
 					arNodes.push_back(L'.' + oNode->m_wsClass);
@@ -540,7 +691,7 @@ namespace NSCSS
 		if (arNextNodes.empty())
 			return;
 
-		const std::vector<CElement*> arTempPrev = pElement->GetPrevElements(arNextNodes.crbegin() + 1, arNextNodes.crend());
+		const std::vector<CElement*> arTempPrev = pElement->GetPrevElements(arNextNodes.cbegin(), arNextNodes.cend());
 		const std::vector<CElement*> arTempKins = pElement->GetNextOfKin(wsName, arClasses);
 
 		if (!arTempPrev.empty())
@@ -550,6 +701,36 @@ namespace NSCSS
 			arFindedElements.insert(arFindedElements.end(), arTempKins.begin(), arTempKins.end());
 	}
 
+	inline std::wstring GetAlternativeDefaultNodeName(const std::wstring& wsNodeName)
+	{
+		if (L"strong" == wsNodeName)
+			return L"b";
+
+		if (L"cite" == wsNodeName || L"dfn" == wsNodeName || L"em" == wsNodeName ||
+		    L"var" == wsNodeName || L"adress" == wsNodeName)
+			return L"i";
+
+		if (L"tt" == wsNodeName || L"samp" == wsNodeName)
+			return L"code";
+
+		if (L"strike" == wsNodeName || L"del" == wsNodeName)
+			return L"s";
+
+		if (L"ins" == wsNodeName)
+			return L"u";
+
+		if (L"xmp" == wsNodeName || L"nobr" == wsNodeName)
+			return L"pre";
+
+		if (L"ol" == wsNodeName)
+			return L"ul";
+
+		if (L"fieldset" == wsNodeName)
+			return L"textarea";
+
+		return wsNodeName;
+	}
+
 	std::vector<const CElement*> CCssCalculator_Private::FindElements(std::vector<std::wstring> &arNodes, std::vector<std::wstring> &arNextNodes)
 	{
 		if (arNodes.empty())
@@ -557,20 +738,19 @@ namespace NSCSS
 
 		std::vector<const CElement*> arFindedElements;
 
-		std::wstring wsName, wsId;
+		std::wstring wsName, wsClasses, wsId;
 		std::vector<std::wstring> arClasses;
 
 		if (!arNodes.empty() && arNodes.back()[0] == L'#')
 		{
 			wsId = arNodes.back();
 			arNodes.pop_back();
-			arNextNodes.push_back(wsId);
 		}
 
 		if (!arNodes.empty() && arNodes.back()[0] == L'.')
 		{
-			arClasses = NS_STATIC_FUNCTIONS::GetWordsW(arNodes.back(), false, L" ");
-			arNextNodes.push_back(arNodes.back());
+			wsClasses = arNodes.back();
+			arClasses = NS_STATIC_FUNCTIONS::GetWordsW(wsClasses, false, L" ");
 			arNodes.pop_back();
 		}
 
@@ -578,7 +758,6 @@ namespace NSCSS
 		{
 			wsName = arNodes.back();
 			arNodes.pop_back();
-			arNextNodes.push_back(wsName);
 		}
 
 		if (!wsId.empty())
@@ -610,6 +789,11 @@ namespace NSCSS
 			}
 		}
 
+		const CElement* pFoundDefault = m_oStyleStorage.FindDefaultElement(GetAlternativeDefaultNodeName(wsName));
+
+		if (nullptr != pFoundDefault)
+			arFindedElements.push_back(pFoundDefault);
+
 		const CElement* pFoundName = m_oStyleStorage.FindElement(wsName);
 
 		if (nullptr != pFoundName)
@@ -620,6 +804,16 @@ namespace NSCSS
 			FindPrevAndKindElements(pFoundName, arNextNodes, arFindedElements, wsName, arClasses);
 		}
 
+		const CElement* pFoundAll = m_oStyleStorage.FindElement(L"*");
+
+		if (nullptr != pFoundAll)
+		{
+			if (!pFoundAll->Empty())
+				arFindedElements.push_back(pFoundAll);
+
+			FindPrevAndKindElements(pFoundAll, arNextNodes, arFindedElements, wsName, arClasses);
+		}
+
 		if (arFindedElements.size() > 1)
 		{
 			std::sort(arFindedElements.rbegin(), arFindedElements.rend(),
@@ -627,83 +821,18 @@ namespace NSCSS
 			          { return oFirstElement->GetWeight() > oSecondElement->GetWeight(); });
 		}
 
+		if (!wsId.empty())
+			arNextNodes.push_back(wsId);
+
+		if (!wsClasses.empty())
+			arNextNodes.push_back(wsClasses);
+
+		arNextNodes.push_back(wsName);
+
 		return arFindedElements;
 	}
 
 	#ifdef CSS_CALCULATOR_WITH_XHTML
-	CCompiledStyle CCssCalculator_Private::GetCompiledStyle(const std::vector<CNode>& arSelectors)
-	{
-		if (arSelectors.empty())
-			return CCompiledStyle();
-
-		CCompiledStyle oStyle;
-
-		GetCompiledStyle(oStyle, arSelectors);
-
-		return oStyle;
-	}
-
-	bool CCssCalculator_Private::GetCompiledStyle(CCompiledStyle &oStyle, const std::vector<CNode> &arSelectors)
-	{
-		if (arSelectors.empty())
-			return false;
-
-		const std::map<std::vector<CNode>, CCompiledStyle>::iterator oItem = m_mUsedStyles.find(arSelectors);
-
-		if (oItem != m_mUsedStyles.end())
-		{
-			oStyle = oItem->second;
-			return true;
-		}
-
-		oStyle.SetDpi(m_nDpi);
-
-		std::vector<std::wstring> arNodes = CalculateAllNodes(arSelectors);
-		std::vector<std::wstring> arPrevNodes;
-		bool bInTable = false;
-		
-		for (size_t i = 0; i < arSelectors.size(); ++i)
-		{
-			oStyle.AddParent(arSelectors[i].m_wsName);
-
-			if (!bInTable)
-				bInTable = IsTableElement(arSelectors[i].m_wsName);
-
-			if (bInTable)
-			{
-				oStyle.m_oBackground.Clear();
-				oStyle.m_oBorder.Clear();
-			}
-
-			CCompiledStyle oTempStyle;
-
-			oTempStyle.AddStyle(arSelectors[i].m_mAttributes, i + 1);
-
-			for (const CElement* oElement : FindElements(arNodes, arPrevNodes))
-				oTempStyle.AddStyle(oElement->GetStyle(), i + 1);
-
-			if (!arSelectors[i].m_wsStyle.empty())
-				oTempStyle.AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
-
-			oStyle += oTempStyle;
-
-			// Скидываем некоторые внешние стили, которые внутри таблицы переопределяются
-			if (bInTable && i < arSelectors.size() - 1)
-			{
-				oStyle.m_oFont.GetLineHeight().Clear();
-				oStyle.m_oPadding.Clear();
-				oStyle.m_oMargin.Clear();
-			}
-		}
-
-		oStyle.SetID(CalculateStyleId(arSelectors.back()));
-
-		if (!oStyle.Empty())
-			m_mUsedStyles[arSelectors] = oStyle;
-
-		return true;
-	}
-
 	std::wstring CCssCalculator_Private::CalculateStyleId(const CNode& oNode)
 	{
 		return oNode.m_wsName + ((!oNode.m_wsClass.empty()) ? L'.' + oNode.m_wsClass : L"") + ((oNode.m_wsId.empty()) ? L"" : L'#' + oNode.m_wsId) + L'-' + std::to_wstring(++m_nCountNodes);
@@ -714,7 +843,7 @@ namespace NSCSS
 		if (arSelectors.empty())
 			return false;
 
-		std::vector<std::wstring> arNodes = CalculateAllNodes(arSelectors);
+		std::vector<std::wstring> arNodes = CalculateAllNodes(arSelectors, 0, arSelectors.size());
 		std::vector<std::wstring> arNextNodes;
 
 		for (size_t i = 0; i < arSelectors.size(); ++i)
@@ -766,6 +895,11 @@ namespace NSCSS
 		return m_nDpi;
 	}
 
+	bool CCssCalculator_Private::HaveStylesById(const std::wstring& wsId) const
+	{
+		return nullptr != m_oStyleStorage.FindElement(L'#' + wsId);
+	}
+
 	void CCssCalculator_Private::ClearEmbeddedStyles()
 	{
 		m_oStyleStorage.ClearEmbeddedStyles();
@@ -910,4 +1044,11 @@ inline static std::wstring StringifyValue(const KatanaValue* oValue)
 	return str;
 }
 
+inline static bool IsTableElement(const std::wstring& wsNameTag)
+{
+	return  L"td" == wsNameTag || L"tr" == wsNameTag || L"table" == wsNameTag ||
+	        L"tbody" == wsNameTag || L"thead" == wsNameTag || L"tfoot" == wsNameTag ||
+	        L"th" == wsNameTag;
+}
+
 

Common/3dParty/html/css/src/CCssCalculator_Private.h

@@ -27,6 +27,7 @@ namespace NSCSS
 		void AddStylesFromFile(const std::wstring& wsFileName);
 
 		void ClearEmbeddedStyles();
+		void ClearDefaultStyles();
 		void ClearAllowedStyleFiles();
 		void ClearStylesFromFile(const std::wstring& wsFileName);
 
@@ -37,7 +38,8 @@ namespace NSCSS
 		void ClearPageData();
 		#endif
 
-		const CElement* FindElement(const std::wstring& wsSelector);
+		const CElement* FindElement(const std::wstring& wsSelector) const;
+		const CElement* FindDefaultElement(const std::wstring& wsSelector) const;
 	private:
 		typedef struct
 		{
@@ -49,6 +51,7 @@ namespace NSCSS
 		std::set<std::wstring> m_arAllowedStyleFiles;
 		std::vector<TStyleFileData*> m_arStyleFiles;
 		std::map<std::wstring, CElement*> m_mEmbeddedStyleData;
+		std::map<std::wstring, CElement*> m_mDefaultStyleData;
 
 		#ifdef CSS_CALCULATOR_WITH_XHTML
 		typedef struct
@@ -77,7 +80,9 @@ namespace NSCSS
 
 		void GetOutputData(KatanaOutput* oOutput, std::map<std::wstring, CElement*>& mStyleData);
 
-		const CElement* FindSelectorFromStyleData(const std::wstring& wsSelector, const std::map<std::wstring, CElement*>& mStyleData);
+		const CElement* FindSelectorFromStyleData(const std::wstring& wsSelector, const std::map<std::wstring, CElement*>& mStyleData) const;
+
+		void InitDefaultStyles();
 	};
 
 	class CCssCalculator_Private
@@ -102,8 +107,7 @@ namespace NSCSS
 		~CCssCalculator_Private();
 
 		#ifdef CSS_CALCULATOR_WITH_XHTML
-		CCompiledStyle GetCompiledStyle(const std::vector<CNode> &arSelectors);
-		bool GetCompiledStyle(CCompiledStyle& oStyle, const std::vector<CNode> &arSelectors);
+		bool CalculateCompiledStyle(std::vector<CNode>& arSelectors);
 
 		std::wstring CalculateStyleId(const CNode& oNode);
 		bool CalculatePageStyle(NSProperties::CPage& oPageData, const std::vector<CNode> &arSelectors);
@@ -111,7 +115,7 @@ namespace NSCSS
 		void ClearPageData();
 		#endif
 
-		std::vector<std::wstring> CalculateAllNodes(const std::vector<CNode>& arSelectors);
+		std::vector<std::wstring> CalculateAllNodes(const std::vector<CNode>& arSelectors, unsigned int unStart, unsigned int unEnd);
 		std::vector<const CElement*> FindElements(std::vector<std::wstring>& arNodes, std::vector<std::wstring>& arNextNodes);
 
 		void AddStyles(const std::string& sStyle);
@@ -123,6 +127,8 @@ namespace NSCSS
 		std::wstring GetEncoding() const;
 		unsigned short int GetDpi() const;
 
+		bool HaveStylesById(const std::wstring& wsId) const;
+
 		void ClearEmbeddedStyles();
 		void ClearAllowedStyleFiles();
 		void ClearStylesFromFile(const std::wstring& wsFilePath);

Common/3dParty/html/css/src/CElement.cpp

@@ -9,6 +9,13 @@ namespace NSCSS
 	CElement::CElement()
 	{
 	}
+
+	CElement::CElement(const std::wstring& wsSelector, std::map<std::wstring, std::wstring> mStyle)
+		: m_mStyle(mStyle), m_sSelector(wsSelector), m_sFullSelector(wsSelector)
+	{
+		UpdateWeight();
+	}
+
 	CElement::~CElement()
 	{
 		for (CElement* oElement : m_arPrevElements)
@@ -18,7 +25,6 @@ namespace NSCSS
 				continue;
 
 		m_mStyle.clear();
-
 	}
 
 	std::wstring CElement::GetSelector() const
@@ -176,14 +182,14 @@ namespace NSCSS
 		return arElements;
 	}
 
-	std::vector<CElement *> CElement::GetPrevElements(const std::vector<std::wstring>::const_reverse_iterator& oNodesRBegin, const std::vector<std::wstring>::const_reverse_iterator& oNodesREnd) const
+	std::vector<CElement *> CElement::GetPrevElements(const std::vector<std::wstring>::const_iterator& oNodesBegin, const std::vector<std::wstring>::const_iterator& oNodesEnd) const
 	{
-		if (oNodesRBegin >= oNodesREnd || m_arPrevElements.empty())
+		if (oNodesBegin >= oNodesEnd || m_arPrevElements.empty())
 			return std::vector<CElement*>();
 
 		std::vector<CElement*> arElements;
 
-		for (std::vector<std::wstring>::const_reverse_iterator iWord = oNodesRBegin; iWord != oNodesREnd; ++iWord)
+		for (std::vector<std::wstring>::const_iterator iWord = oNodesBegin; iWord != oNodesEnd; ++iWord)
 		{
 			if ((*iWord)[0] == L'.' && ((*iWord).find(L" ") != std::wstring::npos))
 			{
@@ -195,7 +201,7 @@ namespace NSCSS
 						if (oPrevElement->m_sSelector == wsClass)
 						{
 							arElements.push_back(oPrevElement);
-							std::vector<CElement*> arTempElements = oPrevElement->GetPrevElements(iWord + 1, oNodesREnd);
+							std::vector<CElement*> arTempElements = oPrevElement->GetPrevElements(iWord + 1, oNodesEnd);
 							arElements.insert(arElements.end(), arTempElements.begin(), arTempElements.end());
 						}
 					}
@@ -208,9 +214,8 @@ namespace NSCSS
 					if (oPrevElement->m_sSelector == *iWord)
 					{
 						arElements.push_back(oPrevElement);
-						std::vector<CElement*> arTempElements = oPrevElement->GetPrevElements(iWord + 1, oNodesREnd);
+						std::vector<CElement*> arTempElements = oPrevElement->GetPrevElements(iWord + 1, oNodesEnd);
 						arElements.insert(arElements.end(), arTempElements.begin(), arTempElements.end());
-	//                    return arElements;
 					}
 				}
 			}

Common/3dParty/html/css/src/CElement.h

@@ -22,6 +22,7 @@ namespace NSCSS
 
 	public:
 		CElement();
+		CElement(const std::wstring& wsSelector, std::map<std::wstring, std::wstring> mStyle);
 		~CElement();
 
 		std::wstring GetSelector() const;
@@ -39,7 +40,7 @@ namespace NSCSS
 		std::map<std::wstring, std::wstring> GetFullStyle(const std::vector<CNode>& arSelectors) const;
 		std::map<std::wstring, std::wstring> GetFullStyle(const std::vector<std::wstring>& arNodes) const;
 		std::vector<CElement *> GetNextOfKin(const std::wstring& sName, const std::vector<std::wstring>& arClasses = {}) const;
-		std::vector<CElement *> GetPrevElements(const std::vector<std::wstring>::const_reverse_iterator& oNodesRBegin, const std::vector<std::wstring>::const_reverse_iterator& oNodesREnd) const;
+		std::vector<CElement *> GetPrevElements(const std::vector<std::wstring>::const_iterator& oNodesBegin, const std::vector<std::wstring>::const_iterator& oNodesEnd) const;
 		std::map<std::wstring, std::wstring> GetConvertStyle(const std::vector<CNode>& arNodes) const;
 
 		CElement *FindPrevElement(const std::wstring& sSelector) const;

Common/3dParty/html/css/src/CNode.cpp

@@ -1,19 +1,74 @@
 #include "CNode.h"
 
+#ifdef CSS_CALCULATOR_WITH_XHTML
+#include "CCompiledStyle.h"
+#endif
+
 namespace NSCSS
 {
 	CNode::CNode()
+	#ifdef CSS_CALCULATOR_WITH_XHTML
+		: m_pCompiledStyle(new CCompiledStyle())
+    #endif
 	{}
 
+	CNode::CNode(const CNode& oNode)
+		: m_wsName(oNode.m_wsName), m_wsClass(oNode.m_wsClass), m_wsId(oNode.m_wsId),
+	      m_wsStyle(oNode.m_wsStyle), m_mAttributes(oNode.m_mAttributes)
+	{
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		m_pCompiledStyle = new CCompiledStyle(*oNode.m_pCompiledStyle);
+		#endif
+	}
+
 	CNode::CNode(const std::wstring& wsName, const std::wstring& wsClass, const std::wstring& wsId)
 		: m_wsName(wsName), m_wsClass(wsClass), m_wsId(wsId)
+	    #ifdef CSS_CALCULATOR_WITH_XHTML
+	    , m_pCompiledStyle(new CCompiledStyle())
+		#endif
 	{}
 
+	CNode::~CNode()
+	{
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		if (nullptr != m_pCompiledStyle)
+			delete m_pCompiledStyle;
+		#endif
+	}
+
 	bool CNode::Empty() const
 	{
 		return m_wsName.empty() && m_wsClass.empty() && m_wsId.empty() && m_wsStyle.empty();
 	}
 
+	bool CNode::GetAttributeValue(const std::wstring& wsAttributeName, std::wstring& wsAttributeValue) const
+	{
+		const std::map<std::wstring, std::wstring>::const_iterator itFound{m_mAttributes.find(wsAttributeName)};
+
+		if (m_mAttributes.cend() == itFound)
+			return false;
+
+		wsAttributeValue = itFound->second;
+		return true;
+	}
+
+	std::wstring CNode::GetAttributeValue(const std::wstring& wsAttributeName) const
+	{
+		const std::map<std::wstring, std::wstring>::const_iterator itFound{m_mAttributes.find(wsAttributeName)};
+		return (m_mAttributes.cend() != itFound) ? itFound->second : std::wstring();
+	}
+
+	#ifdef CSS_CALCULATOR_WITH_XHTML
+	void CNode::SetCompiledStyle(CCompiledStyle* pCompiledStyle)
+	{
+		if (nullptr != m_pCompiledStyle)
+			delete m_pCompiledStyle;
+
+		m_pCompiledStyle = new CCompiledStyle();
+		*m_pCompiledStyle = *pCompiledStyle;
+	}
+	#endif
+
 	void CNode::Clear()
 	{
 		m_wsName     .clear();
@@ -47,6 +102,9 @@ namespace NSCSS
 		if(m_wsStyle != oNode.m_wsStyle)
 			return m_wsStyle < oNode.m_wsStyle;
 
+		if (m_mAttributes.size() != oNode.m_mAttributes.size())
+			return m_mAttributes.size() < oNode.m_mAttributes.size();
+
 		if (m_mAttributes != oNode.m_mAttributes)
 			return m_mAttributes < oNode.m_mAttributes;
 
@@ -55,10 +113,9 @@ namespace NSCSS
 
 	bool CNode::operator==(const CNode& oNode) const
 	{
-		return((m_wsId == oNode.m_wsId)       &&
-			   (m_wsName == oNode.m_wsName)   &&
-			   (m_wsClass == oNode.m_wsClass) &&
-			  (m_wsStyle == oNode.m_wsStyle) &&
-			  (m_mAttributes == oNode.m_mAttributes));
+		return((m_wsName == oNode.m_wsName)   &&
+		       (m_wsClass == oNode.m_wsClass) &&
+		       (m_wsStyle == oNode.m_wsStyle) &&
+		       (m_mAttributes == oNode.m_mAttributes));
 	}
 }

Common/3dParty/html/css/src/CNode.h

@@ -7,21 +7,37 @@
 
 namespace NSCSS
 {
+	#ifdef CSS_CALCULATOR_WITH_XHTML
+	class CCompiledStyle;
+	#endif
 	class CNode
 	{
 	public:
-		std::wstring m_wsName;  // Имя тэга
-		std::wstring m_wsClass; // Класс тэга
-		std::wstring m_wsId;    // Id тэга
-		std::wstring m_wsStyle; // Стиль тэга
-		std::map<std::wstring, std::wstring> m_mAttributes; // Остальные аттрибуты тэга
+		std::wstring m_wsName;  // Tag name
+		std::wstring m_wsClass; // Tag class
+		std::wstring m_wsId;    // Tag id
+		std::wstring m_wsStyle; // Tag style
+		std::map<std::wstring, std::wstring> m_mAttributes; // Other tag attributes
+		//TODO:: perhaps using std::wstring is excessive
 
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		CCompiledStyle *m_pCompiledStyle;
+		#endif
 	public:
 		CNode();
+		CNode(const CNode& oNode);
 		CNode(const std::wstring& wsName, const std::wstring& wsClass, const std::wstring& wsId);
+		~CNode();
 
 		bool Empty() const;
 
+		bool GetAttributeValue(const std::wstring& wsAttributeName, std::wstring& wsAttributeValue) const;
+		std::wstring GetAttributeValue(const std::wstring& wsAttributeName) const;
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		void SetCompiledStyle(CCompiledStyle* pCompiledStyle);
+		#endif
+
 		void Clear();
 
 		std::vector<std::wstring> GetData() const;

Common/3dParty/html/css/src/CUnitMeasureConverter.cpp

@@ -23,7 +23,7 @@ namespace NSCSS
 			case NSCSS::Inch:
 				return dValue / (double)ushDPI;
 			case NSCSS::Peak:
-				return dValue * 6. / (double)ushDPI; // 1 дюйм = 6 пик
+				return dValue * 6. / (double)ushDPI; // 1 inch = 6 peak
 			case NSCSS::Twips:
 				return dValue * 1440. / (double)ushDPI;
 			default:
@@ -36,17 +36,17 @@ namespace NSCSS
 		switch (enUnitMeasure)
 		{
 			case NSCSS::Point:
-				return dValue * 28.3465 ; // 1 см = (2.54 / 72) пункта
+				return dValue * 28.3465 ; // 1 cm = (2.54 / 72) points
 			case NSCSS::Pixel:
 				return dValue * (double)ushDPI / 2.54;
 			case NSCSS::Millimeter:
 				return dValue * 10.;
 			case NSCSS::Inch:
-				return dValue / 2.54; // 1 дюйм = 2.54 см
+				return dValue / 2.54; // 1 inch = 2.54 cm
 			case NSCSS::Peak:
 				return dValue * 2.36; // 2.36 = 6 / 2.54
 			case NSCSS::Twips:
-				return dValue * 567.; // 1 см = (1440 / 2.54) твипов
+				return dValue * 567.; // 1 cm = (1440 / 2.54) twips
 			default:
 				return dValue;
 		}
@@ -57,7 +57,7 @@ namespace NSCSS
 		switch (enUnitMeasure)
 		{
 			case NSCSS::Point:
-				return dValue * 2.8346; // 1 мм = (25.4 / 72) пункта
+				return dValue * 2.8346; // 1 mm = (25.4 / 72) points
 			case NSCSS::Pixel:
 				return dValue * (double)ushDPI / 25.4;
 			case NSCSS::Cantimeter:
@@ -82,7 +82,7 @@ namespace NSCSS
 			case NSCSS::Pixel:
 				return dValue * (double)ushDPI;
 			case NSCSS::Cantimeter:
-				return dValue * 2.54; // 1 дюйм = 2.54 см
+				return dValue * 2.54; // 1 inch = 2.54 cm
 			case NSCSS::Millimeter:
 				return dValue * 25.4;
 			case NSCSS::Peak:
@@ -105,9 +105,9 @@ namespace NSCSS
 			case NSCSS::Millimeter:
 				return dValue * 0.3528;
 			case NSCSS::Inch:
-				return dValue / 72.; // 1 дюйм = 72 пункта
+				return dValue / 72.; // 1 inch = 72 points
 			case NSCSS::Peak:
-				return dValue * 0.0833; // 0.0833 = 6 / 72 (1 пункт = 1/72 дюйма)
+				return dValue * 0.0833; // 0.0833 = 6 / 72 (1 point = 1/72 inch)
 			case NSCSS::Twips:
 				return dValue * 20.; // 20 = 1440 / 72
 			default:
@@ -122,7 +122,7 @@ namespace NSCSS
 			case NSCSS::Point:
 				return dValue * 12.; // 12 = 72 / 6
 			case NSCSS::Pixel:
-				return dValue * (double)ushDPI / 6.; // 1 дюйм = 6 пика
+				return dValue * (double)ushDPI / 6.; // 1 inch = 6 peak
 			case NSCSS::Cantimeter:
 				return dValue * 0.423; // 0.423 = 2.54 / 6
 			case NSCSS::Millimeter:
@@ -143,13 +143,13 @@ namespace NSCSS
 			case NSCSS::Point:
 				return dValue * 0.05; // 0.05 = 72. / 1440.
 			case NSCSS::Pixel:
-				return dValue * (double)ushDPI / 1440.; // 1 дюйм = 1440 твипов
+				return dValue * (double)ushDPI / 1440.; // 1 inch = 1440 twips
 			case NSCSS::Cantimeter:
 				return dValue * 0.001764; // 0.001764 = 2.54 / 1440
 			case NSCSS::Millimeter:
 				return dValue * 0.01764;
 			case NSCSS::Inch:
-				return dValue * 1440.;
+				return dValue / 1440.;
 			case NSCSS::Peak:
 				return dValue * 0.004167; // 0.004167 = 6 / 1440
 			default:

Common/3dParty/html/css/src/ConstValues.h

@@ -69,7 +69,10 @@ namespace NSCSS
 				R_Highlight,
 				R_Shd,
 				R_SmallCaps,
-				R_Kern
+				R_Kern,
+				R_Vanish,
+				R_Strike,
+				R_VertAlign
 			} RunnerProperties;
 
 			typedef enum

Common/3dParty/html/css/src/StaticFunctions.cpp

@@ -16,14 +16,14 @@ namespace NS_STATIC_FUNCTIONS
 	std::string GetContentAsUTF8(const std::wstring& sFileName)
 	{
 		std::string sContent;
-		// читаем файл как есть. utf-8 тут просто название.
+		// read file as-is. utf-8 here is just a name.
 		if(!NSFile::CFileBinary::ReadAllTextUtf8A(sFileName, sContent))
 			return sContent;
 
 		std::string sEncoding;
 		if (true)
 		{
-			// определяем кодировку
+			//determining the encoding
 			const std::string::size_type& posCharset = sContent.find("@charset");
 
 			if (std::string::npos != posCharset)

Common/3dParty/html/css/src/StyleProperties.h

@@ -4,11 +4,14 @@
 #include <map>
 #include <string>
 #include <vector>
-#include <sstream>
 
 #include "../../../../DesktopEditor/graphics/Matrix.h"
 #include "CUnitMeasureConverter.h"
 
+#include <boost/optional.hpp>
+#include "boost/blank.hpp"
+#include <boost/variant2/variant.hpp>
+
 namespace NSCSS
 {
 	namespace NSProperties
@@ -16,33 +19,34 @@ namespace NSCSS
 	#define NEXT_LEVEL UINT_MAX, true
 
 	template<typename T>
-	class CValue
+	class CValueBase
 	{
-		friend class CString;
-		friend class CMatrix;
-		friend class CDigit;
-		friend class CColor;
-		friend class CEnum;
-		friend class CURL;
+	protected:
+		CValueBase()
+			: m_unLevel(0), m_bImportant(false)
+		{}
+		CValueBase(const CValueBase& oValue)
+			: m_oValue(oValue.m_oValue), m_unLevel(oValue.m_unLevel), m_bImportant(oValue.m_bImportant)
+		{}
+
+		CValueBase(const T& oValue, unsigned int unLevel, bool bImportant)
+		    : m_oValue(oValue), m_unLevel(unLevel), m_bImportant(bImportant)
+		{}
 
 		T            m_oValue;
 		unsigned int m_unLevel;
 		bool         m_bImportant;
 	public:
-		CValue(const T& oValue, unsigned int unLevel, bool bImportant) :
-		    m_oValue(oValue), m_unLevel(unLevel), m_bImportant(bImportant)
-		{
-		}
+		virtual bool Empty() const = 0;
+		virtual void Clear() = 0;
 
 		virtual bool SetValue(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode) = 0;
 
-		virtual bool Empty() const = 0;
-		virtual void Clear() = 0;
 		virtual int ToInt() const = 0;
 		virtual double ToDouble() const = 0;
 		virtual std::wstring ToWString() const = 0;
 
-		static void Equation(CValue &oFirstValue, CValue &oSecondValue)
+		static void Equation(CValueBase &oFirstValue, CValueBase &oSecondValue)
 		{
 			if (oFirstValue.m_bImportant && !oSecondValue.m_bImportant && oFirstValue.Empty())
 				oSecondValue.Clear();
@@ -57,18 +61,39 @@ namespace NSCSS
 			}
 		}
 
-		static bool LevelIsSame(const CValue& oFirstValue, const CValue& oSecondValue)
+		static bool LevelIsSame(const CValueBase& oFirstValue, const CValueBase& oSecondValue)
 		{
 			return oFirstValue.m_unLevel == oSecondValue.m_unLevel;
 		}
 
-		bool operator==(const T& oValue) const { return m_oValue == oValue; }
-		bool operator>=(const T& oValue) const { return m_oValue >= oValue; }
-		bool operator<=(const T& oValue) const { return m_oValue <= oValue; }
-		bool operator> (const T& oValue) const { return m_oValue > oValue; }
-		bool operator< (const T& oValue) const { return m_oValue < oValue; }
+		friend bool operator==(const CValueBase& oLeftValue, const CValueBase& oRightValue)
+		{
+			if (oLeftValue.Empty() && oRightValue.Empty())
+				return true;
 
-		virtual CValue& operator =(const CValue& oValue)
+			if (( oLeftValue.Empty() && !oRightValue.Empty()) ||
+			    (!oLeftValue.Empty() &&  oRightValue.Empty()))
+				return false;
+
+			return oLeftValue.m_oValue == oRightValue.m_oValue;
+		}
+
+		friend bool operator!=(const CValueBase& oLeftValue, const CValueBase& oRightValue)
+		{
+			return !(oLeftValue == oRightValue);
+		}
+
+		bool operator==(const T& oValue) const
+		{
+			return m_oValue == oValue;
+		}
+
+		bool operator!=(const T& oValue) const
+		{
+			return m_oValue != oValue;
+		}
+
+		virtual CValueBase& operator =(const CValueBase& oValue)
 		{
 			m_oValue     = oValue.m_oValue;
 			m_unLevel    = oValue.m_unLevel;
@@ -77,70 +102,98 @@ namespace NSCSS
 			return *this;
 		}
 
-		virtual CValue& operator =(const T& oValue)
+		virtual CValueBase& operator =(const T& oValue)
 		{
-			//m_oValue = oValue.m_oValue;
+			m_oValue = oValue;
+
 			return *this;
 		}
 
-		virtual CValue& operator+=(const CValue& oValue)
+		virtual CValueBase& operator+=(const CValueBase& oValue)
 		{
 			if (m_unLevel > oValue.m_unLevel || (m_bImportant && !oValue.m_bImportant) || oValue.Empty())
 				return *this;
 
-			m_oValue     = oValue.m_oValue;
-			m_unLevel    = oValue.m_unLevel;
-			m_bImportant = oValue.m_bImportant;
+			*this = oValue;
 
 			return *this;
 		}
 
-		virtual bool operator==(const CValue& oValue) const
+		bool LessSignificantThen(const CValueBase& oValue) const
 		{
-			return m_oValue == oValue.m_oValue;
-		}
-
-		virtual bool operator!=(const CValue& oValue) const
-		{
-			return m_oValue != oValue.m_oValue;
+			return oValue.m_unLevel >= m_unLevel && (!m_bImportant || oValue.m_bImportant) && !oValue.Empty();
 		}
 	};
 
-	class CString : public CValue<std::wstring>
+	template<typename T>
+	class CValueOptional : public CValueBase<boost::optional<T>>
+	{
+	protected:
+		CValueOptional() = default;
+
+		CValueOptional(const T& oValue, unsigned int unLevel = 0, bool bImportant = false)
+		    : CValueBase<boost::optional<T>>(oValue, unLevel, bImportant)
+		{}
+	public:
+		virtual bool Empty() const override
+		{
+			return !this->m_oValue.has_value();
+		}
+		void Clear() override
+		{
+			this->m_oValue.reset();
+			this->m_unLevel = 0;
+			this->m_bImportant = false;
+		}
+
+		bool operator==(const T& oValue) const
+		{
+			if (!this->m_oValue.has_value())
+				return false;
+
+			return this->m_oValue.value() == oValue;
+		}
+
+		virtual CValueOptional& operator=(const T& oValue)
+		{
+			this->m_oValue = oValue;
+
+			return *this;
+		}
+	};
+
+	class CString : public CValueOptional<std::wstring>
 	{
 	public:
-		CString();
-		CString(const std::wstring& wsValue, unsigned int unLevel, bool bImportant = false);
+		CString() = default;
+		CString(const std::wstring& wsValue, unsigned int unLevel = 0, bool bImportant = false);
 
 		bool SetValue(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode) override;
 		bool SetValue(const std::wstring& wsValue, const std::vector<std::wstring>& arValiableValues, unsigned int unLevel, bool bHardMode);
 		bool SetValue(const std::wstring& wsValue, const std::map<std::wstring, std::wstring>& arValiableValues, unsigned int unLevel, bool bHardMode);
 
 		bool Empty() const override;
-		void Clear() override;
 
 		int          ToInt()     const override;
 		double       ToDouble()  const override;
 		std::wstring ToWString() const override;
 
-		CString& operator+=(const CString& oString);
+		bool operator==(const wchar_t* pValue) const;
+		bool operator!=(const wchar_t* pValue) const;
+
+		using CValueOptional<std::wstring>::operator=;
 	};
 
-	class CDigit : public CValue<double>
+	class CDigit : public CValueOptional<double>
 	{
-		UnitMeasure m_enUnitMeasure;
-
-		double ConvertValue(double dPrevValue, UnitMeasure enUnitMeasure) const;
 	public:
 		CDigit();
-		CDigit(double dValue);
-		CDigit(double dValue, unsigned int unLevel, bool bImportant = false);
+		CDigit(const double& dValue, unsigned int unLevel = 0, bool bImportant = false);
 
 		bool SetValue(const std::wstring& wsValue, unsigned int unLevel = 0, bool bHardMode = true) override;
 		bool SetValue(const CDigit& oValue);
-		bool SetValue(const double& dValue, unsigned int unLevel, bool bHardMode);
+		bool SetValue(const double& dValue, UnitMeasure enUnitMeasure, unsigned int unLevel = 0, bool bHardMode = true);
 
-		bool Empty() const override;
 		bool Zero() const;
 		void Clear() override;
 
@@ -156,7 +209,7 @@ namespace NSCSS
 
 		UnitMeasure GetUnitMeasure() const;
 
-		bool operator==(const double& oValue) const;
+		bool operator==(const double& dValue) const;
 		bool operator==(const CDigit& oDigit) const;
 
 		bool operator!=(const double& oValue) const;
@@ -171,11 +224,19 @@ namespace NSCSS
 
 		CDigit& operator+=(const CDigit& oDigit);
 		CDigit& operator-=(const CDigit& oDigit);
-		CDigit& operator+=(double dValue);
-		CDigit& operator-=(double dValue);
-		CDigit& operator*=(double dValue);
-		CDigit& operator/=(double dValue);
-		CDigit& operator =(double dValue);
+		CDigit& operator+=(const double& dValue);
+		CDigit& operator-=(const double& dValue);
+		CDigit& operator*=(const double& dValue);
+		CDigit& operator/=(const double& dValue);
+
+		using CValueOptional<double>::operator=;
+	private:
+		UnitMeasure m_enUnitMeasure;
+
+		double ConvertValue(double dPrevValue, UnitMeasure enUnitMeasure) const;
+
+		template <typename Operation>
+		CDigit ApplyOperation(const CDigit& oDigit, Operation operation) const;
 	};
 
 	struct TRGB
@@ -186,6 +247,8 @@ namespace NSCSS
 
 		bool Empty() const;
 
+		int ToInt() const;
+
 		bool operator==(const TRGB& oRGB) const;
 		bool operator!=(const TRGB& oRGB) const;
 	};
@@ -211,31 +274,58 @@ namespace NSCSS
 	
 	typedef enum
 	{
-		ColorEmpty,
 		ColorNone,
 		ColorRGB,
 		ColorHEX,
 		ColorUrl,
 		ColorContextStroke,
 		ColorContextFill
-	} ColorType;
+	} EColorType;
 
-	class CColor : public CValue<void*>
+	class CColorValue
+	{
+		using color_value = boost::variant2::variant<boost::blank, std::wstring, TRGB, CURL>;
+	protected:
+		EColorType  m_eType;
+	public:
+		CColorValue();
+		CColorValue(const CColorValue& oValue);
+		CColorValue(const std::wstring& wsValue);
+		CColorValue(const TRGB& oValue);
+		CColorValue(const CURL& oValue);
+
+		EColorType GetType() const;
+
+		bool operator==(const CColorValue& oValue) const;
+
+		color_value m_oValue;
+	};
+
+	class CColorValueContextStroke : public CColorValue
+	{
+	public:
+		CColorValueContextStroke();
+	};
+
+	class CColorValueContextFill : public CColorValue
+	{
+	public:
+		CColorValueContextFill();
+	};
+
+	class CColor : public CValueOptional<CColorValue>
 	{
 	public:
 		CColor();
-		CColor(const CColor& oColor);
-		~CColor();
 
 		bool SetValue(const std::wstring& wsValue, unsigned int unLevel = 0, bool bHardMode = true) override;
 		bool SetOpacity(const std::wstring& wsValue, unsigned int unLevel = 0, bool bHardMode = true);
 
-		bool Empty() const override;
 		bool None() const;
 		bool Url() const;
 		void Clear() override;
 
-		ColorType GetType() const;
+		EColorType GetType() const;
 
 		double GetOpacity() const;
 
@@ -249,21 +339,15 @@ namespace NSCSS
 		static TRGB ConvertHEXtoRGB(const std::wstring& wsValue);
 		static std::wstring ConvertRGBtoHEX(const TRGB& oValue);
 
-		bool operator==(const CColor& oColor) const;
-		bool operator!=(const CColor& oColor) const;
-
-		CColor& operator =(const CColor& oColor);
-		CColor& operator+=(const CColor& oColor);
+		using CValueOptional<CColorValue>::operator=;
 	private:
-		CDigit    m_oOpacity;
-		ColorType m_enType;
+		CDigit m_oOpacity;
 
 		void SetEmpty(unsigned int unLevel = 0);
 		void SetRGB(unsigned char uchR, unsigned char uchG, unsigned char uchB);
 		void SetRGB(const TRGB& oRGB);
 		void SetHEX(const std::wstring& wsValue);
-		void SetUrl(const std::wstring& wsValue);
-		void SetNone();
+		bool SetUrl(const std::wstring& wsValue);
 	};
 
 	typedef enum
@@ -279,7 +363,7 @@ namespace NSCSS
 
 	typedef std::vector<std::pair<std::vector<double>, TransformType>> MatrixValues;
 
-	class CMatrix : public CValue<MatrixValues>
+	class CMatrix : public CValueBase<MatrixValues>
 	{
 		std::vector<std::wstring> CutTransforms(const std::wstring& wsValue) const;
 	public:
@@ -302,32 +386,41 @@ namespace NSCSS
 		void ApplyTranform(Aggplus::CMatrix& oMatrix, Aggplus::MatrixOrder order = Aggplus::MatrixOrderPrepend) const;
 
 		bool operator==(const CMatrix& oMatrix) const;
+		CMatrix& operator+=(const CMatrix& oMatrix);
+		CMatrix& operator-=(const CMatrix& oMatrix);
+
+		using CValueBase<MatrixValues>::operator=;
 	};
 
-	class CEnum : public CValue<int>
+	class CEnum : public CValueOptional<int>
 	{
-		std::map<std::wstring, int> m_mMap;
 	public:
 		CEnum();
 
 		bool SetValue(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode) override;
 		void SetMapping(const std::map<std::wstring, int>& mMap, int nDefaulvalue = -1);
 
-		bool Empty() const override;
-		void Clear() override;
-
-		CEnum &operator =(int nValue);
-
-		bool operator==(int nValue) const;
-		bool operator!=(int nValue) const;
-
 		int ToInt() const override;
+
+		using CValueOptional<int>::operator=;
 	private:
 		double ToDouble() const override;
 		std::wstring ToWString() const override;
+
+		int m_nDefaultValue;
+		std::map<std::wstring, int> m_mMap;
 	};
 
 	// PROPERTIES
+	typedef enum
+	{
+		Normal,
+		Nowrap,
+		Pre,
+		Pre_Line,
+		Pre_Wrap
+	} EWhiteSpace;
+
 	class CDisplay
 	{
 	public:
@@ -347,6 +440,8 @@ namespace NSCSS
 
 		bool SetDisplay(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
+		bool SetWhiteSpace(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+
 		const CDigit& GetX()      const;
 		const CDigit& GetY()      const;
 		const CDigit& GetWidth()  const;
@@ -357,7 +452,10 @@ namespace NSCSS
 
 		const CString& GetDisplay() const;
 
+		const CEnum& GetWhiteSpace() const;
+
 		bool Empty() const;
+		void Clear();
 
 		CDisplay& operator+=(const CDisplay& oDisplay);
 		bool      operator==(const CDisplay& oDisplay) const;
@@ -371,6 +469,8 @@ namespace NSCSS
 		CString m_oVAlign;
 
 		CString m_oDisplay;
+
+		CEnum m_eWhiteSpace;
 	};
 
 	class CStroke
@@ -457,7 +557,7 @@ namespace NSCSS
 
 		bool SetValue(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetWidth(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetWidth(const double& dValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetWidth(const double& dValue, UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
 		bool SetStyle(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetColor(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
@@ -509,7 +609,7 @@ namespace NSCSS
 
 		bool SetSides(const std::wstring& wsValue,    unsigned int unLevel, bool bHardMode = false);
 		bool SetWidth(const std::wstring& wsValue,    unsigned int unLevel, bool bHardMode = false);
-		bool SetWidth(const double& dValue,           unsigned int unLevel, bool bHardMode = false);
+		bool SetWidth(const double& dValue,           UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
 		bool SetStyle(const std::wstring& wsValue,    unsigned int unLevel, bool bHardMode = false);
 		bool SetColor(const std::wstring& wsValue,    unsigned int unLevel, bool bHardMode = false);
 		bool SetCollapse(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
@@ -517,28 +617,28 @@ namespace NSCSS
 		//Left Side
 		bool SetLeftSide       (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetWidthLeftSide  (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetWidthLeftSide  (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
+		bool SetWidthLeftSide  (const double& dValue,        UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
 		bool SetStyleLeftSide  (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetColorLeftSide  (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
 		//Top Side
 		bool SetTopSide        (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetWidthTopSide   (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetWidthTopSide   (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
+		bool SetWidthTopSide   (const double& dValue,        UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
 		bool SetStyleTopSide   (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetColorTopSide   (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
 		//Right Side
 		bool SetRightSide      (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetWidthRightSide (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetWidthRightSide (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
+		bool SetWidthRightSide (const double& dValue,        UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
 		bool SetStyleRightSide (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetColorRightSide (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
 		//Bottom Side
 		bool SetBottomSide     (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetWidthBottomSide(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetWidthBottomSide(const double& dValue,        unsigned int unLevel, bool bHardMode = false);
+		bool SetWidthBottomSide(const double& dValue,        UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
 		bool SetStyleBottomSide(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetColorBottomSide(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
@@ -601,6 +701,30 @@ namespace NSCSS
 		bool operator==(const TTextDecoration& oTextDecoration) const;
 	};
 
+	typedef enum
+	{
+		Baseline,
+		Sub,
+		Super,
+		Percentage,
+		Length
+	} EBaselineShift;
+
+	class CBaselineShift
+	{
+		CEnum   m_eType;
+		CDigit  m_oValue;
+	public:
+		CBaselineShift();
+
+		bool Empty() const;
+
+		EBaselineShift GetType() const;
+		double         GetValue() const;
+
+		bool SetValue(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+	};
+
 	class CText
 	{
 	public:
@@ -608,11 +732,12 @@ namespace NSCSS
 
 		static void Equation(CText &oFirstText, CText &oSecondText);
 
-		bool SetIndent    (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetAlign     (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetDecoration(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetColor     (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetHighlight (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetIndent        (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetAlign         (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetDecoration    (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetColor         (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetHighlight     (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
+		bool SetBaselineShift (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
 		const CDigit&          GetIndent()     const;
 		const CString&         GetAlign()      const;
@@ -620,6 +745,9 @@ namespace NSCSS
 		const CColor&          GetColor()      const;
 		const CColor&          GetHighlight()  const;
 
+		EBaselineShift GetBaselineShiftType()  const;
+		double         GetBaselineShiftValue() const;
+
 		bool Empty() const;
 
 		bool Underline()   const;
@@ -629,6 +757,7 @@ namespace NSCSS
 		CText& operator+=(const CText& oText);
 		bool   operator==(const CText& oText) const;
 	private:
+		CBaselineShift  m_oBaselineShift;
 		TTextDecoration m_oDecoration;
 		CDigit          m_oIndent;
 		CString         m_oAlign;
@@ -651,13 +780,15 @@ namespace NSCSS
 
 		bool SetValues (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetTop    (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetTop    (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
 		bool SetRight  (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetRight  (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
 		bool SetBottom (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetBottom (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
 		bool SetLeft   (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetLeft   (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
+
+		bool SetValues (const double& dValue, UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
+		bool SetTop    (const double& dValue, UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
+		bool SetRight  (const double& dValue, UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
+		bool SetBottom (const double& dValue, UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
+		bool SetLeft   (const double& dValue, UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
 
 		void UpdateAll   (const double& dParentFontSize, const double& dCoreFontSize);
 		void UpdateTop   (const double& dParentFontSize, const double& dCoreFontSize);
@@ -670,6 +801,9 @@ namespace NSCSS
 		const CDigit& GetBottom() const;
 		const CDigit& GetLeft  () const;
 
+		bool GetAfterAutospacing () const;
+		bool GetBeforeAutospacing() const;
+
 		bool Empty() const;
 		bool Zero() const;
 
@@ -697,7 +831,7 @@ namespace NSCSS
 
 		bool SetValue         (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetSize          (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
-		bool SetSize          (const double& dValue,        unsigned int unLevel, bool bHardMode = false);
+		bool SetSize          (const double& dValue,        UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
 		bool SetLineHeight    (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetFamily        (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetStretch       (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
@@ -730,7 +864,7 @@ namespace NSCSS
 		CDigit  m_oSize;
 		CDigit  m_oLineHeight;
 		CString m_oFamily;
-		//TODO:: возможно стоит перейти в слудующих переменных на enum
+		//TODO:: perhaps should switch to enum for the following variables
 		CString m_oStretch;
 		CString m_oStyle;
 		CString m_oVariant;
@@ -747,6 +881,12 @@ namespace NSCSS
 		bool SetFooter (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 		bool SetHeader (const std::wstring& wsValue, unsigned int unLevel, bool bHardMode = false);
 
+		bool SetWidth  (const double& dValue, UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
+		bool SetHeight (const double& dValue, UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
+		bool SetMargin (const double& dValue, UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
+		bool SetFooter (const double& dValue, UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
+		bool SetHeader (const double& dValue, UnitMeasure enUnitMeasure, unsigned int unLevel, bool bHardMode = false);
+
 		const CDigit&  GetWidth()  const;
 		const CDigit&  GetHeight() const;
 		const CIndent& GetMargin() const;

Common/3dParty/html/css/src/xhtml/CDocumentStyle.cpp

@@ -1,6 +1,5 @@
 #include "CDocumentStyle.h"
 
-#include <iostream>
 #include <unordered_set>
 #include <wchar.h>
 #include <math.h>
@@ -9,7 +8,7 @@
 #include <list>
 
 #define DEFAULT_LINEHEIGHT 240
-#define LINEHEIGHTSCALE 10 // Значение LineHeight в OOXML должно быть в 10 раз больше чем указано в стиле
+#define LINEHEIGHTSCALE 10 // LineHeight value in OOXML must be 10 times larger than specified in style
 
 #define VALUE_TO_INT(value, unit_measure) \
 	(NSCSS::UnitMeasure::None != value.GetUnitMeasure()) ? \
@@ -22,10 +21,15 @@ namespace NSCSS
 		: m_oStyle(oStyle), m_bIsPStyle(bIsPStyle)
 	{}
 
-	bool CheckArrays(const std::vector<std::wstring>& arInitial, const std::set<std::wstring>& arFirst, const std::set<std::wstring>& arSecond) 
+	void CStyleUsed::SetFinalId(const std::wstring& wsFinalId)
+	{
+		m_wsFinalId = wsFinalId;
+	}
+
+	bool CheckArrays(const std::vector<std::wstring>& arInitial, const std::set<std::wstring>& arFirst, const std::set<std::wstring>& arSecond)
 	{
 		std::unordered_set<std::wstring> arInitialSet(arInitial.begin(), arInitial.end());
-	
+
 		std::vector<std::wstring> arCommonElements1;
 		std::vector<std::wstring> arCommonElements2;
 
@@ -57,19 +61,14 @@ namespace NSCSS
 		       m_oStyle == oUsedStyle.m_oStyle;
 	}
 
-	std::wstring CStyleUsed::getId()
+	std::wstring CStyleUsed::GetId() const
 	{
-		if (m_bIsPStyle)
-			return m_oStyle.GetId();
-
-		return m_oStyle.GetId() + L"-c";
+		return m_wsFinalId;
 	}
 
-	CDocumentStyle::CDocumentStyle() : m_arStandardStyles(Names_Standard_Styles)
-	{
-		for (const std::wstring& oNameStandardStyle : Names_Standard_Styles)
-			m_arStandardStyles.push_back(oNameStandardStyle + L"-c");
-	}
+	CDocumentStyle::CDocumentStyle()
+		: m_arStandardStyles(Names_Standard_Styles)
+	{}
 
 	CDocumentStyle::~CDocumentStyle()
 	{
@@ -85,7 +84,7 @@ namespace NSCSS
 
 	std::wstring CDocumentStyle::GetIdAndClear()
 	{
-		std::wstring sId = m_sId;
+		const std::wstring sId = m_sId;
 		Clear();
 		return sId;
 	}
@@ -110,10 +109,10 @@ namespace NSCSS
 		m_sId = sId;
 	}
 
-	void CDocumentStyle::CombineStandardStyles(const std::vector<std::wstring>& arStandartedStyles, CXmlElement& oElement)
+	bool CDocumentStyle::CombineStandardStyles(const std::vector<std::wstring>& arStandartedStyles, CXmlElement& oElement)
 	{
 		if (arStandartedStyles.empty())
-			return;
+			return false;
 
 		std::vector<std::wstring> arStyles;
 		for (const std::wstring& sStyleName : arStandartedStyles)
@@ -123,7 +122,7 @@ namespace NSCSS
 		}
 
 		if (arStyles.empty())
-			return;
+			return false;
 
 		std::wstring sId;
 		for (std::vector<std::wstring>::const_reverse_iterator iStyleName = arStyles.rbegin(); iStyleName != arStyles.rend(); ++iStyleName)
@@ -142,18 +141,25 @@ namespace NSCSS
 
 		oElement.AddBasicProperties(BProperties::B_Name, sId);
 		oElement.AddBasicProperties(BProperties::B_StyleId, sId);
+
+		return true;
 	}
 
-	void CDocumentStyle::CreateStandardStyle(const std::wstring& sNameStyle, CXmlElement& oElement)
+	bool CDocumentStyle::CreateStandardStyle(const std::wstring& sNameStyle, CXmlElement& oElement)
 	{
 		if (std::find(m_arStandardStyles.begin(), m_arStandardStyles.end(), sNameStyle) != m_arStandardStyles.end())
+		{
 			oElement.CreateDefaultElement(sNameStyle);
+			return true;
+		}
+
+		return false;
 	}
 
-	void CDocumentStyle::ConvertStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oElement, bool bIsPStyle)
+	bool CDocumentStyle::ConvertStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oElement, bool bIsPStyle)
 	{
 		if (oStyle.GetId().empty())
-			return;
+			return false;
 
 		std::wstring sName = oStyle.GetId();
 		const size_t posPoint = sName.find(L'.');
@@ -183,25 +189,25 @@ namespace NSCSS
 			for (std::wstring& sParentName : arParentsName)
 				sParentName += L"-c";
 
+		bool bResult{false};
+
 		if (!arParentsName.empty())
 		{
-			CombineStandardStyles(arParentsName, oParentStyle);
+			bResult = CombineStandardStyles(arParentsName, oParentStyle);
 
 			if (!oParentStyle.Empty())
 			{
 				oParentStyle.AddBasicProperties(BProperties::B_BasedOn, L"normal");
-				oParentStyle.AddBasicProperties(BProperties::B_StyleId, L"(" + oParentStyle.GetStyleId() + L")");
+				oParentStyle.AddBasicProperties(BProperties::B_StyleId, oParentStyle.GetStyleId());
 				if (!bIsPStyle)
-				{
-					oParentStyle.AddBasicProperties(BProperties::B_StyleId, oParentStyle.GetStyleId() + L"-c");
 					oParentStyle.AddBasicProperties(BProperties::B_Type, L"character");
-				}
 			}
 		}
 
 		CXmlElement oStandardXmlElement;
 		if (std::find(m_arStandardStyles.begin(), m_arStandardStyles.end(), sName) != m_arStandardStyles.end())
-			CreateStandardStyle(sName, oStandardXmlElement);
+			if (CreateStandardStyle(sName, oStandardXmlElement))
+				bResult = true;
 
 		if (oStandardXmlElement.Empty() && !oParentStyle.Empty())
 		{
@@ -221,7 +227,7 @@ namespace NSCSS
 			if (oStyle.Empty())
 			{
 				m_sId = sParentsStyleID;
-				return;
+				return true;
 			}
 
 			oElement.AddBasicProperties(BProperties::B_BasedOn, sParentsStyleID);
@@ -234,7 +240,7 @@ namespace NSCSS
 				if (oStyle.Empty())
 				{
 					m_sId = sStandPlusParent;
-					return;
+					return true;
 				}
 				oElement.AddBasicProperties(BProperties::B_BasedOn, sStandPlusParent);
 			}
@@ -258,7 +264,7 @@ namespace NSCSS
 				if (oStyle.Empty())
 				{
 					m_sId = sStandPlusParent;
-					return;
+					return true;
 				}
 				oElement.AddBasicProperties(BProperties::B_BasedOn, oTempElement.GetStyleId());
 			}
@@ -281,7 +287,7 @@ namespace NSCSS
 			if (oStyle.Empty())
 			{
 				m_sId = sStandartStyleID;
-				return;
+				return true;
 			}
 			oElement.AddBasicProperties(BProperties::B_BasedOn, sStandartStyleID);
 		}
@@ -289,7 +295,7 @@ namespace NSCSS
 		if (oStyle.Empty() && oElement.Empty())
 		{
 			m_sId = L"normal";
-			return;
+			return true;
 		}
 
 		m_sId = oStyle.GetId();
@@ -302,15 +308,19 @@ namespace NSCSS
 		oElement.AddBasicProperties(BProperties::B_Name, m_sId);
 		oElement.AddBasicProperties(BProperties::B_Type, bIsPStyle ? L"paragraph" : L"character");
 		oElement.AddBasicProperties(BProperties::B_CustomStyle, L"1");
+
+		return bResult;
 	}
 
-	void CDocumentStyle::SetPStyle   (const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement, bool bIsLite)
+	bool CDocumentStyle::SetPStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement, bool bIsLite)
 	{
+		bool bResult{false};
+
 		if (!bIsLite)
-			ConvertStyle(oStyle, oXmlElement, true);
+			bResult = ConvertStyle(oStyle, oXmlElement, true);
 
 		if (oStyle.Empty())
-			return;
+			return bResult;
 
 		const bool bInTable{oStyle.HaveThisParent(L"table")};
 
@@ -341,14 +351,14 @@ namespace NSCSS
 		sSpacingValue.reserve(128);
 
 		if (!oStyle.m_oMargin.GetTop().Empty() && !oStyle.m_oMargin.GetTop().Zero())
-			sSpacingValue += L"w:before=\""  + std::to_wstring(VALUE_TO_INT(oStyle.m_oMargin.GetTop(), NSCSS::Twips))    + L"\" w:beforeAutospacing=\"0\"";
+			sSpacingValue += L"w:before=\""  + std::to_wstring(VALUE_TO_INT(oStyle.m_oMargin.GetTop(), NSCSS::Twips))    + L"\" w:beforeAutospacing=\"1\"";
 		else if (oStyle.m_oMargin.GetBottom().Zero() || bInTable)
-			sSpacingValue += L"w:before=\"0\" w:beforeAutospacing=\"0\"";
+			sSpacingValue += L"w:before=\"0\" w:beforeAutospacing=\"1\"";
 
 		if (!oStyle.m_oMargin.GetBottom().Empty() && !oStyle.m_oMargin.GetBottom().Zero())
-			sSpacingValue += L" w:after=\""   + std::to_wstring(VALUE_TO_INT(oStyle.m_oMargin.GetBottom(), NSCSS::Twips)) + L"\" w:afterAutospacing=\"0\"";
+			sSpacingValue += L" w:after=\""   + std::to_wstring(VALUE_TO_INT(oStyle.m_oMargin.GetBottom(), NSCSS::Twips)) + L"\" w:afterAutospacing=\"1\"";
 		else if (oStyle.m_oMargin.GetBottom().Zero() || bInTable)
-			sSpacingValue += L" w:after=\"0\" w:afterAutospacing=\"0\"";
+			sSpacingValue += L" w:after=\"0\" w:afterAutospacing=\"1\"";
 
 		if (!oStyle.m_oFont.GetLineHeight().Empty() && !oStyle.m_oFont.GetLineHeight().Zero())
 		{
@@ -390,6 +400,8 @@ namespace NSCSS
 					SetBorderStyle(oStyle, oXmlElement, PProperties::P_LeftBorder);
 			}
 		}
+
+		return bResult || !oXmlElement.Empty();
 	}
 
 	void CDocumentStyle::SetBorderStyle(const CCompiledStyle &oStyle, CXmlElement &oXmlElement, const PProperties &enBorderProperty)
@@ -441,7 +453,7 @@ namespace NSCSS
 		int nWidth = static_cast<int>(std::round(oBorder.GetWidth().ToDouble(Point) * 8.));
 
 		if (L"double" == wsStyle)
-			nWidth /= 3; // в ooxml double граница формируется из трёх линий
+			nWidth /= 3; // in ooxml double border is formed from three lines
 
 		if (nWidth <= 3)
 			nWidth = 2;
@@ -470,22 +482,21 @@ namespace NSCSS
 
 		int nSpace{0};
 
-		if (NULL != pPadding && !pPadding->Empty() && !pPadding->Zero())
-			nSpace = pPadding->ToInt(NSCSS::Point);
-
 		return  L"w:val=\"" + wsStyle + L"\" w:sz=\"" + std::to_wstring(nWidth) + + L"\" w:space=\"" + std::to_wstring(nSpace) + L"\" w:color=\"" + wsColor + L"\"";
 	}
 
-	void CDocumentStyle::SetRStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement, bool bIsLite)
+	bool CDocumentStyle::SetRStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement, bool bIsLite)
 	{
+		bool bResult{false};
+
 		if (!bIsLite)
-			ConvertStyle(oStyle, oXmlElement, false);
+			bResult = ConvertStyle(oStyle, oXmlElement, false);
 
 		if (oStyle.Empty() && oXmlElement.Empty())
-			return;
+			return bResult;
 
 		if (!oStyle.m_oFont.GetSize().Empty())
-			oXmlElement.AddPropertiesInR(RProperties::R_Sz, std::to_wstring(static_cast<int>(oStyle.m_oFont.GetSize().ToDouble(NSCSS::Point) * 2. * oStyle.m_oTransform.GetMatrix().GetFinalValue().sy() + 0.5))); // Значения шрифта увеличивает на 2
+			oXmlElement.AddPropertiesInR(RProperties::R_Sz, std::to_wstring(static_cast<int>(oStyle.m_oFont.GetSize().ToDouble(NSCSS::Point) * 2. * oStyle.m_oTransform.GetMatrix().GetFinalValue().sy() + 0.5))); // Font value is multiplied by 2
 
 		if (oStyle.m_oText.GetDecoration().m_oLine.Underline())
 			oXmlElement.AddPropertiesInR(RProperties::R_U, (!oStyle.m_oText.GetDecoration().m_oStyle.Empty()) ? oStyle.m_oText.GetDecoration().m_oStyle.ToWString() : L"single");
@@ -512,10 +523,25 @@ namespace NSCSS
 		else if (L"serif" == wsFontFamily)
 			wsFontFamily = L"Times New Roman";
 
+		if (oStyle.m_oDisplay.GetDisplay() == L"none")
+			oXmlElement.AddPropertiesInR(RProperties::R_Vanish, L"true");
+
 		oXmlElement.AddPropertiesInR(RProperties::R_RFonts, oStyle.m_oFont.GetFamily().ToWString());
 		oXmlElement.AddPropertiesInR(RProperties::R_I, oStyle.m_oFont.GetStyle().ToWString());
 		oXmlElement.AddPropertiesInR(RProperties::R_B, oStyle.m_oFont.GetWeight().ToWString());
 		oXmlElement.AddPropertiesInR(RProperties::R_SmallCaps, oStyle.m_oFont.GetVariant().ToWString());
+
+		if (oStyle.m_oText.LineThrough())
+		{
+			if (L"double" == oStyle.m_oText.GetDecoration().m_oStyle.ToWString())
+				oXmlElement.AddPropertiesInR(RProperties::R_Strike, L"dstrike");
+			else
+				oXmlElement.AddPropertiesInR(RProperties::R_Strike, L"strike");
+		}
+
+		oXmlElement.AddPropertiesInR(RProperties::R_VertAlign, oStyle.m_oDisplay.GetVAlign().ToWString());
+
+		return bResult || !oXmlElement.Empty();
 	}
 
 	bool CDocumentStyle::WriteRStyle(const NSCSS::CCompiledStyle& oStyle)
@@ -531,16 +557,16 @@ namespace NSCSS
 
 		if (oItem != m_arStyleUsed.end())
 		{
-			m_sId = (*oItem).getId();
+			m_sId = (*oItem).GetId();
 			return true;
 		}
 
 		CXmlElement oXmlElement;
-		SetRStyle(oStyle, oXmlElement);
 
-		if (oXmlElement.Empty())
+		if (!SetRStyle(oStyle, oXmlElement))
 			return false;
 
+		structStyle.SetFinalId(m_sId);
 		m_arStyleUsed.push_back(structStyle);
 		m_sStyle += oXmlElement.GetRStyle();
 
@@ -559,7 +585,7 @@ namespace NSCSS
 
 		if (oXmlElement.Empty())
 			return false;
-		
+
 		m_sStyle += oXmlElement.GetPStyle(true);
 		return true;
 	}
@@ -593,16 +619,16 @@ namespace NSCSS
 
 		if (oItem != m_arStyleUsed.end())
 		{
-			m_sId = (*oItem).getId();
+			m_sId = (*oItem).GetId();
 			return true;
 		}
 
 		CXmlElement oXmlElement;
-		SetPStyle(oStyle, oXmlElement);
 
-		if (oXmlElement.Empty())
+		if (!SetPStyle(oStyle, oXmlElement))
 			return false;
 
+		structStyle.SetFinalId(m_sId);
 		m_arStyleUsed.push_back(structStyle);
 		m_sStyle += oXmlElement.GetPStyle();
 

Common/3dParty/html/css/src/xhtml/CDocumentStyle.h

@@ -12,16 +12,19 @@ namespace NSCSS
 	{
 		CCompiledStyle m_oStyle;
 		bool m_bIsPStyle;
+		std::wstring m_wsFinalId;
 
 	public:
 		CStyleUsed(const CCompiledStyle& oStyle, bool bIsPStyle);
 
+		void SetFinalId(const std::wstring& wsFinalId);
+
 		bool operator==(const CStyleUsed& oUsedStyle) const;
 
-		std::wstring getId();
+		std::wstring GetId() const;
 	};
 
-	static const std::vector<std::wstring> Names_Standard_Styles = {L"a", L"li", L"h1", L"h2", L"h3", L"h4", L"h5", L"h6",L"p", L"div"};
+	static const std::vector<std::wstring> Names_Standard_Styles = {L"a", L"a-c", L"li", L"h1", L"h2", L"h3", L"h4", L"h5", L"h6", L"h1-c", L"h2-c", L"h3-c", L"h4-c", L"h5-c", L"h6-c"};
 
 	class CSSCALCULATOR_EXPORT CDocumentStyle
 	{
@@ -36,12 +39,12 @@ namespace NSCSS
 		std::wstring m_sStyle;
 		std::wstring m_sId;
 
-		void CombineStandardStyles(const std::vector<std::wstring>& arStandartedStyles, CXmlElement& oElement);
-		void CreateStandardStyle  (const std::wstring& sNameStyle, CXmlElement& oElement);
-		void ConvertStyle         (const NSCSS::CCompiledStyle& oStyle, CXmlElement& oElement, bool bIsPStyle);
+		bool CombineStandardStyles(const std::vector<std::wstring>& arStandartedStyles, CXmlElement& oElement);
+		bool CreateStandardStyle  (const std::wstring& sNameStyle, CXmlElement& oElement);
+		bool ConvertStyle         (const NSCSS::CCompiledStyle& oStyle, CXmlElement& oElement, bool bIsPStyle);
 
-		void SetRStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement, bool bIsLite = false);
-		void SetPStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement, bool bIsLite = false);
+		bool SetRStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement, bool bIsLite = false);
+		bool SetPStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement, bool bIsLite = false);
 
 		void SetBorderStyle(const NSCSS::CCompiledStyle& oStyle, CXmlElement& oXmlElement, const PProperties& enBorderProperty);
 	public:

Common/3dParty/html/css/src/xhtml/CXmlElement.cpp

@@ -5,7 +5,6 @@
 #include <cwctype>
 #include <functional>
 
-#include <iostream>
 #include "../ConstValues.h"
 
 #define DEFAULTFONTNAME L"Times New Roman"
@@ -67,7 +66,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h1-c");
 
 		AddPropertiesInP(CSSProperties::ParagraphProperties::P_OutlineLvl, L"0");
-//		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
+		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
 	}
 	else if (sNameDefaultElement == L"h2")
 	{
@@ -78,7 +77,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h2-c");
 
 		AddPropertiesInP(CSSProperties::ParagraphProperties::P_OutlineLvl, L"1");
-//		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
+		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
 	}
 	else if (sNameDefaultElement == L"h3")
 	{
@@ -89,7 +88,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h3-c");
 
 		AddPropertiesInP(CSSProperties::ParagraphProperties::P_OutlineLvl, L"2");
-//		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
+		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
 	}
 	else if (sNameDefaultElement == L"h4")
 	{
@@ -100,7 +99,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h4-c");
 
 		AddPropertiesInP(CSSProperties::ParagraphProperties::P_OutlineLvl, L"3");
-//		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
+		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
 	}
 	else if (sNameDefaultElement == L"h5")
 	{
@@ -111,7 +110,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h5-c");
 
 		AddPropertiesInP(CSSProperties::ParagraphProperties::P_OutlineLvl, L"4");
-//		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
+		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
 
 	}
 	else if (sNameDefaultElement == L"h6")
@@ -123,13 +122,13 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h6-c");
 
 		AddPropertiesInP(CSSProperties::ParagraphProperties::P_OutlineLvl, L"5");
-//		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
+		AddPropertiesInP(CSSProperties::ParagraphProperties::P_Spacing, L"w:before=\"100\" w:beforeAutospacing=\"1\" w:after=\"100\" w:afterAutospacing=\"1\"");
 	}
 	else if (sNameDefaultElement == L"h1-c")
 	{
 		AddBasicProperties(CSSProperties::BasicProperties::B_Type, L"character");
 		AddBasicProperties(CSSProperties::BasicProperties::B_StyleId, L"h1-c");
-		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Title 1 Sign");
+		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Heading 1 Sign");
 		AddBasicProperties(CSSProperties::BasicProperties::B_CustomStyle, L"1");
 		AddBasicProperties(CSSProperties::BasicProperties::B_UiPriority, L"9");
 		AddBasicProperties(CSSProperties::BasicProperties::B_Link, L"h1");
@@ -142,7 +141,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 	{
 		AddBasicProperties(CSSProperties::BasicProperties::B_Type, L"character");
 		AddBasicProperties(CSSProperties::BasicProperties::B_StyleId, L"h2-c");
-		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Title 2 Sign");
+		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Heading 2 Sign");
 		AddBasicProperties(CSSProperties::BasicProperties::B_CustomStyle, L"1");
 		AddBasicProperties(CSSProperties::BasicProperties::B_UiPriority, L"9");
 		AddBasicProperties(CSSProperties::BasicProperties::B_UnhideWhenUsed, L"true");
@@ -155,7 +154,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 	{
 		AddBasicProperties(CSSProperties::BasicProperties::B_Type, L"character");
 		AddBasicProperties(CSSProperties::BasicProperties::B_StyleId, L"h3-c");
-		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Title 3 Sign");
+		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Heading 3 Sign");
 		AddBasicProperties(CSSProperties::BasicProperties::B_CustomStyle, L"1");
 		AddBasicProperties(CSSProperties::BasicProperties::B_UiPriority, L"9");
 		AddBasicProperties(CSSProperties::BasicProperties::B_UnhideWhenUsed, L"true");
@@ -168,7 +167,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 	{
 		AddBasicProperties(CSSProperties::BasicProperties::B_Type, L"character");
 		AddBasicProperties(CSSProperties::BasicProperties::B_StyleId, L"h4-c");
-		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Title 4 Sign");
+		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Heading 4 Sign");
 		AddBasicProperties(CSSProperties::BasicProperties::B_CustomStyle, L"1");
 		AddBasicProperties(CSSProperties::BasicProperties::B_UiPriority, L"9");
 		AddBasicProperties(CSSProperties::BasicProperties::B_UnhideWhenUsed, L"true");
@@ -181,7 +180,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 	{
 		AddBasicProperties(CSSProperties::BasicProperties::B_Type, L"character");
 		AddBasicProperties(CSSProperties::BasicProperties::B_StyleId, L"h5-c");
-		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Title 5 Sign");
+		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Heading 5 Sign");
 		AddBasicProperties(CSSProperties::BasicProperties::B_CustomStyle, L"1");
 		AddBasicProperties(CSSProperties::BasicProperties::B_UiPriority, L"9");
 		AddBasicProperties(CSSProperties::BasicProperties::B_UnhideWhenUsed, L"true");
@@ -194,7 +193,7 @@ void CXmlElement::CreateDefaultElement(const std::wstring& sNameDefaultElement)
 	{
 		AddBasicProperties(CSSProperties::BasicProperties::B_Type, L"character");
 		AddBasicProperties(CSSProperties::BasicProperties::B_StyleId, L"h6-c");
-		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Title 6 Sign");
+		AddBasicProperties(CSSProperties::BasicProperties::B_Name, L"Heading 6 Sign");
 		AddBasicProperties(CSSProperties::BasicProperties::B_CustomStyle, L"1");
 		AddBasicProperties(CSSProperties::BasicProperties::B_UiPriority, L"9");
 		AddBasicProperties(CSSProperties::BasicProperties::B_UnhideWhenUsed, L"true");
@@ -473,6 +472,25 @@ std::wstring CXmlElement::ConvertRStyle(bool bIsLite) const
 				sRStyle += L"<w:kern w:val=\"" + oItem.second + L"\"/>";
 				break;
 			}
+			case CSSProperties::RunnerProperties::R_Vanish:
+			{
+				if (oItem.second == L"true")
+					sRStyle += L"<w:vanish/>";
+				break;
+			}
+			case CSSProperties::RunnerProperties::R_Strike:
+			{
+				sRStyle += L"<w:" + oItem.second + L"/>";
+				break;
+			}
+			case CSSProperties::RunnerProperties::R_VertAlign:
+			{
+				if (L"top" == oItem.second)
+					sRStyle += L"<w:vertAlign w:val=\"superscript\"/>";
+				else if (L"bottom" == oItem.second)
+					sRStyle += L"<w:vertAlign w:val=\"subscript\"/>";
+				break;
+			}
 			default:
 				break;
 		}

Common/3dParty/html/css/tests/test.cpp

@@ -371,10 +371,10 @@ int main(int argc, char *argv[])
     }
     std::cout << "-----END-----" << std::endl;
 
-// Тесты багов
+// Bug tests
 /*
-    // Стандарный katana_parser не считывает @page
-    // Также, если заккомитить всё, что было до тестов бага, то всё будет крашиться с ошибкой "-1073741819"
+    // Standard katana_parser doesn't read @page
+    // Also, if you uncomment everything before bug tests, it will crash with error "-1073741819"
 
     const char* css = "#page{margin:10px; padding:5pt} "
                       "@page{color:white;}";
@@ -382,7 +382,7 @@ int main(int argc, char *argv[])
     katana_dump_output(output);
     katana_destroy_output(output);
 
-    // Из-за того, что стандарный katana_parser не считывает @page, не считывает и CCssCalculator
+    // Because standard katana_parser doesn't read @page, CCssCalculator doesn't read it either
 
     std::wstring sFilePath = NSFile::GetProcessDirectory() + L"../../../../cssFiles/test.css";
     NSCSS::CCssCalculator oCSS;

Common/3dParty/html/fetch.py

@@ -10,14 +10,14 @@ base_directory = os.getcwd()
 
 if not base.is_dir("gumbo-parser"):
   base.cmd("git", ["clone", "https://github.com/google/gumbo-parser.git"])
-  base.cmd_in_dir("gumbo-parser", "git", ["checkout", "aa91b27b02c0c80c482e24348a457ed7c3c088e0"])
+  base.cmd_in_dir("gumbo-parser", "git", ["checkout", "aa91b27b02c0c80c482e24348a457ed7c3c088e0", "--quiet"])
 
   # fix gumbo
   base.replaceInFile(base_directory + "/gumbo-parser/src/tag.c", "isspace(*c)", "isspace((unsigned char)*c)")
 
 if not base.is_dir("katana-parser"):
   base.cmd("git", ["clone", "https://github.com/jasenhuang/katana-parser.git"])
-  base.cmd_in_dir("katana-parser", "git", ["checkout", "be6df458d4540eee375c513958dcb862a391cdd1"])
+  base.cmd_in_dir("katana-parser", "git", ["checkout", "be6df458d4540eee375c513958dcb862a391cdd1", "--quiet"])
 
   # fix katana
   base.replaceInFileUtf8(base_directory + "/katana-parser/src/tokenizer.c", "static inline bool katana_is_html_space(char c);", "static inline bool2 katana_is_html_space(char c);")
@@ -25,3 +25,5 @@ if not base.is_dir("katana-parser"):
   base.replaceInFileUtf8(base_directory + "/katana-parser/src/tokenizer.c", "static inline bool2 katana_is_html_space(char c);", "static inline bool katana_is_html_space(char c);")
   base.replaceInFileUtf8(base_directory + "/katana-parser/src/parser.c", "katanaget_text(parser->scanner)", "/*katanaget_text(parser->scanner)*/\"error\"")
   base.replaceInFileUtf8(base_directory + "/katana-parser/src/parser.c", "#define KATANA_PARSER_STRING(literal) (KatanaParserString){", "#define KATANA_PARSER_STRING(literal) {")
+  # katana may not be able to handle an empty string correctly in some cases (bug#73485)
+  base.replaceInFileUtf8(base_directory + "/katana-parser/src/foundation.c", "size_t len = strlen(str);", "if (NULL == str)\n        return;\n    size_t len = strlen(str);")

Common/3dParty/html/gumbo.pri

@@ -7,4 +7,5 @@ core_windows:INCLUDEPATH += $$PWD/gumbo-parser/visualc/include
 HEADERS += $$files($$PWD/gumbo-parser/src/*.h, true) \
            $$PWD/htmltoxhtml.h
 
-SOURCES += $$files($$PWD/gumbo-parser/src/*.c, true)
+SOURCES += $$files($$PWD/gumbo-parser/src/*.c, true) \
+           $$PWD/htmltoxhtml.cpp

Common/3dParty/html/htmltoxhtml.cpp

@@ -0,0 +1,657 @@
+#include "htmltoxhtml.h"
+
+#include <map>
+#include <cctype>
+#include <vector>
+#include <algorithm>
+
+#include "gumbo-parser/src/gumbo.h"
+#include "../../../DesktopEditor/common/File.h"
+#include "../../../DesktopEditor/common/Directory.h"
+#include "../../../DesktopEditor/common/StringBuilder.h"
+#include "../../../UnicodeConverter/UnicodeConverter.h"
+#include "../../../HtmlFile2/src/StringFinder.h"
+
+namespace HTML
+{
+#if defined(CreateDirectory)
+#undef CreateDirectory
+#endif
+
+static std::string nonbreaking_inline  = "|a|abbr|acronym|b|bdo|big|cite|code|dfn|em|font|i|img|kbd|nobr|s|small|span|strike|strong|sub|sup|tt|";
+static std::string empty_tags          = "|area|base|basefont|bgsound|br|command|col|embed|event-source|frame|hr|image|img|input|keygen|link|menuitem|meta|param|source|spacer|track|wbr|";
+static std::string preserve_whitespace = "|pre|textarea|script|style|";
+static std::string special_handling    = "|html|body|";
+static std::string treat_like_inline   = "|p|";
+
+static std::vector<std::string> html_tags = {"div","span","a","img","p","h1","h2","h3","h4","h5","h6",
+                                             "ul", "ol", "li","td","tr","table","thead","tbody","tfoot","th",
+                                             "br","form","input","button","section","nav","header","footer",
+                                             "main","figure","figcaption","strong","em","i", "b", "u","pre",
+                                             "code","blockquote","hr","script","link","meta","style","title",
+                                             "head","body","html","legend","optgroup","option","select","dl",
+                                             "dt","dd","time","data","abbr","address","area","base","bdi",
+                                             "bdo","cite","col","iframe","video","source","track","textarea",
+                                             "label","fieldset","colgroup","del","ins","details","summary",
+                                             "dialog","embed","kbd","map","mark","menu","meter","object",
+                                             "output","param","progress","q","samp","small","sub","sup","var",
+                                             "wbr","acronym","applet","article","aside","audio","basefont",
+                                             "bgsound","big","blink","canvas","caption","center","command",
+                                             "comment","datalist","dfn","dir","font","frame","frameset",
+                                             "hgroup","isindex","keygen","marquee","nobr","noembed","noframes",
+                                             "noscript","plaintext","rp","rt","ruby","s","strike","tt","xmp"};
+
+static std::vector<std::string> unchecked_nodes_new = {"svg"};
+
+static void replace_all(std::string& s, const std::string& s1, const std::string& s2)
+{
+	size_t pos = s.find(s1);
+	while(pos != std::string::npos)
+	{
+		s.replace(pos, s1.length(), s2);
+		pos = s.find(s1, pos + s2.length());
+	}
+}
+
+static bool NodeIsUnprocessed(const std::string& sTagName)
+{
+	return "xml" == sTagName;
+}
+
+static bool IsUnckeckedNodes(const std::string& sValue)
+{
+	return unchecked_nodes_new.end() != std::find(unchecked_nodes_new.begin(), unchecked_nodes_new.end(), sValue);
+}
+
+static std::string Base64ToString(const std::string& sContent, const std::string& sCharset)
+{
+	std::string sRes;
+	int nSrcLen = (int)sContent.length();
+	int nDecodeLen = NSBase64::Base64DecodeGetRequiredLength(nSrcLen);
+	BYTE* pData = new BYTE[nDecodeLen];
+	if (TRUE == NSBase64::Base64Decode(sContent.c_str(), nSrcLen, pData, &nDecodeLen))
+	{
+		std::wstring sConvert;
+		if(!sCharset.empty() && NSStringFinder::Equals<std::string>("utf-8", sCharset))
+		{
+			NSUnicodeConverter::CUnicodeConverter oConverter;
+			sConvert = oConverter.toUnicode(reinterpret_cast<char *>(pData), (unsigned)nDecodeLen, sCharset.data());
+		}
+		sRes = sConvert.empty() ? std::string(reinterpret_cast<char *>(pData), nDecodeLen) : U_TO_UTF8(sConvert);
+	}
+	RELEASEARRAYOBJECTS(pData);
+	return sRes;
+}
+
+static std::string QuotedPrintableDecode(const std::string& sContent, std::string& sCharset)
+{
+	NSStringUtils::CStringBuilderA sRes;
+	size_t ip = 0;
+	size_t i  = sContent.find('=');
+
+	if(i == 0)
+	{
+		size_t nIgnore = 12;
+		std::string charset = sContent.substr(0, nIgnore);
+		if(charset == "=00=00=FE=FF")
+			sCharset = "UTF-32BE";
+		else if(charset == "=FF=FE=00=00")
+			sCharset = "UTF-32LE";
+		else if(charset == "=2B=2F=76=38" || charset == "=2B=2F=76=39" ||
+				charset == "=2B=2F=76=2B" || charset == "=2B=2F=76=2F")
+			sCharset = "UTF-7";
+		else if(charset == "=DD=73=66=73")
+			sCharset = "UTF-EBCDIC";
+		else if(charset == "=84=31=95=33")
+			sCharset = "GB-18030";
+		else
+		{
+			nIgnore -= 3;
+			charset.erase(nIgnore);
+			if(charset == "=EF=BB=BF")
+				sCharset = "UTF-8";
+			else if(charset == "=F7=64=4C")
+				sCharset = "UTF-1";
+			else if(charset == "=0E=FE=FF")
+				sCharset = "SCSU";
+			else if(charset == "=FB=EE=28")
+				sCharset = "BOCU-1";
+			else
+			{
+				nIgnore -= 3;
+				charset.erase(nIgnore);
+				if(charset == "=FE=FF")
+					sCharset = "UTF-16BE";
+				else if(charset == "=FF=FE")
+					sCharset = "UTF-16LE";
+				else
+					nIgnore -= 6;
+			}
+		}
+
+		ip = nIgnore;
+		i  = sContent.find('=', ip);
+	}
+
+	while(i != std::string::npos && i + 2 < sContent.length())
+	{
+		sRes.WriteString(sContent.c_str() + ip, i - ip);
+		std::string str = sContent.substr(i + 1, 2);
+		if(str.front() == '\n' || str.front() == '\r')
+		{
+			char ch = str[1];
+			if(ch != '\n' && ch != '\r')
+				sRes.WriteString(&ch, 1);
+		}
+		else
+		{
+			char* err;
+			char ch = (int)strtol(str.data(), &err, 16);
+			if(*err)
+				sRes.WriteString('=' + str);
+			else
+				sRes.WriteString(&ch, 1);
+		}
+		ip = i + 3;
+		i = sContent.find('=', ip);
+	}
+	if(ip != std::string::npos)
+		sRes.WriteString(sContent.c_str() + ip);
+	return sRes.GetData();
+}
+
+static std::string mhtTohtml(const std::string& sFileContent);
+
+static void ReadMht(const std::string& sMhtContent, std::map<std::string, std::string>& sRes, NSStringUtils::CStringBuilderA& oRes)
+{
+	size_t unContentPosition = 0, unCharsetBegin = 0, unCharsetEnd = std::string::npos;
+
+	NSStringFinder::TFoundedData<char> oData;
+
+	// Content-Type
+	oData =  NSStringFinder::FindProperty(sMhtContent, "content-type", {":"}, {";", "\\n", "\\r"});
+	const std::string sContentType{oData.m_sValue};
+
+	if (sContentType.empty())
+		return;
+
+	if (NSStringFinder::Equals(sContentType, "multipart/alternative"))
+	{
+		oRes.WriteString(mhtTohtml(sMhtContent.substr(oData.m_unEndPosition, sMhtContent.length() - oData.m_unEndPosition)));
+		return;
+	}
+
+	unContentPosition = std::max(unContentPosition, oData.m_unEndPosition);
+	unCharsetBegin = oData.m_unEndPosition;
+
+	// name
+//	std::string sName = NSStringFinder::FindProperty(sMhtContent, "name", {"="}, {";", "\\n", "\\r"}, 0, unLastPosition);
+//	unContentPosition = std::max(unContentPosition, unLastPosition);
+
+	// Content-Location
+	oData = NSStringFinder::FindProperty(sMhtContent, "content-location", {":"}, {";", "\\n", "\\r"});
+	std::string sContentLocation{oData.m_sValue};
+
+	if (!oData.Empty())
+		unContentPosition = std::max(unContentPosition, oData.m_unEndPosition);
+
+	// Content-ID
+	oData = NSStringFinder::FindProperty(sMhtContent, "content-id", {":"}, {";", "\\n", "\\r"});
+	std::string sContentID{oData.m_sValue};
+
+	if (!oData.Empty())
+	{
+		unContentPosition = std::max(unContentPosition, oData.m_unEndPosition);
+		unCharsetEnd = std::min(unCharsetEnd, oData.m_unBeginPosition);
+		NSStringFinder::CutInside<std::string>(sContentID, "<", ">");
+	}
+
+	if (sContentLocation.empty() && !sContentID.empty())
+		sContentLocation = "cid:" + sContentID;
+
+	// Content-Transfer-Encoding
+	oData = NSStringFinder::FindProperty(sMhtContent, "content-transfer-encoding", {":"}, {";", "\\n", "\\r"});
+	const std::string sContentEncoding{oData.m_sValue};
+
+	if (!oData.Empty())
+	{
+		unContentPosition = std::max(unContentPosition, oData.m_unEndPosition);
+		unCharsetEnd = std::min(unCharsetEnd, oData.m_unBeginPosition);
+	}
+
+	// charset
+	std::string sCharset = "utf-8";
+
+	if (std::string::npos != unCharsetEnd && unCharsetBegin < unCharsetEnd)
+	{
+		sCharset = NSStringFinder::FindProperty(sMhtContent.substr(unCharsetBegin, unCharsetEnd - unCharsetBegin), "charset", {"="}, {";", "\\n", "\\r"}).m_sValue;
+		NSStringFinder::CutInside<std::string>(sCharset, "\"");
+	}
+
+	// Content
+	std::string sContent = sMhtContent.substr(unContentPosition, sMhtContent.length() - unContentPosition);
+
+//	std::wstring sExtention = NSFile::GetFileExtention(UTF8_TO_U(sName));
+//	std::transform(sExtention.begin(), sExtention.end(), sExtention.begin(), tolower);
+	// Main document
+	if (NSStringFinder::Equals(sContentType, "multipart/alternative"))
+		oRes.WriteString(mhtTohtml(sContent));
+	else if ((NSStringFinder::Find(sContentType, "text") /*&& (sExtention.empty() || NSStringFinder::EqualOf(sExtention, {L"htm", L"html", L"xhtml", L"css"}))*/)
+	          || (NSStringFinder::Equals(sContentType, "application/octet-stream") && NSStringFinder::Find(sContentLocation, "css")))
+	{
+		// Styles are enclosed in <style> tag
+		const bool bAddTagStyle = NSStringFinder::Equals(sContentType, "text/css") /*|| NSStringFinder::Equals(sExtention, L"css")*/ || NSStringFinder::Find(sContentLocation, "css");
+
+		if (bAddTagStyle)
+			oRes.WriteString("<style>");
+
+		if (NSStringFinder::Equals(sContentEncoding, "base64"))
+			sContent = Base64ToString(sContent, sCharset);
+		else if (NSStringFinder::EqualOf(sContentEncoding, {"8bit", "7bit"}) || sContentEncoding.empty())
+		{
+			if (!NSStringFinder::Equals(sCharset, "utf-8") && !sCharset.empty())
+			{
+				NSUnicodeConverter::CUnicodeConverter oConverter;
+				sContent = U_TO_UTF8(oConverter.toUnicode(sContent, sCharset.data()));
+			}
+		}
+		else if (NSStringFinder::Equals(sContentEncoding, "quoted-printable"))
+		{
+			sContent = QuotedPrintableDecode(sContent, sCharset);
+			if (!NSStringFinder::Equals(sCharset, "utf-8") && !sCharset.empty())
+			{
+				NSUnicodeConverter::CUnicodeConverter oConverter;
+				sContent = U_TO_UTF8(oConverter.toUnicode(sContent, sCharset.data()));
+			}
+		}
+
+		if (NSStringFinder::Equals(sContentType, "text/html"))
+			sContent = U_TO_UTF8(htmlToXhtml(sContent, false));
+
+		oRes.WriteString(sContent);
+
+		if(bAddTagStyle)
+			oRes.WriteString("</style>");
+	}
+	// Images
+	else if ((NSStringFinder::Find(sContentType, "image") /*|| NSStringFinder::Equals(sExtention, L"gif")*/ || NSStringFinder::Equals(sContentType, "application/octet-stream")) &&
+			  NSStringFinder::Equals(sContentEncoding, "base64"))
+	{
+//		if (NSStringFinder::Equals(sExtention, L"ico") || NSStringFinder::Find(sContentType, "ico"))
+//			sContentType = "image/jpg";
+//		else if(NSStringFinder::Equals(sExtention, L"gif"))
+//			sContentType = "image/gif";
+		int nSrcLen = (int)sContent.length();
+		int nDecodeLen = NSBase64::Base64DecodeGetRequiredLength(nSrcLen);
+		BYTE* pData = new BYTE[nDecodeLen];
+		if (TRUE == NSBase64::Base64Decode(sContent.c_str(), nSrcLen, pData, &nDecodeLen))
+			sRes.insert(std::make_pair(sContentLocation, "data:" + sContentType + ";base64," + sContent));
+		RELEASEARRAYOBJECTS(pData);
+	}
+}
+
+static std::string mhtTohtml(const std::string& sFileContent)
+{
+	std::map<std::string, std::string> sRes;
+	NSStringUtils::CStringBuilderA oRes;
+
+	// Search for boundary
+	NSStringFinder::TFoundedData<char> oData{NSStringFinder::FindProperty(sFileContent, "boundary", {"="}, {"\\r", "\\n", "\""})};
+
+	size_t nFound{oData.m_unEndPosition};
+	std::string sBoundary{oData.m_sValue};
+
+	if (sBoundary.empty())
+	{
+		size_t nFoundEnd = sFileContent.length();
+		nFound = 0;
+		ReadMht(sFileContent.substr(nFound, nFoundEnd), sRes, oRes);
+		return oRes.GetData();
+	}
+
+	NSStringFinder::CutInside<std::string>(sBoundary, "\"");
+
+	size_t nFoundEnd{nFound};
+
+	sBoundary = "--" + sBoundary;
+	size_t nBoundaryLength = sBoundary.length();
+
+	nFound = sFileContent.find(sBoundary, nFound) + nBoundaryLength;
+
+	// Loop through boundary
+	while(nFound != std::string::npos)
+	{
+		nFoundEnd = sFileContent.find(sBoundary, nFound + nBoundaryLength);
+		if(nFoundEnd == std::string::npos)
+			break;
+
+		ReadMht(sFileContent.substr(nFound, nFoundEnd - nFound), sRes, oRes);
+
+		nFound = sFileContent.find(sBoundary, nFoundEnd);
+	}
+
+	std::string sFile = oRes.GetData();
+	for(const std::pair<std::string, std::string>& item : sRes)
+	{
+		std::string sName = item.first;
+		size_t found = sFile.find(sName);
+		size_t sfound = sName.rfind('/');
+		if(found == std::string::npos && sfound != std::string::npos)
+			found = sFile.find(sName.erase(0, sfound + 1));
+		while(found != std::string::npos)
+		{
+			size_t fq = sFile.find_last_of("\"\'>=", found);
+
+			if (std::string::npos == fq)
+				break;
+
+			char ch = sFile[fq];
+			if(ch != '\"' && ch != '\'')
+				fq++;
+			size_t tq = sFile.find_first_of("\"\'<> ", found) + 1;
+
+			if (std::string::npos == tq)
+				break;
+
+			if(sFile[tq] != '\"' && sFile[tq] != '\'')
+				tq--;
+			if(ch != '>')
+			{
+				std::string is = '\"' + item.second + '\"';
+				sFile.replace(fq, tq - fq, is);
+				found = sFile.find(sName, fq + is.length());
+			}
+			else
+				found = sFile.find(sName, tq);
+		}
+	}
+
+	return sFile;
+}
+
+// Replaces entities &,<,> in text
+static void substitute_xml_entities_into_text(std::string& text)
+{
+	// replacing & must come first
+	replace_all(text, "&", "&amp;");
+	replace_all(text, "<", "&lt;");
+	replace_all(text, ">", "&gt;");
+}
+
+// After running through Gumbo, the values of type "&#1;" are replaced with the corresponding code '0x01'
+// Since the attribute value does not use control characters (value <= 0x09),
+// then just delete them, otherwise XmlUtils::CXmlLiteReader crashes on them.
+// bug#73486
+static void remove_control_symbols(std::string& text)
+{
+	std::string::iterator itFound = std::find_if(text.begin(), text.end(), [](unsigned char chValue){ return chValue <= 0x09; });
+
+	while (itFound != text.end())
+	{
+		itFound = text.erase(itFound);
+		itFound = std::find_if(itFound, text.end(), [](unsigned char chValue){ return chValue <= 0x09; });
+	}
+}
+
+// Replaces entity " in text
+static void substitute_xml_entities_into_attributes(std::string& text)
+{
+	remove_control_symbols(text);
+	substitute_xml_entities_into_text(text);
+	replace_all(text, "\"", "&quot;");
+}
+
+static std::string handle_unknown_tag(GumboStringPiece* text)
+{
+	if (text->data == NULL)
+		return "";
+	GumboStringPiece gsp = *text;
+	gumbo_tag_from_original_text(&gsp);
+	std::string sAtr = std::string(gsp.data, gsp.length);
+	size_t found = sAtr.find_first_of("-'+,./=?;!*#@$_%<>&;\"\'()[]{}");
+	while(found != std::string::npos)
+	{
+		sAtr.erase(found, 1);
+		found = sAtr.find_first_of("-'+,./=?;!*#@$_%<>&;\"\'()[]{}", found);
+	}
+	return sAtr;
+}
+
+static std::string get_tag_name(GumboNode* node)
+{
+	std::string tagname = (node->type == GUMBO_NODE_DOCUMENT ? "document" : gumbo_normalized_tagname(node->v.element.tag));
+	if (tagname.empty())
+		tagname = handle_unknown_tag(&node->v.element.original_tag);
+	return tagname;
+}
+
+static void build_doctype(GumboNode* node, NSStringUtils::CStringBuilderA& oBuilder)
+{
+	if (node->v.document.has_doctype)
+	{
+		oBuilder.WriteString("<!DOCTYPE ");
+		oBuilder.WriteString(node->v.document.name);
+		std::string pi(node->v.document.public_identifier);
+		remove_control_symbols(pi);
+		if ((node->v.document.public_identifier != NULL) && !pi.empty())
+		{
+			oBuilder.WriteString(" PUBLIC \"");
+			oBuilder.WriteString(pi);
+			oBuilder.WriteString("\" \"");
+			oBuilder.WriteString(node->v.document.system_identifier);
+			oBuilder.WriteString("\"");
+		}
+		oBuilder.WriteString(">");
+	}
+}
+
+static void build_attributes(const GumboVector* attribs, NSStringUtils::CStringBuilderA& atts)
+{
+	std::vector<std::string> arrRepeat;
+	for (size_t i = 0; i < attribs->length; ++i)
+	{
+		GumboAttribute* at = static_cast<GumboAttribute*>(attribs->data[i]);
+		std::string sVal(at->value);
+		std::string sName(at->name);
+
+		remove_control_symbols(sVal);
+		remove_control_symbols(sName);
+
+		atts.WriteString(" ");
+
+		bool bCheck = false;
+		size_t nBad = sName.find_first_of("+,.=?#%<>&;\"\'()[]{}");
+		while(nBad != std::string::npos)
+		{
+			sName.erase(nBad, 1);
+			nBad = sName.find_first_of("+,.=?#%<>&;\"\'()[]{}", nBad);
+			if(sName.empty())
+				break;
+			bCheck = true;
+		}
+		if(sName.empty())
+			continue;
+		while(sName.front() >= '0' && sName.front() <= '9')
+		{
+			sName.erase(0, 1);
+			if(sName.empty())
+				break;
+			bCheck = true;
+		}
+		if(bCheck)
+		{
+			GumboAttribute* check = gumbo_get_attribute(attribs, sName.c_str());
+			if(check || std::find(arrRepeat.begin(), arrRepeat.end(), sName) != arrRepeat.end())
+				continue;
+			else
+				arrRepeat.push_back(sName);
+		}
+
+		if(sName.empty())
+			continue;
+		atts.WriteString(sName);
+
+		// determine original quote character used if it exists
+		std::string qs ="\"";
+		atts.WriteString("=");
+		atts.WriteString(qs);
+		substitute_xml_entities_into_attributes(sVal);
+		atts.WriteString(sVal);
+		atts.WriteString(qs);
+	}
+}
+
+static void prettyprint(GumboNode* node, NSStringUtils::CStringBuilderA& oBuilder, bool bCheckValidNode = true);
+
+static void prettyprint_contents(GumboNode* node, NSStringUtils::CStringBuilderA& contents, bool bCheckValidNode)
+{
+	std::string key             = "|" + get_tag_name(node) + "|";
+	bool keep_whitespace        = preserve_whitespace.find(key) != std::string::npos;
+	bool is_inline              = nonbreaking_inline.find(key) != std::string::npos;
+	bool is_like_inline         = treat_like_inline.find(key) != std::string::npos;
+
+	GumboVector* children = &node->v.element.children;
+
+	for (size_t i = 0; i < children->length; i++)
+	{
+		GumboNode* child = static_cast<GumboNode*> (children->data[i]);
+
+		if (child->type == GUMBO_NODE_TEXT)
+		{
+			std::string val(child->v.text.text);
+			remove_control_symbols(val);
+			substitute_xml_entities_into_text(val);
+
+			// Remove FF
+			size_t found = val.find_first_of("\014");
+			while(found != std::string::npos)
+			{
+				val.erase(found, 1);
+				found = val.find_first_of("\014", found);
+			}
+
+			contents.WriteString(val);
+		}
+		else if ((child->type == GUMBO_NODE_ELEMENT) || (child->type == GUMBO_NODE_TEMPLATE))
+			prettyprint(child, contents, bCheckValidNode);
+		else if (child->type == GUMBO_NODE_WHITESPACE)
+		{
+			if (keep_whitespace || is_inline || is_like_inline)
+				contents.WriteString(child->v.text.text);
+		}
+		else if (child->type != GUMBO_NODE_COMMENT)
+		{
+			// Error message
+			// Does this actually exist: (child->type == GUMBO_NODE_CDATA)
+			// fprintf(stderr, "unknown element of type: %d\n", child->type);
+		}
+	}
+}
+
+static void prettyprint(GumboNode* node, NSStringUtils::CStringBuilderA& oBuilder, bool bCheckValidNode)
+{
+	// special case the document node
+	if (node->type == GUMBO_NODE_DOCUMENT)
+	{
+		build_doctype(node, oBuilder);
+		prettyprint_contents(node, oBuilder, bCheckValidNode);
+		return;
+	}
+
+	std::string tagname            = get_tag_name(node);
+	remove_control_symbols(tagname);
+
+	if (NodeIsUnprocessed(tagname))
+		return;
+
+	if (bCheckValidNode)
+		bCheckValidNode = !IsUnckeckedNodes(tagname);
+
+	if (bCheckValidNode && html_tags.end() == std::find(html_tags.begin(), html_tags.end(), tagname))
+	{
+		prettyprint_contents(node, oBuilder, bCheckValidNode);
+		return;
+	}
+
+	std::string close              = "";
+	std::string closeTag           = "";
+	std::string key                = "|" + tagname + "|";
+	bool is_empty_tag              = empty_tags.find(key) != std::string::npos;
+
+	// determine closing tag type
+	if (is_empty_tag)
+		close = "/";
+	else
+		closeTag = "</" + tagname + ">";
+
+	// build results
+	oBuilder.WriteString("<" + tagname);
+
+	// build attr string
+	const GumboVector* attribs = &node->v.element.attributes;
+	build_attributes(attribs, oBuilder);
+	oBuilder.WriteString(close + ">");
+
+	// prettyprint your contents
+	prettyprint_contents(node, oBuilder, bCheckValidNode);
+	oBuilder.WriteString(closeTag);
+}
+
+std::wstring htmlToXhtml(std::string& sFileContent, bool bNeedConvert)
+{
+	if (bNeedConvert)
+	{ // Encoding detection
+		std::string sEncoding = NSStringFinder::FindProperty(sFileContent, "charset", {"="}, {";", "\\n", "\\r", " ", "\"", "'"}).m_sValue;
+
+		if (sEncoding.empty())
+			sEncoding = NSStringFinder::FindProperty(sFileContent, "encoding", {"="}, {";", "\\n", "\\r", " "}).m_sValue;
+
+		if (!sEncoding.empty() && !NSStringFinder::Equals("utf-8", sEncoding))
+		{
+			NSUnicodeConverter::CUnicodeConverter oConverter;
+			sFileContent = U_TO_UTF8(oConverter.toUnicode(sFileContent, sEncoding.c_str()));
+		}
+	}
+
+	// Remove extra characters before <...
+	boost::regex oRegex("<[a-zA-Z]");
+	boost::match_results<typename std::string::const_iterator> oResult;
+
+	if (boost::regex_search(sFileContent, oResult, oRegex))
+		sFileContent.erase(0, oResult.position());
+
+	//Remove <a ... />
+	while (NSStringFinder::RemoveEmptyTag(sFileContent, "a"));
+	//Remove <title ... />
+	while (NSStringFinder::RemoveEmptyTag(sFileContent, "title"));
+	//Remove <script ... />
+	while (NSStringFinder::RemoveEmptyTag(sFileContent, "script"));
+
+	// Gumbo
+	GumboOptions options = kGumboDefaultOptions;
+	GumboOutput* output = gumbo_parse_with_options(&options, sFileContent.data(), sFileContent.length());
+
+	// prettyprint
+	NSStringUtils::CStringBuilderA oBuilder;
+	prettyprint(output->document, oBuilder);
+
+	// Convert from string utf8 to wstring
+	return UTF8_TO_U(oBuilder.GetData());
+}
+
+std::wstring mhtToXhtml(std::string& sFileContent)
+{
+	sFileContent = mhtTohtml(sFileContent);
+
+	// Gumbo
+	GumboOptions options = kGumboDefaultOptions;
+	GumboOutput* output = gumbo_parse_with_options(&options, sFileContent.data(), sFileContent.length());
+
+	// prettyprint
+	NSStringUtils::CStringBuilderA oBuilder;
+	prettyprint(output->document, oBuilder);
+
+	// Convert from string utf8 to wstring
+	return UTF8_TO_U(oBuilder.GetData());
+}
+}

Common/3dParty/html/htmltoxhtml.h

@@ -2,636 +2,11 @@
 #define HTMLTOXHTML_H
 
 #include <string>
-#include <map>
-#include <cctype>
-#include <vector>
-#include <algorithm>
 
-#include "gumbo-parser/src/gumbo.h"
-#include "../../../DesktopEditor/common/File.h"
-#include "../../../DesktopEditor/common/Directory.h"
-#include "../../../DesktopEditor/common/StringBuilder.h"
-#include "../../../DesktopEditor/xml/include/xmlutils.h"
-#include "../../../UnicodeConverter/UnicodeConverter.h"
-#include "../../../HtmlFile2/src/StringFinder.h"
-
-static std::string nonbreaking_inline  = "|a|abbr|acronym|b|bdo|big|cite|code|dfn|em|font|i|img|kbd|nobr|s|small|span|strike|strong|sub|sup|tt|";
-static std::string empty_tags          = "|area|base|basefont|bgsound|br|command|col|embed|event-source|frame|hr|image|img|input|keygen|link|menuitem|meta|param|source|spacer|track|wbr|";
-static std::string preserve_whitespace = "|pre|textarea|script|style|";
-static std::string special_handling    = "|html|body|";
-static std::string no_entity_sub       = ""; //"|style|";
-static std::string treat_like_inline   = "|p|";
-
-static std::vector<std::string> html_tags = {"div","span","a","img","p","h1","h2","h3","h4","h5","h6",
-                                             "ul", "ol", "li","td","tr","table","thead","tbody","tfoot","th",
-                                             "br","form","input","button","section","nav","header","footer",
-                                             "main","figure","figcaption","strong","em","i", "b", "u","pre",
-                                             "code","blockquote","hr","script","link","meta","style","title",
-                                             "head","body","html","legend","optgroup","option","select","dl",
-                                             "dt","dd","time","data","abbr","address","area","base","bdi",
-                                             "bdo","cite","col","iframe","video","source","track","textarea",
-                                             "label","fieldset","colgroup","del","ins","details","summary",
-                                             "dialog","embed","kbd","map","mark","menu","meter","object",
-                                             "output","param","progress","q","samp","small","sub","sup","var",
-                                             "wbr","acronym","applet","article","aside","audio","basefont",
-                                             "bgsound","big","blink","canvas","caption","center","command",
-                                             "comment","datalist","dfn","dir","font","frame","frameset",
-                                             "hgroup","isindex","keygen","marquee","nobr","noembed","noframes",
-                                             "noscript","plaintext","rp","rt","ruby","s","strike","tt","xmp"};
-
-static std::vector<std::string> unchecked_nodes_new = {"svg"};
-
-static void prettyprint(GumboNode*, NSStringUtils::CStringBuilderA& oBuilder, bool bCheckValidNode = true);
-static std::string mhtTohtml(const std::string &sFileContent);
-
-// Заменяет в строке s все символы s1 на s2
-static void replace_all(std::string& s, const std::string& s1, const std::string& s2)
+namespace HTML
 {
-	size_t pos = s.find(s1);
-	while(pos != std::string::npos)
-	{
-		s.replace(pos, s1.length(), s2);
-		pos = s.find(s1, pos + s2.length());
-	}
-}
-
-static bool NodeIsUnprocessed(const std::string& wsTagName)
-{
-	return "xml" == wsTagName;
-}
-
-static bool IsUnckeckedNodes(const std::string& sValue)
-{
-	return unchecked_nodes_new.end() != std::find(unchecked_nodes_new.begin(), unchecked_nodes_new.end(), sValue);
-}
-
-static std::wstring htmlToXhtml(std::string& sFileContent, bool bNeedConvert)
-{
-	if (bNeedConvert)
-	{ // Определение кодировки
-		std::string sEncoding = NSStringFinder::FindPropety(sFileContent, "charset", {"="}, {";", "\\n", "\\r", " ", "\""}).m_sValue;
-
-		if (sEncoding.empty())
-			sEncoding = NSStringFinder::FindPropety(sFileContent, "encoding", {"="}, {";", "\\n", "\\r", " "}).m_sValue;
-
-		if (!sEncoding.empty() && !NSStringFinder::Equals("utf-8", sEncoding))
-		{
-			NSUnicodeConverter::CUnicodeConverter oConverter;
-			sFileContent = U_TO_UTF8(oConverter.toUnicode(sFileContent, sEncoding.c_str()));
-		}
-	}
-
-	// Избавляемся от лишних символов до <...
-	boost::regex oRegex("<[a-zA-Z]");
-	boost::match_results<typename std::string::const_iterator> oResult;
-
-	if (boost::regex_search(sFileContent, oResult, oRegex))
-		sFileContent.erase(0, oResult.position());
-
-	//Избавление от <a ... />
-	while (NSStringFinder::RemoveEmptyTag(sFileContent, "a"));
-	//Избавление от <title ... />
-	while (NSStringFinder::RemoveEmptyTag(sFileContent, "title"));
-	//Избавление от <script ... />
-	while (NSStringFinder::RemoveEmptyTag(sFileContent, "script"));
-
-	// Gumbo
-	GumboOptions options = kGumboDefaultOptions;
-	GumboOutput* output = gumbo_parse_with_options(&options, sFileContent.data(), sFileContent.length());
-
-	// prettyprint
-	NSStringUtils::CStringBuilderA oBuilder;
-	prettyprint(output->document, oBuilder);
-
-	// Конвертирование из string utf8 в wstring
-	return UTF8_TO_U(oBuilder.GetData());
-}
-
-static std::string Base64ToString(const std::string& sContent, const std::string& sCharset)
-{
-	std::string sRes;
-	int nSrcLen = (int)sContent.length();
-	int nDecodeLen = NSBase64::Base64DecodeGetRequiredLength(nSrcLen);
-	BYTE* pData = new BYTE[nDecodeLen];
-	if (TRUE == NSBase64::Base64Decode(sContent.c_str(), nSrcLen, pData, &nDecodeLen))
-	{
-		std::wstring sConvert;
-		if(!sCharset.empty() && NSStringFinder::Equals<std::string>("utf-8", sCharset))
-		{
-			NSUnicodeConverter::CUnicodeConverter oConverter;
-			sConvert = oConverter.toUnicode(reinterpret_cast<char *>(pData), (unsigned)nDecodeLen, sCharset.data());
-		}
-		sRes = sConvert.empty() ? std::string(reinterpret_cast<char *>(pData), nDecodeLen) : U_TO_UTF8(sConvert);
-	}
-	RELEASEARRAYOBJECTS(pData);
-	return sRes;
-}
-
-static std::string QuotedPrintableDecode(const std::string& sContent, std::string& sCharset)
-{
-	NSStringUtils::CStringBuilderA sRes;
-	size_t ip = 0;
-	size_t i  = sContent.find('=');
-
-	if(i == 0)
-	{
-		size_t nIgnore = 12;
-		std::string charset = sContent.substr(0, nIgnore);
-		if(charset == "=00=00=FE=FF")
-			sCharset = "UTF-32BE";
-		else if(charset == "=FF=FE=00=00")
-			sCharset = "UTF-32LE";
-		else if(charset == "=2B=2F=76=38" || charset == "=2B=2F=76=39" ||
-				charset == "=2B=2F=76=2B" || charset == "=2B=2F=76=2F")
-			sCharset = "UTF-7";
-		else if(charset == "=DD=73=66=73")
-			sCharset = "UTF-EBCDIC";
-		else if(charset == "=84=31=95=33")
-			sCharset = "GB-18030";
-		else
-		{
-			nIgnore -= 3;
-			charset.erase(nIgnore);
-			if(charset == "=EF=BB=BF")
-				sCharset = "UTF-8";
-			else if(charset == "=F7=64=4C")
-				sCharset = "UTF-1";
-			else if(charset == "=0E=FE=FF")
-				sCharset = "SCSU";
-			else if(charset == "=FB=EE=28")
-				sCharset = "BOCU-1";
-			else
-			{
-				nIgnore -= 3;
-				charset.erase(nIgnore);
-				if(charset == "=FE=FF")
-					sCharset = "UTF-16BE";
-				else if(charset == "=FF=FE")
-					sCharset = "UTF-16LE";
-				else
-					nIgnore -= 6;
-			}
-		}
-
-		ip = nIgnore;
-		i  = sContent.find('=', ip);
-	}
-
-	while(i != std::string::npos && i + 2 < sContent.length())
-	{
-		sRes.WriteString(sContent.c_str() + ip, i - ip);
-		std::string str = sContent.substr(i + 1, 2);
-		if(str.front() == '\n' || str.front() == '\r')
-		{
-			char ch = str[1];
-			if(ch != '\n' && ch != '\r')
-				sRes.WriteString(&ch, 1);
-		}
-		else
-		{
-			char* err;
-			char ch = (int)strtol(str.data(), &err, 16);
-			if(*err)
-				sRes.WriteString('=' + str);
-			else
-				sRes.WriteString(&ch, 1);
-		}
-		ip = i + 3;
-		i = sContent.find('=', ip);
-	}
-	if(ip != std::string::npos)
-		sRes.WriteString(sContent.c_str() + ip);
-	return sRes.GetData();
-}
-
-static void ReadMht(const std::string& sMhtContent, std::map<std::string, std::string>& sRes, NSStringUtils::CStringBuilderA& oRes)
-{
-	size_t unContentPosition = 0, unCharsetBegin = 0, unCharsetEnd = std::string::npos;
-
-	NSStringFinder::TFoundedData<char> oData;
-	
-	// Content-Type
-	oData =  NSStringFinder::FindPropety(sMhtContent, "content-type", {":"}, {";", "\\n", "\\r"});
-	const std::string sContentType{oData.m_sValue};
-
-	if (sContentType.empty())
-		return;
-	
-	if (NSStringFinder::Equals(sContentType, "multipart/alternative"))
-	{
-		oRes.WriteString(mhtTohtml(sMhtContent.substr(oData.m_unEndPosition, sMhtContent.length() - oData.m_unEndPosition)));
-		return;
-	}
-
-	unContentPosition = std::max(unContentPosition, oData.m_unEndPosition);
-	unCharsetBegin = oData.m_unEndPosition;
-
-	// name
-//	std::string sName = NSStringFinder::FindPropety(sMhtContent, "name", {"="}, {";", "\\n", "\\r"}, 0, unLastPosition);
-//	unContentPosition = std::max(unContentPosition, unLastPosition);
-
-	// Content-Location
-	oData = NSStringFinder::FindPropety(sMhtContent, "content-location", {":"}, {";", "\\n", "\\r"});
-	std::string sContentLocation{oData.m_sValue};
-
-	if (!oData.Empty())
-		unContentPosition = std::max(unContentPosition, oData.m_unEndPosition);
-
-	// Content-ID
-	oData = NSStringFinder::FindPropety(sMhtContent, "content-id", {":"}, {";", "\\n", "\\r"});
-	std::string sContentID{oData.m_sValue};
-
-	if (!oData.Empty())
-	{
-		unContentPosition = std::max(unContentPosition, oData.m_unEndPosition);
-		unCharsetEnd = std::min(unCharsetEnd, oData.m_unBeginPosition);
-		NSStringFinder::CutInside<std::string>(sContentID, "<", ">");
-	}
-
-	if (sContentLocation.empty() && !sContentID.empty())
-		sContentLocation = "cid:" + sContentID;
-
-	// Content-Transfer-Encoding
-	oData = NSStringFinder::FindPropety(sMhtContent, "content-transfer-encoding", {":"}, {";", "\\n", "\\r"});
-	const std::string sContentEncoding{oData.m_sValue};
-
-	if (!oData.Empty())
-	{
-		unContentPosition = std::max(unContentPosition, oData.m_unEndPosition);
-		unCharsetEnd = std::min(unCharsetEnd, oData.m_unBeginPosition);
-	}
-
-	// charset
-	std::string sCharset = "utf-8";
-
-	if (std::string::npos != unCharsetEnd && unCharsetBegin < unCharsetEnd)
-	{
-		sCharset = NSStringFinder::FindPropety(sMhtContent.substr(unCharsetBegin, unCharsetEnd - unCharsetBegin), "charset", {"="}, {";", "\\n", "\\r"}).m_sValue;
-		NSStringFinder::CutInside<std::string>(sCharset, "\"");
-	}
-
-	// Content
-	std::string sContent = sMhtContent.substr(unContentPosition, sMhtContent.length() - unContentPosition);
-
-//	std::wstring sExtention = NSFile::GetFileExtention(UTF8_TO_U(sName));
-//	std::transform(sExtention.begin(), sExtention.end(), sExtention.begin(), tolower);
-	// Основной документ
-	if (NSStringFinder::Equals(sContentType, "multipart/alternative"))
-		oRes.WriteString(mhtTohtml(sContent));
-	else if ((NSStringFinder::Find(sContentType, "text") /*&& (sExtention.empty() || NSStringFinder::EqualOf(sExtention, {L"htm", L"html", L"xhtml", L"css"}))*/) 
-	          || (NSStringFinder::Equals(sContentType, "application/octet-stream") && NSStringFinder::Find(sContentLocation, "css")))
-	{
-		// Стили заключаются в тэг <style>
-		const bool bAddTagStyle = NSStringFinder::Equals(sContentType, "text/css") /*|| NSStringFinder::Equals(sExtention, L"css")*/ || NSStringFinder::Find(sContentLocation, "css");
-
-		if (bAddTagStyle)
-			oRes.WriteString("<style>");
-
-		if (NSStringFinder::Equals(sContentEncoding, "base64"))
-			sContent = Base64ToString(sContent, sCharset);
-		else if (NSStringFinder::EqualOf(sContentEncoding, {"8bit", "7bit"}) || sContentEncoding.empty())
-		{
-			if (!NSStringFinder::Equals(sCharset, "utf-8") && !sCharset.empty())
-			{
-				NSUnicodeConverter::CUnicodeConverter oConverter;
-				sContent = U_TO_UTF8(oConverter.toUnicode(sContent, sCharset.data()));
-			}
-		}
-		else if (NSStringFinder::Equals(sContentEncoding, "quoted-printable"))
-		{
-			sContent = QuotedPrintableDecode(sContent, sCharset);
-			if (!NSStringFinder::Equals(sCharset, "utf-8") && !sCharset.empty())
-			{
-				NSUnicodeConverter::CUnicodeConverter oConverter;
-				sContent = U_TO_UTF8(oConverter.toUnicode(sContent, sCharset.data()));
-			}
-		}
-
-		if (NSStringFinder::Equals(sContentType, "text/html"))
-			sContent = U_TO_UTF8(htmlToXhtml(sContent, false));
-
-		oRes.WriteString(sContent);
-
-		if(bAddTagStyle)
-			oRes.WriteString("</style>");
-	}
-	// Картинки
-	else if ((NSStringFinder::Find(sContentType, "image") /*|| NSStringFinder::Equals(sExtention, L"gif")*/ || NSStringFinder::Equals(sContentType, "application/octet-stream")) && 
-			  NSStringFinder::Equals(sContentEncoding, "base64"))
-	{
-//		if (NSStringFinder::Equals(sExtention, L"ico") || NSStringFinder::Find(sContentType, "ico"))
-//			sContentType = "image/jpg";
-//		else if(NSStringFinder::Equals(sExtention, L"gif"))
-//			sContentType = "image/gif";
-		int nSrcLen = (int)sContent.length();
-		int nDecodeLen = NSBase64::Base64DecodeGetRequiredLength(nSrcLen);
-		BYTE* pData = new BYTE[nDecodeLen];
-		if (TRUE == NSBase64::Base64Decode(sContent.c_str(), nSrcLen, pData, &nDecodeLen))
-			sRes.insert(std::make_pair(sContentLocation, "data:" + sContentType + ";base64," + sContent));
-		RELEASEARRAYOBJECTS(pData);
-	}
-}
-
-static std::string mhtTohtml(const std::string& sFileContent)
-{
-	std::map<std::string, std::string> sRes;
-	NSStringUtils::CStringBuilderA oRes;
-
-	// Поиск boundary
-	NSStringFinder::TFoundedData<char> oData{NSStringFinder::FindPropety(sFileContent, "boundary", {"="}, {"\\r", "\\n", "\""})};
-
-	size_t nFound{oData.m_unEndPosition};
-	std::string sBoundary{oData.m_sValue};
-
-	if (sBoundary.empty())
-	{
-		size_t nFoundEnd = sFileContent.length();
-		nFound = 0;
-		ReadMht(sFileContent.substr(nFound, nFoundEnd), sRes, oRes);
-		return oRes.GetData();
-	}
-
-	NSStringFinder::CutInside<std::string>(sBoundary, "\"");
-
-	size_t nFoundEnd{nFound};
-
-	sBoundary = "--" + sBoundary;
-	size_t nBoundaryLength = sBoundary.length();
-
-	nFound = sFileContent.find(sBoundary, nFound) + nBoundaryLength;
-
-	// Цикл по boundary
-	while(nFound != std::string::npos)
-	{
-		nFoundEnd = sFileContent.find(sBoundary, nFound + nBoundaryLength);
-		if(nFoundEnd == std::string::npos)
-			break;
-
-		ReadMht(sFileContent.substr(nFound, nFoundEnd - nFound), sRes, oRes);
-
-		nFound = sFileContent.find(sBoundary, nFoundEnd);
-	}
-
-	std::string sFile = oRes.GetData();
-	for(const std::pair<std::string, std::string>& item : sRes)
-	{
-		std::string sName = item.first;
-		size_t found = sFile.find(sName);
-		size_t sfound = sName.rfind('/');
-		if(found == std::string::npos && sfound != std::string::npos)
-			found = sFile.find(sName.erase(0, sfound + 1));
-		while(found != std::string::npos)
-		{
-			size_t fq = sFile.find_last_of("\"\'>=", found);
-
-			if (std::string::npos == fq)
-				break;
-
-			char ch = sFile[fq];
-			if(ch != '\"' && ch != '\'')
-				fq++;
-			size_t tq = sFile.find_first_of("\"\'<> ", found) + 1;
-
-			if (std::string::npos == tq)
-				break;
-
-			if(sFile[tq] != '\"' && sFile[tq] != '\'')
-				tq--;
-			if(ch != '>')
-			{
-				std::string is = '\"' + item.second + '\"';
-				sFile.replace(fq, tq - fq, is);
-				found = sFile.find(sName, fq + is.length());
-			}
-			else
-				found = sFile.find(sName, tq);
-		}
-	}
-
-	return sFile;
-}
-
-static std::wstring mhtToXhtml(std::string& sFileContent)
-{
-	sFileContent = mhtTohtml(sFileContent);
-
-	// Gumbo
-	GumboOptions options = kGumboDefaultOptions;
-	GumboOutput* output = gumbo_parse_with_options(&options, sFileContent.data(), sFileContent.length());
-
-	// prettyprint
-	NSStringUtils::CStringBuilderA oBuilder;
-	prettyprint(output->document, oBuilder);
-
-	// Конвертирование из string utf8 в wstring
-	return UTF8_TO_U(oBuilder.GetData());
-}
-
-// Заменяет сущности &,<,> в text
-static void substitute_xml_entities_into_text(std::string& text)
-{
-	// replacing & must come first
-	replace_all(text, "&", "&amp;");
-	replace_all(text, "<", "&lt;");
-	replace_all(text, ">", "&gt;");
-}
-
-// Заменяет сущности " в text
-static void substitute_xml_entities_into_attributes(std::string& text)
-{
-	substitute_xml_entities_into_text(text);
-	replace_all(text, "\"", "&quot;");
-}
-
-static std::string handle_unknown_tag(GumboStringPiece* text)
-{
-	if (text->data == NULL)
-		return "";
-	GumboStringPiece gsp = *text;
-	gumbo_tag_from_original_text(&gsp);
-	std::string sAtr = std::string(gsp.data, gsp.length);
-	size_t found = sAtr.find_first_of("-'+,./=?;!*#@$_%<>&;\"\'()[]{}");
-	while(found != std::string::npos)
-	{
-		sAtr.erase(found, 1);
-		found = sAtr.find_first_of("-'+,./=?;!*#@$_%<>&;\"\'()[]{}", found);
-	}
-	return sAtr;
-}
-
-static std::string get_tag_name(GumboNode* node)
-{
-	std::string tagname = (node->type == GUMBO_NODE_DOCUMENT ? "document" : gumbo_normalized_tagname(node->v.element.tag));
-	if (tagname.empty())
-		tagname = handle_unknown_tag(&node->v.element.original_tag);
-	return tagname;
-}
-
-static void build_doctype(GumboNode* node, NSStringUtils::CStringBuilderA& oBuilder)
-{
-	if (node->v.document.has_doctype)
-	{
-		oBuilder.WriteString("<!DOCTYPE ");
-		oBuilder.WriteString(node->v.document.name);
-		std::string pi(node->v.document.public_identifier);
-		if ((node->v.document.public_identifier != NULL) && !pi.empty())
-		{
-			oBuilder.WriteString(" PUBLIC \"");
-			oBuilder.WriteString(pi);
-			oBuilder.WriteString("\" \"");
-			oBuilder.WriteString(node->v.document.system_identifier);
-			oBuilder.WriteString("\"");
-		}
-		oBuilder.WriteString(">");
-	}
-}
-
-static void build_attributes(const GumboVector* attribs, bool no_entities, NSStringUtils::CStringBuilderA& atts)
-{
-	std::vector<std::string> arrRepeat;
-	for (size_t i = 0; i < attribs->length; ++i)
-	{
-		GumboAttribute* at = static_cast<GumboAttribute*>(attribs->data[i]);
-		std::string sVal(at->value);
-		std::string sName(at->name);
-		atts.WriteString(" ");
-
-		bool bCheck = false;
-		size_t nBad = sName.find_first_of("+,.=?#%<>&;\"\'()[]{}");
-		while(nBad != std::string::npos)
-		{
-			sName.erase(nBad, 1);
-			nBad = sName.find_first_of("+,.=?#%<>&;\"\'()[]{}", nBad);
-			if(sName.empty())
-				break;
-			bCheck = true;
-		}
-		if(sName.empty())
-			continue;
-		while(sName.front() >= '0' && sName.front() <= '9')
-		{
-			sName.erase(0, 1);
-			if(sName.empty())
-				break;
-			bCheck = true;
-		}
-		if(bCheck)
-		{
-			GumboAttribute* check = gumbo_get_attribute(attribs, sName.c_str());
-			if(check || std::find(arrRepeat.begin(), arrRepeat.end(), sName) != arrRepeat.end())
-				continue;
-			else
-				arrRepeat.push_back(sName);
-		}
-
-		if(sName.empty())
-			continue;
-		atts.WriteString(sName);
-
-		// determine original quote character used if it exists
-		std::string qs ="\"";
-		atts.WriteString("=");
-		atts.WriteString(qs);
-		if(!no_entities)
-			substitute_xml_entities_into_attributes(sVal);
-		atts.WriteString(sVal);
-		atts.WriteString(qs);
-	}
-}
-
-static void prettyprint_contents(GumboNode* node, NSStringUtils::CStringBuilderA& contents, bool bCheckValidNode)
-{
-	std::string key             = "|" + get_tag_name(node) + "|";
-	bool no_entity_substitution = no_entity_sub.find(key) != std::string::npos;
-	bool keep_whitespace        = preserve_whitespace.find(key) != std::string::npos;
-	bool is_inline              = nonbreaking_inline.find(key) != std::string::npos;
-	bool is_like_inline         = treat_like_inline.find(key) != std::string::npos;
-
-	GumboVector* children = &node->v.element.children;
-
-	for (size_t i = 0; i < children->length; i++)
-	{
-		GumboNode* child = static_cast<GumboNode*> (children->data[i]);
-
-		if (child->type == GUMBO_NODE_TEXT)
-		{
-			std::string val(child->v.text.text);
-			if(!no_entity_substitution)
-				substitute_xml_entities_into_text(val);
-
-			// Избавление от FF
-			size_t found = val.find_first_of("\014");
-			while(found != std::string::npos)
-			{
-				val.erase(found, 1);
-				found = val.find_first_of("\014", found);
-			}
-
-			contents.WriteString(val);
-		}
-		else if ((child->type == GUMBO_NODE_ELEMENT) || (child->type == GUMBO_NODE_TEMPLATE))
-			prettyprint(child, contents, bCheckValidNode);
-		else if (child->type == GUMBO_NODE_WHITESPACE)
-		{
-			if (keep_whitespace || is_inline || is_like_inline)
-				contents.WriteString(child->v.text.text);
-		}
-		else if (child->type != GUMBO_NODE_COMMENT)
-		{
-			// Сообщение об ошибке
-			// Does this actually exist: (child->type == GUMBO_NODE_CDATA)
-			// fprintf(stderr, "unknown element of type: %d\n", child->type);
-		}
-	}
-}
-
-static void prettyprint(GumboNode* node, NSStringUtils::CStringBuilderA& oBuilder, bool bCheckValidNode)
-{
-	// special case the document node
-	if (node->type == GUMBO_NODE_DOCUMENT)
-	{
-		build_doctype(node, oBuilder);
-		prettyprint_contents(node, oBuilder, bCheckValidNode);
-		return;
-	}
-
-	std::string tagname            = get_tag_name(node);
-
-	if (NodeIsUnprocessed(tagname))
-		return;
-
-	if (bCheckValidNode)
-		bCheckValidNode = !IsUnckeckedNodes(tagname);
-
-	if (bCheckValidNode && html_tags.end() == std::find(html_tags.begin(), html_tags.end(), tagname))
-	{
-		prettyprint_contents(node, oBuilder, bCheckValidNode);
-		return;
-	}
-
-	std::string close              = "";
-	std::string closeTag           = "";
-	std::string key                = "|" + tagname + "|";
-	bool is_empty_tag              = empty_tags.find(key) != std::string::npos;
-	bool no_entity_substitution    = no_entity_sub.find(key) != std::string::npos;
-	
-	// determine closing tag type
-	if (is_empty_tag)
-		close = "/";
-	else
-		closeTag = "</" + tagname + ">";
-
-	// build results
-	oBuilder.WriteString("<" + tagname);
-
-	// build attr string
-	const GumboVector* attribs = &node->v.element.attributes;
-	build_attributes(attribs, no_entity_substitution, oBuilder);
-	oBuilder.WriteString(close + ">");
-
-	// prettyprint your contents
-	prettyprint_contents(node, oBuilder, bCheckValidNode);
-	oBuilder.WriteString(closeTag);
+std::wstring htmlToXhtml(std::string& sFileContent, bool bNeedConvert);
+std::wstring mhtToXhtml(std::string& sFileContent);
 }
 
 #endif // HTMLTOXHTML_H

Common/3dParty/hunspell/.gitignore

@@ -1,5 +1,2 @@
-emsdk/
 hunspell/
-deploy/
-o
 hunspell.data

Common/3dParty/hunspell/autogen/generate.py

@@ -0,0 +1,43 @@
+import os
+import glob
+import json
+import subprocess
+
+curDirectory = os.path.dirname(os.path.realpath(__file__))
+dictionatiesDirectory = curDirectory + "/../../../../../dictionaries"
+
+all_dictionaties = {}
+for dir in glob.glob(dictionatiesDirectory + "/*"):
+    if not os.path.isdir(dir):
+        continue
+    dictionaryName = os.path.basename(dir)
+    configFile = dictionatiesDirectory + "/" + dictionaryName + "/" + dictionaryName + ".json"
+    if not os.path.isfile(configFile):
+        continue
+    isHyphen = False
+    hyphenFile = dictionatiesDirectory + "/" + dictionaryName + "/hyph_" + dictionaryName + ".dic"
+    if os.path.isfile(hyphenFile):
+        isHyphen = True
+    with open(configFile, 'r', encoding='utf-8') as file:
+        data = json.loads(file.read())
+        for lang in data["codes"]:
+            all_dictionaties[str(lang)] = {
+                "name": dictionaryName,
+                "hyphen": isHyphen
+            }
+
+content = ""
+content += "#define DictionaryRec_count " + str(len(all_dictionaties)) + "\n"
+content += "typedef struct {\n"
+content += "    const char* m_name;\n"
+content += "    int         m_lang;\n"
+content += "} DictionaryRec;\n\n"
+content += "static const DictionaryRec Dictionaries[DictionaryRec_count] = {\n"
+
+for lang in all_dictionaties:
+    info = all_dictionaties[lang]
+    content += "    { \"" + info["name"] + "\", " + str(lang) + " },\n"
+content += "};\n"
+
+with open("./records.h", 'w', encoding='utf-8') as f:
+    f.write(content)

Common/3dParty/hunspell/autogen/records.h

@@ -0,0 +1,73 @@
+#define DictionaryRec_count 65
+typedef struct {
+    const char* m_name;
+    int         m_lang;
+} DictionaryRec;
+
+static const DictionaryRec Dictionaries[DictionaryRec_count] = {
+    { "ar", 1025 },
+    { "ar", 2049 },
+    { "ar", 3073 },
+    { "ar", 4097 },
+    { "ar", 5121 },
+    { "ar", 6145 },
+    { "ar", 7169 },
+    { "ar", 8193 },
+    { "ar", 9217 },
+    { "ar", 10241 },
+    { "ar", 11265 },
+    { "ar", 12289 },
+    { "ar", 13313 },
+    { "ar", 14337 },
+    { "ar", 15361 },
+    { "ar", 16385 },
+    { "az_Latn_AZ", 1068 },
+    { "bg_BG", 1026 },
+    { "ca_ES", 1027 },
+    { "ca_ES_valencia", 2051 },
+    { "cs_CZ", 1029 },
+    { "da_DK", 1030 },
+    { "de_AT", 3079 },
+    { "de_CH", 2055 },
+    { "de_DE", 1031 },
+    { "el_GR", 1032 },
+    { "en_AU", 3081 },
+    { "en_CA", 4105 },
+    { "en_GB", 2057 },
+    { "en_US", 1033 },
+    { "en_ZA", 7177 },
+    { "es_ES", 3082 },
+    { "eu_ES", 1069 },
+    { "fr_FR", 1036 },
+    { "gl_ES", 1110 },
+    { "hr_HR", 1050 },
+    { "hu_HU", 1038 },
+    { "id_ID", 1057 },
+    { "it_IT", 1040 },
+    { "kk_KZ", 1087 },
+    { "ko_KR", 1042 },
+    { "lb_LU", 1134 },
+    { "lt_LT", 1063 },
+    { "lv_LV", 1062 },
+    { "mn_MN", 1104 },
+    { "nb_NO", 1044 },
+    { "nl_NL", 1043 },
+    { "nl_NL", 2067 },
+    { "nn_NO", 2068 },
+    { "oc_FR", 1154 },
+    { "pl_PL", 1045 },
+    { "pt_BR", 1046 },
+    { "pt_PT", 2070 },
+    { "ro_RO", 1048 },
+    { "ru_RU", 1049 },
+    { "sk_SK", 1051 },
+    { "sl_SI", 1060 },
+    { "sr_Cyrl_RS", 10266 },
+    { "sr_Latn_RS", 9242 },
+    { "sv_SE", 1053 },
+    { "tr_TR", 1055 },
+    { "uk_UA", 1058 },
+    { "uz_Cyrl_UZ", 2115 },
+    { "uz_Latn_UZ", 1091 },
+    { "vi_VN", 1066 },
+};

Common/3dParty/hunspell/hunspell.json

@@ -1,49 +0,0 @@
-{
-	"name": "spell",
-	"res_folder": "./deploy/spell",
-	"wasm": true,
-	"asm": true,
-	"embed_mem_file": true,
-	"run_before": "before.py",
-	"run_after": "import sys;sys.path.append(\"../../../../build_tools/scripts\");import base;base.configure_common_apps();base.replaceInFile(\"./deploy/spell/spell.js\", \"__ATPOSTRUN__=[];\", \"__ATPOSTRUN__=[function(){self.onEngineInit();}];\");base.replaceInFile(\"./deploy/spell/spell.js\", \"function getBinaryPromise(){\", \"function getBinaryPromise2(){\");base.replaceInFile(\"./deploy/spell/spell_ie.js\", \"__ATPOSTRUN__=[];\", \"__ATPOSTRUN__=[function(){self.onEngineInit();}];\");base.replaceInFile(\"./deploy/spell/spell_ie.js\", \"function getBinaryPromise(){\", \"function getBinaryPromise2(){\");base.copy_file(\"./wasm/js/code.js\", \"./deploy/spell.js\");base.copy_file(\"./wasm/js/index.html\", \"./deploy/index.html\")",
-	"base_js_content": "./wasm/js/spell.js",
-
-	"compiler_flags": [
-		"-O3",
-		"-fno-exceptions",
-		"-fno-rtti",
-		"-Wno-unused-command-line-argument",
-		"-s ALLOW_MEMORY_GROWTH=1",
-		"-s FILESYSTEM=0",
-		"-s ENVIRONMENT='web,worker'"
-	],
-	"exported_functions": [
-		"_malloc",
-		"_free",
-		"_Spellchecker_Malloc",
-		"_Spellchecker_Free",
-		"_Spellchecker_Create",
-		"_Spellchecker_Destroy",
-		"_Spellchecker_AddDictionary",
-		"_Spellchecker_RemoveDicrionary",
-		"_Spellchecker_Load",
-		"_Spellchecker_Spell",
-		"_Spellchecker_Suggest",
-		"_Spellchecker_RemoveEngine",
-		"_Spellchecker_TotalAllocatedMemory"
-	],
-	"include_path": ["./hunspell/src/hunspell", "./wasm/src"],
-	"define": ["WIN32", "NDEBUG", "HUNSPELL_STATIC", "BUILDING_LIBHUNSPELL", "HUNSPELL_WASM_MODULE"],
-	"compile_files_array": [
-	{
-		"name": "h",
-		"folder": "./hunspell/src/hunspell/",
-		"files": ["affentry.cxx", "affixmgr.cxx", "csutil.cxx", "hashmgr.cxx", "hunspell.cxx", "hunzip.cxx", "phonet.cxx", "replist.cxx", "suggestmgr.cxx"]
-	},
-	{
-		"name": "s",
-		"folder": "./wasm/src/",
-		"files": ["filemgr_wrapper_new.cxx", "base.cpp"]
-	}
-	]
-}

Common/3dParty/hunspell/test/main.cpp

@@ -1,33 +1,36 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * Copyright (C) Ascensio System SIA, 2009-2026
  *
  * This program is a free software product. You can redistribute it and/or
  * modify it under the terms of the GNU Affero General Public License (AGPL)
- * version 3 as published by the Free Software Foundation. In accordance with
- * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
- * that Ascensio System SIA expressly excludes the warranty of non-infringement
- * of any third-party rights.
+ * version 3 as published by the Free Software Foundation, together with the
+ * additional terms provided in the LICENSE file.
  *
  * This program is distributed WITHOUT ANY WARRANTY; without even the implied
- * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
- * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
+ * details, see the GNU AGPL at: https://www.gnu.org/licenses/agpl-3.0.html
  *
- * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
- * street, Riga, Latvia, EU, LV-1050.
+ * You can contact Ascensio System SIA by email at info@onlyoffice.com
+ * or by postal mail at 20A-6 Ernesta Birznieka-Upisha Street, Riga,
+ * LV-1050, Latvia, European Union.
  *
- * The  interactive user interfaces in modified source and object code versions
- * of the Program must display Appropriate Legal Notices, as required under
+ * The interactive user interfaces in modified versions of the Program
+ * are required to display Appropriate Legal Notices in accordance with
  * Section 5 of the GNU AGPL version 3.
  *
- * Pursuant to Section 7(b) of the License you must retain the original Product
- * logo when distributing the program. Pursuant to Section 7(e) we decline to
- * grant you any rights under trademark law for use of our trademarks.
+ * No trademark rights are granted under this License.
  *
- * All the Product's GUI elements, including illustrations and icon sets, as
- * well as technical writing content are licensed under the terms of the
- * Creative Commons Attribution-ShareAlike 4.0 International. See the License
- * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ * All non-code elements of the Product, including illustrations,
+ * icon sets, and technical writing content, are licensed under the
+ * Creative Commons Attribution-ShareAlike 4.0 International License:
+ * https://creativecommons.org/licenses/by-sa/4.0/legalcode
  *
+ * This license applies only to such non-code elements and does not
+ * modify or replace the licensing terms applicable to the Program's
+ * source code, which remains licensed under the GNU Affero General
+ * Public License v3.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
  */
 
 #include "../../../../Common/3dParty/hunspell/hunspell/src/hunspell/hunspell.h"

Common/3dParty/hunspell/wasm/js/code.js

@@ -1,125 +0,0 @@
-function CSpellchecker(settings)
-{
-	useWasm = false;
-	var webAsmObj = window["WebAssembly"];
-	if (typeof webAsmObj === "object")
-	{
-		if (typeof webAsmObj["Memory"] === "function")
-		{
-			if ((typeof webAsmObj["instantiateStreaming"] === "function") || (typeof webAsmObj["instantiate"] === "function"))
-				useWasm = true;
-		}
-	}
-
-	var enginePath = "./spell/";
-	if (settings && settings.enginePath)
-	{
-		enginePath = settings.enginePath;
-		if (enginePath.substring(enginePath.length - 1) != "/")
-			enginePath += "/";
-	}
-
-	var dictionariesPath = "./../dictionaries";
-	if (settings && settings.dictionariesPath)
-	{
-		dictionariesPath = settings.dictionariesPath;
-		if (dictionariesPath.substring(dictionariesPath.length - 1) == "/")
-			dictionariesPath = dictionariesPath.substr(0, dictionariesPath.length - 1);
-	}
-
-	var isUseSharedWorker = !!window.SharedWorker;
-	if (isUseSharedWorker && (false === settings.useShared))
-		isUseSharedWorker = false;
-
-	var worker_src = useWasm ? "spell.js" : "spell_ie.js";
-	worker_src = enginePath + worker_src;
-
-	var _worker = this;
-	var _port = null;
-	if (isUseSharedWorker)
-	{
-		this.worker = new SharedWorker(worker_src, "onlyoffice-spellchecker");
-		_port = this.worker.port;
-	}
-	else
-	{
-		this.worker = new Worker(worker_src);
-		_port = this.worker;
-	}
-
-	this.languages = {
-		"1068" : "az_Latn_AZ",
-		"1026" : "bg_BG",
-		"1027" : "ca_ES",
-		"2051" : "ca_ES_valencia",
-		"1029" : "cs_CZ",
-		"1030" : "da_DK",
-		"3079" : "de_AT",
-		"2055" : "de_CH",
-		"1031" : "de_DE",
-		"1032" : "el_GR",
-		"3081" : "en_AU",
-		"4105" : "en_CA",
-		"2057" : "en_GB",
-		"1033" : "en_US",
-		"7177" : "en_ZA",
-		"3082" : "es_ES",
-		"1069" : "eu_ES",
-		"1036" : "fr_FR",
-		"1110" : "gl_ES",
-		"1050" : "hr_HR",
-		"1038" : "hu_HU",
-		"1057" : "id_ID",
-		"1040" : "it_IT",
-		"1087" : "kk_KZ",
-		"1042" : "ko_KR",
-		"1134" : "lb_LU",
-		"1063" : "lt_LT",
-		"1062" : "lv_LV",
-		"1104" : "mn_MN",
-		"1044" : "nb_NO",
-		"1043" : "nl_NL",
-		"2068" : "nn_NO",
-		"1045" : "pl_PL",
-		"1046" : "pt_BR",
-		"2070" : "pt_PT",
-		"1048" : "ro_RO",
-		"1049" : "ru_RU",
-		"1051" : "sk_SK",
-		"1060" : "sl_SI",
-		"10266" : "sr_Cyrl_RS",
-		"9242" : "sr_Latn_RS",
-		"1053" : "sv_SE",
-		"1055" : "tr_TR",
-		"1058" : "uk_UA",
-		"1066" : "vi_VN",
-		"2067" : "nl_NL" // nl_BE
-	};
-
-	_port.onmessage = function(message) {
-		_worker.oncommand && _worker.oncommand(message.data);
-	};
-	_port.postMessage({ "type" : "init", "dictionaries_path" : dictionariesPath, "languages" : this.languages });
-
-	this.stop = function()
-	{
-		this.worker.terminate();
-		this.worker = null;
-	};
-
-	this.command = function(message)
-	{
-		_port && _port.postMessage(message);
-	};
-	this.oncommand = function(message) { console.log(message); };
-
-	this.checkDictionary = function(lang) {
-		return (undefined !== this.languages["" + lang]) ? true : false;
-	};
-	this.getLanguages = function() {
-		var ret = [];
-		for (var lang in this.languages)
-			ret.push(lang);
-		return ret;
-	};
-}

Common/3dParty/hunspell/wasm/js/index.html

@@ -1,33 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-<meta charset="utf-8">
-<title>Demo of spellchecker</title>
-<meta name="viewport" content="width=device-width">
-<script src="./spell.js"></script>
-<script type="text/javascript">
-    window.spellcheck = new CSpellchecker({
-    	enginePath : "./spell",
-    	dictionariesPath : "./../dictionaries"
-    });
-
-	window.spellcheck.oncommand = function(message) {
-		console.log(message);
-	};
-	
-	window.spellcheck.command({
-		"type" : "spell",
-		"usrLang" : [1033, 1033, 1049],
-		"usrWords" : ["hello", "hellop", "привет"]
-	});
-
-	window.spellcheck.command({
-		"type" : "suggest",
-		"usrLang" : [1033],
-		"usrWords" : ["hellop"]
-	});
-  </script>
-</head>
-<body>
-</body>
-</html>

Common/3dParty/hunspell/wasm/js/spell.js

@@ -1,546 +0,0 @@
-var printErr = undefined;
-var FS = undefined;
-var print = undefined;
-
-var fetch = self.fetch;
-var getBinaryPromise = null;
-if (self.AscDesktopEditor && document.currentScript && 0 == document.currentScript.src.indexOf("file:///"))
-{
-    fetch = undefined; // fetch not support file:/// scheme
-    getBinaryPromise = function() {
-        var wasmPath = "ascdesktop://fonts/" + wasmBinaryFile.substr(8);
-        return new Promise(function (resolve, reject) {
-
-            var xhr = new XMLHttpRequest();
-            xhr.open('GET', wasmPath, true);
-            xhr.responseType = 'arraybuffer';
-
-            if (xhr.overrideMimeType)
-                xhr.overrideMimeType('text/plain; charset=x-user-defined');
-            else
-                xhr.setRequestHeader('Accept-Charset', 'x-user-defined');
-
-            xhr.onload = function () {
-                if (this.status == 200) {
-                    resolve(new Uint8Array(this.response));
-                }
-            };
-            xhr.send(null);
-        });
-    }
-}
-else
-{
-    getBinaryPromise = function() {
-        return getBinaryPromise2();
-    }
-}
-
-//polyfill
-
-//module
-
-self.spellchecker = null;
-function onMessageEvent(data, port)
-{
-    if (data.type == "init")
-    {
-        if (self.spellchecker)
-            return;
-        self.spellchecker = new Spellchecker();
-        self.spellchecker.languagesPath = data.dictionaries_path;
-        var languages = data.languages;
-        for (var i in languages)
-        	self.spellchecker.addDefaultLanguage(i, languages[i]);
-        self.spellchecker.init();
-        return;
-    }
-
-    if (!self.spellchecker)
-        return;
-
-    self.spellchecker.messages.push(data);
-    if (port)
-        self.spellchecker.ports.push(port);
-
-    if (1 < self.spellchecker.messages.length)
-    {
-        // значит еще грузим что-то
-        return;
-    }
-
-    self.spellchecker.checkMessage();
-}
-
-self.onconnect = function(e)
-{
-    var port = e.ports[0];
-    port.onmessage = function(e) {
-        onMessageEvent(e.data, port);
-    }    
-};
-self.onmessage = function(e)
-{
-    onMessageEvent(e.data);
-};
-self.engineInit = false;
-self.onEngineInit = function()
-{
-	self.engineInit = true;
-	if (self.spellchecker)
-	{
-		self.spellchecker.init();
-		self.spellchecker.checkMessage();
-	}
-};
-
-function Dictionary()
-{
-	this.dataAff = null;
-	this.dataDic = null;
-	this.status = 0;
-	this.id = 0;
-	this.language = null;
-
-	this.load_file = function(src, params)
-	{
-		var xhr = new XMLHttpRequest();
-		xhr.sender = this;
-		xhr.params = params;
-        xhr.open('GET', src, true);
-        xhr.responseType = 'arraybuffer';
-        if (xhr.overrideMimeType)
-            xhr.overrideMimeType('text/plain; charset=x-user-defined');
-        else
-            xhr.setRequestHeader('Accept-Charset', 'x-user-defined');
-
-        xhr.onload = function()
-        {
-        	if (xhr.sender.status >= 2)
-        		return;
-
-        	if (this.response && this.status == 200)
-            {
-                var uintData = new Uint8Array(this.response);
-                switch (this.params)
-                {
-                	case "aff":
-            		{
-            			this.sender.dataAff = uintData;
-            			break;
-            		}
-            		case "dic":
-            		{
-            			this.sender.dataDic = uintData;
-            			break;
-            		}
-            		default:
-            			break;
-                }
-                xhr.sender.status++;
-            }
-
-            if (xhr.sender.status == 2)
-            {
-            	self.spellchecker.onLoadDictionary(this.sender);
-            }
-        };
-        xhr.onerror = function()
-        {
-        	xhr.sender.status = 2;
-        	self.spellchecker.onLoadDictionary(this.sender);
-        };
-
-        xhr.send(null);
-	};
-
-	this.load = function()
-	{
-		if (!this.language)
-		{
-			this.status = 2;
-			self.spellchecker.onLoadDictionary(this);
-			return;
-		}
-		this.load_file(self.spellchecker.languagesPath + "/" + this.language.aff, "aff");
-		this.load_file(self.spellchecker.languagesPath + "/" + this.language.dic, "dic");
-	};
-
-	this.freeUnusedData = function()
-	{
-		this.dataAff = null;
-		this.dataDic = null;
-	};
-}
-
-
-function Spellchecker()
-{
-	this.languagesPath = "";
-	this.languages = {};
-	this.readyLanguages = {};
-	this.messages = [];
-	this.ports = [];
-	this.tmpStrings = new ArrayBuffer(1000);
-	this.engine = 0;
-
-	this.maxEngines = 3; 
-	this.maxDictionaries = 5;
-	this.languageQueue = [];
-
-	this.maxDictionariesHandler = function() 
-	{
-		if (this.languageQueue.length > this.maxDictionaries) 
-		{
-			var toDelete = this.languageQueue.length - this.maxDictionaries;
-			for (let i = 0; i < toDelete; i++) 
-			{
-				var lk = this.languageQueue[0];
-				this.deleteDictionaty(lk);
-				delete this.readyLanguages[lk];
-				this.languageQueue.shift();
-			}
-		}
-	};
-
-	this.deleteDictionaty = function(lk) 
-	{
-		if (!lk) 
-			return;
-
-		var affID = lk + ".aff";
-		var dicID = lk + ".dic"
-		var engineID = affID + dicID;
-		var engineIDptr = this.allocString(engineID);
-		var langAffptr = this.allocString(affID);
-		var langDicptr = this.allocString(dicID);
-		Module._Spellchecker_RemoveDicrionary(this.engine, langAffptr);
-		Module._Spellchecker_RemoveDicrionary(this.engine, langDicptr);
-		Module._Spellchecker_RemoveEngine(this.engine, engineIDptr);
-		this.freeString(engineIDptr);
-		this.freeString(langAffptr);
-		this.freeString(langDicptr);
-	};
-
-	this.init = function()
-	{
-		if (0 == this.engine && self.engineInit)
-			this.engine = this.createEngine();
-	};
-
-	this.addDefaultLanguage = function(id, path)
-	{
-		this.languages["" + id] = { 
-			aff : path + "/" + path + ".aff", 
-			dic : path + "/" + path + ".dic" 
-		};
-	};
-
-	this.onLoadDictionary = function(dictionary)
-	{
-		if (!dictionary.dataAff || !dictionary.dataDic)
-		{
-			this.checkMessage();
-			return;
-		}
-
-		var aff_path = this.allocString(dictionary.id + ".aff");
-		var dic_path = this.allocString(dictionary.id + ".dic");
-
-		var pointerAff = Module._Spellchecker_Malloc(dictionary.dataAff.length);
-    	Module.HEAP8.set(dictionary.dataAff, pointerAff);
-    	var pointerDic = Module._Spellchecker_Malloc(dictionary.dataDic.length);
-    	Module.HEAP8.set(dictionary.dataDic, pointerDic);
-
-    	Module._Spellchecker_AddDictionary(this.engine, aff_path, pointerAff, dictionary.dataAff.length);
-    	Module._Spellchecker_AddDictionary(this.engine, dic_path, pointerDic, dictionary.dataDic.length);
-
-		this.freeString(aff_path);
-		this.freeString(dic_path);
-
-		dictionary.freeUnusedData();
-
-		this.checkMessage();
-	};
-
-	this.checkMessage = function()
-	{
-		if (0 == this.messages.length || !self.engineInit)
-			return;
-
-		var m = this.messages[0];
-		var isReady = true;
-		for (var indexLang = 0, lenLangs = m.usrLang.length; indexLang < lenLangs; indexLang++)
-		{
-			var lang_key = "" + m.usrLang[indexLang];
-			var readyLang = this.readyLanguages[lang_key];
-			if (!readyLang)
-			{
-				// начнем грузить
-				var langToReady = new Dictionary();
-				langToReady.id = lang_key;
-				langToReady.language = this.languages[lang_key];
-				this.readyLanguages[lang_key] = langToReady;
-				this.languageQueue.push(lang_key); // push lang info into the queue
-				langToReady.load();
-
-				isReady = false;
-				break;
-			}
-			else if (readyLang.status != 2)
-			{
-				// ждем
-				isReady = false;
-				break;
-			}
-			else
-			{				
-				// все готово.
-				continue;	
-			}
-		}
-
-		if (!isReady)
-		{
-			// ждем
-			return;
-		}
-
-		switch (m.type)
-		{
-			case "spell":
-			{
-				this.Spell(m);
-				break;
-			}
-			case "suggest":
-			{
-				this.Suggest(m);
-				break;
-			}
-			default:
-				break;
-		}
-		this.maxDictionariesHandler();
-		this.messages.shift();
-	};
-
-	this.allocString = function(string)
-	{
-		var inputLen = string.length;
-		var testLen = 6 * inputLen + 1;
-		if (testLen > this.tmpStrings.byteLength)
-			this.tmpStrings = new ArrayBuffer(testLen);
-
-		var code = 0;
-		var index = 0;
-
-		var outputIndex = 0;
-		var outputDataTmp = new Uint8Array(this.tmpStrings);
-		var outputData = outputDataTmp;
-
-        while (index < inputLen)
-        {
-        	code = string.charCodeAt(index++);
-        	if (code >= 0xD800 && code <= 0xDFFF && index < inputLen)
-            {
-                code = 0x10000 + (((code & 0x3FF) << 10) | (0x03FF & string.charCodeAt(index++)));
-            }
-
-            if (code < 0x80)
-            {
-                outputData[outputIndex++] = code;
-            }
-            else if (code < 0x0800)
-            {
-                outputData[outputIndex++] = 0xC0 | (code >> 6);
-                outputData[outputIndex++] = 0x80 | (code & 0x3F);
-            }
-            else if (code < 0x10000)
-            {
-                outputData[outputIndex++] = 0xE0 | (code >> 12);
-                outputData[outputIndex++] = 0x80 | ((code >> 6) & 0x3F);
-                outputData[outputIndex++] = 0x80 | (code & 0x3F);
-            }
-            else if (code < 0x1FFFFF)
-            {
-                outputData[outputIndex++] = 0xF0 | (code >> 18);
-                outputData[outputIndex++] = 0x80 | ((code >> 12) & 0x3F);
-                outputData[outputIndex++] = 0x80 | ((code >> 6) & 0x3F);
-                outputData[outputIndex++] = 0x80 | (code & 0x3F);
-            }
-            else if (code < 0x3FFFFFF)
-            {
-                outputData[outputIndex++] = 0xF8 | (code >> 24);
-                outputData[outputIndex++] = 0x80 | ((code >> 18) & 0x3F);
-                outputData[outputIndex++] = 0x80 | ((code >> 12) & 0x3F);
-                outputData[outputIndex++] = 0x80 | ((code >> 6) & 0x3F);
-                outputData[outputIndex++] = 0x80 | (code & 0x3F);
-            }
-            else if (code < 0x7FFFFFFF)
-            {
-                outputData[outputIndex++] = 0xFC | (code >> 30);
-                outputData[outputIndex++] = 0x80 | ((code >> 24) & 0x3F);
-                outputData[outputIndex++] = 0x80 | ((code >> 18) & 0x3F);
-                outputData[outputIndex++] = 0x80 | ((code >> 12) & 0x3F);
-                outputData[outputIndex++] = 0x80 | ((code >> 6) & 0x3F);
-                outputData[outputIndex++] = 0x80 | (code & 0x3F);
-            }
-        }
-
-        outputData[outputIndex++] = 0;
-
-        var tmpBuffer = new Uint8Array(this.tmpStrings, 0, outputIndex);
-        var pointer = Module._Spellchecker_Malloc(outputIndex);
-    	Module.HEAP8.set(tmpBuffer, pointer);
-    	return pointer;
-	};
-	this.freeString = function(stringPointer)
-	{
-		Module._Spellchecker_Free(stringPointer);
-	};
-
-	this.readFromUtf8 = function(buffer, start, len)
-	{
-		var result = "";
-		var index = start;
-		var end = start + len;
-		while (index < end) 
-		{
-	        var u0 = buffer[index++];
-	        if (!(u0 & 128)) 
-	        {
-	          	result += String.fromCharCode(u0);
-	          	continue;
-	        }
-	        var u1 = buffer[index++] & 63;
-	        if ((u0 & 224) == 192) 
-	        {
-	          	result += String.fromCharCode((u0 & 31) << 6 | u1);
-	          	continue;
-	        }
-	        var u2 = buffer[index++] & 63;
-	        if ((u0 & 240) == 224) 
-	        {
-	          	u0 = (u0 & 15) << 12 | u1 << 6 | u2;
-	        } 
-	        else 
-	        {
-	          	u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | buffer[index++] & 63;
-	        }
-	        if (u0 < 65536) 
-	        {
-	          	result += String.fromCharCode(u0);
-	        } 
-	        else 
-	        {
-	          	var ch = u0 - 65536;
-	          	result += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
-	        }
-      	}
-      	return result;
-	};
-
-	this.readSuggests = function(pointer)
-	{
-		if (0 == pointer)
-			return [];
-
-		var lenArray = new Int32Array(Module["HEAP8"].buffer, pointer, 4);
-		var len = lenArray[0];
-		len -= 4;
-
-		var buffer = new Uint8Array(Module["HEAP8"].buffer, pointer + 4, len);
-		var index = 0;
-		var ret = [];
-		while (index < len)
-		{
-			var lenRec = buffer[index] | buffer[index + 1] << 8 | buffer[index + 2] << 16 | buffer[index + 3] << 24;
-			index += 4;
-			ret.push(this.readFromUtf8(buffer, index, lenRec));
-			index += lenRec;
-		}
-		return ret;
-	};
-
-	this.createEngine = function()
-	{
-		return Module._Spellchecker_Create(this.maxEngines);
-	};
-	this.destroyEngine = function()
-	{
-		Module._Spellchecker_Destroy();
-	};
-
-	this.Spell = function(data)
-	{
-		var len = Math.min(data.usrLang.length, data.usrWords.length);
-		if (0 == len)
-			return;
-		data.usrCorrect = new Array(len);
-		var curLang = "";		
-		for (var i = 0; i < len; i++)
-		{
-			if (curLang != ("" + data.usrLang[i]))
-			{
-				curLang = "" + data.usrLang[i];
-				var aff = this.allocString(curLang + ".aff");
-				var dic = this.allocString(curLang + ".dic");
-				ret = Module._Spellchecker_Load(this.engine, aff, dic);
-				this.freeString(aff);
-				this.freeString(dic);
-			}
-			var word = this.allocString(data.usrWords[i]);
-			data.usrCorrect[i] = (1 == Module._Spellchecker_Spell(this.engine, word)) ? true : false;
-			this.freeString(word);
-		}
-
-		this.sendAnswer(data);
-	};
-
-	this.Suggest = function(data)
-	{
-		var len = Math.min(data.usrLang.length, data.usrWords.length);
-		if (0 == len)
-			return;
-		data.usrSuggest = new Array(len);
-		var curLang = "";		
-		for (var i = 0; i < len; i++)
-		{
-			if (curLang != ("" + data.usrLang[i]))
-			{
-				curLang = "" + data.usrLang[i];
-				var aff = this.allocString(curLang + ".aff");
-				var dic = this.allocString(curLang + ".dic");
-
-				ret = Module._Spellchecker_Load(this.engine, aff, dic);
-
-				this.freeString(aff);
-				this.freeString(dic);
-			}
-			var word = this.allocString(data.usrWords[i]);
-			var pointerSuggests = Module._Spellchecker_Suggest(this.engine, word);
-			data.usrSuggest[i] = this.readSuggests(pointerSuggests);
-			this.freeString(word);
-		}
-
-		this.sendAnswer(data);
-	};
-
-	this.sendAnswer = function(data)
-	{
-		if (self.spellchecker.ports.length == 0)
-		{
-            self.postMessage(data);
-        }
-        else
-        {
-            var port = self.spellchecker.ports.shift();
-            port.postMessage(data);
-        }
-
-		setTimeout(function(){
-			self.spellchecker.checkMessage();
-		}, 1);
-	};
-}

Common/3dParty/hunspell/wasm/src/base.cpp

@@ -1,61 +0,0 @@
-#include "base.h"
-#include "engine.h"
-
-std::map<std::string, CFileMemory*> CSpellchecker::g_dictionaries;
-
-void* Spellchecker_Malloc(unsigned int size)
-{
-    return ::malloc(size);
-}
-void Spellchecker_Free(void* p)
-{
-    if (p)
-        ::free(p);
-}
-
-CSpellchecker* Spellchecker_Create(size_t max_engine_number)
-{
-    return new CSpellchecker(max_engine_number);
-}
-void Spellchecker_Destroy(CSpellchecker* p)
-{
-    delete p;
-}
-
-int Spellchecker_AddDictionary(CSpellchecker* p, const char* id, unsigned char* data, unsigned int size)
-{
-    if (!p)
-        return 0;
-    return p->AddDictionary(id, data, size);
-}
-void Spellchecker_RemoveDicrionary(CSpellchecker* p, const char* id)
-{
-    if (!p)
-        return;
-    p->RemoveDictionary(id);
-}
-
-int Spellchecker_Load(CSpellchecker* p, const char* aff_id, const char* dic_id)
-{
-    if (!p) return 0;
-    return p->Load(aff_id, dic_id);
-}
-int Spellchecker_Spell(CSpellchecker* p, const char* word_utf8)
-{
-    return  p->Spell(word_utf8);
-}
-unsigned char* Spellchecker_Suggest(CSpellchecker* p, const char* word_utf8)
-{;
-    return p->Suggest(word_utf8);
-}
-void Spellchecker_RemoveEngine(CSpellchecker* p, const char* sid) 
-{
-    p->RemoveEngine(sid);
-}
-
-double Spellchecker_TotalAllocatedMemory() 
-{	
-    struct mallinfo a;
-    a = mallinfo(); // Debug
-    return (double)a.uordblks / 1000. / 1000.;
-}

Common/3dParty/hunspell/wasm/src/base.h

@@ -1,22 +0,0 @@
-#include <memory>
-#include <malloc.h>
-class CSpellchecker;
-
-extern "C"
-{
-    void* Spellchecker_Malloc(unsigned int size);
-    void Spellchecker_Free(void* p);
-
-    CSpellchecker* Spellchecker_Create(size_t max_engine_number);
-    void Spellchecker_Destroy(CSpellchecker*);
-
-    int Spellchecker_AddDictionary(CSpellchecker* p, const char* sid, unsigned char* data, unsigned int size);
-    void Spellchecker_RemoveDicrionary(CSpellchecker* p, const char* sid);
-
-    int Spellchecker_Load(CSpellchecker* p, const char* aff_id, const char* dic_id);
-    int Spellchecker_Spell(CSpellchecker* p, const char* word_utf8);
-    void Spellchecker_RemoveEngine(CSpellchecker* p, const char* sid);
-    unsigned char* Spellchecker_Suggest(CSpellchecker* p, const char* word_utf8);
-
-    double Spellchecker_TotalAllocatedMemory(); //Debug
-}

Common/3dParty/hunspell/wasm/src/engine.h

@@ -1,355 +0,0 @@
-#include "hunspell.h"
-#include <iostream>
-#include <stdlib.h>
-#include "base.h"
-#include <map>
-#include <queue>
-#include <string>
-#include <memory.h>
-//#define WASM_LOGGING fprintf
-
-class CFileMemory
-{
-public:
-    unsigned char* data;
-    unsigned int len;
-
-public:
-    CFileMemory(unsigned char* _data = NULL, unsigned int _len = 0)
-    {
-        data = _data;
-        len = _len;
-    }
-    ~CFileMemory()
-    {
-        if (data)
-        {
-            Spellchecker_Free(data);
-            data = NULL;
-        }
-    }
-};
-
-class CSuggests
-{
-protected:
-    char*	m_pData;
-    size_t	m_lSize;
-
-    char*	m_pDataCur;
-    size_t	m_lSizeCur;
-
-public:
-    CSuggests()
-    {
-        m_pData = NULL;
-        m_lSize = 0;
-
-        m_pDataCur	= m_pData;
-        m_lSizeCur	= m_lSize;
-    }
-    CSuggests(const size_t& nLen)
-    {
-        m_lSize = nLen;
-        m_pData = (char*)malloc(m_lSize * sizeof(char));
-
-        m_lSizeCur = 0;
-        m_pDataCur = m_pData;
-    }
-    virtual ~CSuggests()
-    {
-        Clear();
-    }
-
-    inline void AddSize(const size_t& nSize)
-    {
-        if (NULL == m_pData)
-        {
-            m_lSize = 1000;
-            if (nSize > m_lSize)
-                m_lSize = nSize;
-
-            m_pData = (char*)malloc(m_lSize * sizeof(char));
-
-            m_lSizeCur = 0;
-            m_pDataCur = m_pData;
-            return;
-        }
-
-        if ((m_lSizeCur + nSize) > m_lSize)
-        {
-            while ((m_lSizeCur + nSize) > m_lSize)
-            {
-                m_lSize *= 2;
-            }
-
-            char* pRealloc = (char*)realloc(m_pData, m_lSize * sizeof(char));
-            if (NULL != pRealloc)
-            {
-                // реаллок сработал
-                m_pData		= pRealloc;
-                m_pDataCur	= m_pData + m_lSizeCur;
-            }
-            else
-            {
-                char* pMalloc = (char*)malloc(m_lSize * sizeof(char));
-                memcpy(pMalloc, m_pData, m_lSizeCur * sizeof(char));
-
-                free(m_pData);
-                m_pData		= pMalloc;
-                m_pDataCur	= m_pData + m_lSizeCur;
-            }
-        }
-    }
-
-public:
-    void AddInt(const unsigned int& value)
-    {
-        AddSize(4);
-        memcpy(m_pDataCur, &value, sizeof(unsigned int));
-        m_pDataCur += 4;
-        m_lSizeCur += 4;
-    }
-    void WriteString(const char* value, const unsigned int& len)
-    {
-        AddSize(len + 4);
-        memcpy(m_pDataCur, &len, sizeof(unsigned int));
-        m_pDataCur += 4;
-        m_lSizeCur += 4;
-        memcpy(m_pDataCur, value, len);
-        m_pDataCur += len;
-        m_lSizeCur += len;
-    }
-    unsigned char* GetBuffer()
-    {
-        return (unsigned char*)m_pData;
-    }
-
-    void Clear()
-    {
-        free(m_pData);
-
-        m_pData = NULL;
-        m_lSize = 0;
-
-        m_pDataCur	= m_pData;
-        m_lSizeCur	= 0;
-    }
-    void ClearNoAttack()
-    {
-        m_pDataCur	= m_pData;
-        m_lSizeCur	= 0;
-    }
-    unsigned int GetSize()
-    {
-        return (unsigned int)m_lSizeCur;
-    }
-
-    void SkipLen()
-    {
-        AddInt(0);
-    }
-    void WriteLen()
-    {
-        unsigned int len = (unsigned int)m_lSizeCur;
-        memcpy(m_pData, &len, sizeof(unsigned int));
-    }
-};
-
-class LimitedEngineMap 
-{
-public:
-    LimitedEngineMap(size_t _maxEngineNumer) 
-    {
-        m_nMaxEngineNumber = _maxEngineNumer;
-    }
-    ~LimitedEngineMap() 
-    {
-        for (std::pair<const std::string, Hunhandle*> &i : m_mapDictionariesEngines) 
-        {
-            Hunspell_destroy(i.second);
-        }
-        m_mapDictionariesEngines.clear();
-    }
-    std::map<std::string, Hunhandle*>::iterator find(const std::string &to_find) 
-    {
-        return m_mapDictionariesEngines.find(to_find);
-    }
-    std::map<std::string, Hunhandle*>::iterator end()
-    {
-        return m_mapDictionariesEngines.end();
-    }
-    std::pair<std::map<std::string, Hunhandle*>::iterator,bool> insert(const std::pair<std::string, Hunhandle*> &data) 
-    {
-        if (m_qEngineQueue.size() == m_nMaxEngineNumber)
-        { 
-            if (m_mapDictionariesEngines.find(m_qEngineQueue.front()) != 
-                m_mapDictionariesEngines.end()) 
-                {
-                    Hunspell_destroy(m_mapDictionariesEngines[m_qEngineQueue.front()]); 
-                    m_mapDictionariesEngines.erase(m_qEngineQueue.front());
-                    m_qEngineQueue.pop();
-                }
-            
-        }
-        m_qEngineQueue.push(data.first);
-        return m_mapDictionariesEngines.insert(data);
-    }
-    void RemoveEngine(const char* id) 
-    {
-        if (m_mapDictionariesEngines.find(id) == m_mapDictionariesEngines.end())
-        {
-            return;
-        }
-        std::queue<std::string> new_queue;;
-        Hunspell_destroy(m_mapDictionariesEngines[id]);
-        m_mapDictionariesEngines.erase(id);
-        while (!m_qEngineQueue.empty())
-        {
-            if (m_qEngineQueue.front() != id) 
-            {
-                new_queue.push(m_qEngineQueue.front());
-            }
-            m_qEngineQueue.pop();
-        }
-        m_qEngineQueue = new_queue;
-    }
-private:
-    std::map<std::string, Hunhandle*> m_mapDictionariesEngines; 
-    std::queue<std::string> m_qEngineQueue;
-    size_t m_nMaxEngineNumber;
-};
-
-class CSpellchecker
-{
-public:
-    static std::map<std::string, CFileMemory*> g_dictionaries;
-
-public:
-    LimitedEngineMap m_oDictionariesEngines;
-    std::string m_sCurrentDictionaryId;
-    Hunhandle* m_pCurrentDictionary;
-    CSuggests m_oSuggests;
-
-public:
-    CSpellchecker(size_t _MaxEngineNumber) :
-    m_oDictionariesEngines(_MaxEngineNumber)
-    {
-        m_sCurrentDictionaryId = "";
-        m_pCurrentDictionary = NULL;
-    }
-    ~CSpellchecker()
-    {
-        
-        m_pCurrentDictionary = NULL;
-
-        for (std::pair<const std::string, CFileMemory*> &i : g_dictionaries)
-        {
-            delete i.second;
-        }
-        g_dictionaries.clear();
-    }
-
-public:
-    int AddDictionary(const char*& id, unsigned char* data, unsigned int size)
-    {
-#ifdef WASM_LOGGING
-        WASM_LOGGING(stderr, "add dictionary: [%s, %d]\n", id, (int)size);
-#endif
-
-        RemoveDictionary(id);
-        g_dictionaries.insert(std::pair<std::string, CFileMemory*>(std::string(id), new CFileMemory(data, size)));
-        return 1;
-    }
-    void RemoveDictionary(const char*& id)
-    {
-        std::string sid(id);
-        std::map<std::string, CFileMemory*>::iterator iter = g_dictionaries.find(sid);
-        if (iter != g_dictionaries.end())
-        {
-            CFileMemory* file = iter->second;
-            g_dictionaries.erase(iter);
-            delete file;
-        }
-    }
-    static CFileMemory* Get(const char*& id)
-    {
-        std::map<std::string, CFileMemory*>::iterator iter = g_dictionaries.find(std::string(id));
-        if (iter == g_dictionaries.end())
-            return NULL;
-        return iter->second;
-    }
-
-    int Load(const char*& aff_id, const char*& dic_id)
-    {
-#ifdef WASM_LOGGING
-        WASM_LOGGING(stderr, "load: [%s, %s]\n", aff_id, dic_id);
-#endif
-        return (NULL != SetLanguage(aff_id, dic_id)) ? 1 : 0;
-    }
-    int Spell(const char*& word)
-    {
-#ifdef WASM_LOGGING
-        WASM_LOGGING(stderr, "spell: [%s]\n", word);
-#endif
-        if (!m_pCurrentDictionary)
-            return 0;
-        return Hunspell_spell(m_pCurrentDictionary, word);
-    }
-    unsigned char* Suggest(const char*& word)
-    {
-#ifdef WASM_LOGGING
-        WASM_LOGGING(stderr, "suggest: [%s]\n", word);
-#endif
-        if (!m_pCurrentDictionary)
-            return NULL;
-
-        char** pSuggest;
-        int nSuggestCount = Hunspell_suggest(m_pCurrentDictionary, &pSuggest, word);
-
-        m_oSuggests.ClearNoAttack();
-        m_oSuggests.SkipLen();
-
-        for (int i = 0; i < nSuggestCount; ++i)
-        {
-            m_oSuggests.WriteString(pSuggest[i], (unsigned int)strlen(pSuggest[i]));
-        }
-
-        m_oSuggests.WriteLen();
-
-        if (0 < nSuggestCount)
-            Hunspell_free_list(m_pCurrentDictionary, &pSuggest, nSuggestCount);
-
-        return m_oSuggests.GetBuffer();
-    }
-    void RemoveEngine(const char* id) 
-    {
-        m_oDictionariesEngines.RemoveEngine(id);
-		if (m_sCurrentDictionaryId == id)
-		{
-			m_sCurrentDictionaryId = "";
-			m_pCurrentDictionary = NULL;
-		}
-    }
-protected:
-    Hunhandle* SetLanguage(const std::string& aff_id, const std::string& dic_id)
-    {
-        if ((aff_id + dic_id) == m_sCurrentDictionaryId)
-            return m_pCurrentDictionary;
-       
-        m_sCurrentDictionaryId = aff_id + dic_id;
-        m_pCurrentDictionary = NULL;
-
-        std::map<std::string, Hunhandle*>::iterator iterEngine = m_oDictionariesEngines.find(m_sCurrentDictionaryId);
-        if (iterEngine != m_oDictionariesEngines.end())
-        {
-            m_pCurrentDictionary = iterEngine->second;
-            return m_pCurrentDictionary;
-        }
-
-        Hunhandle* pDictionary = Hunspell_create(aff_id.c_str(), dic_id.c_str());
-        m_oDictionariesEngines.insert(std::pair<std::string, Hunhandle*>(m_sCurrentDictionaryId, pDictionary));
-        m_pCurrentDictionary = pDictionary;
-        return m_pCurrentDictionary;
-    }
-};

Common/3dParty/hunspell/wasm/src/filemgr_wrapper.cxx

@@ -1,58 +0,0 @@
-#include "license.hunspell"
-#include "license.myspell"
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "filemgr.hxx"
-#include "csutil.hxx"
-
-#include "./engine.h"
-
-int FileMgr::fail(const char * err, const char * par) {
-    fprintf(stderr, err, par);
-    return -1;
-}
-
-FileMgr::FileMgr(const char * file, const char * key)
-    : hin(NULL), fin(NULL), linenum(0)
-{
-    in[0] = '\0';
-
-    CFileMemory* file_memory = CSpellchecker::Get(file);
-    if (!file_memory)
-    {
-        fail(MSG_OPEN, file);
-    }
-    else
-    {
-        index = 0;
-        size = file_memory->len;
-        memory = (char*)file_memory->data;
-    }
-}
-
-FileMgr::~FileMgr()
-{
-    if (fin) fclose(fin);
-    if (hin) delete hin;
-}
-
-char * FileMgr::getline() {
-    if(index >= size)
-        return NULL;
-    int i = 0,
-        l = BUFSIZE -1;
-    for(;index < size && memory[index] != '\n' && memory[index] != EOF && i <= l; index++, i++)
-        in[i] = memory[index];
-    in[i] = '\0';
-    index++;
-    if(index < size)
-        linenum++;
-    return strdup(in);
-}
-
-int FileMgr::getlinenum() {
-    return linenum;
-}

Common/3dParty/hunspell/wasm/src/filemgr_wrapper_new.cxx

@@ -1,52 +0,0 @@
-//#include "license.hunspell"
-//#include "license.myspell"
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "./filemgr.hxx"
-#include "csutil.hxx"
-
-#include "./engine.h"
-
-int FileMgr::fail(const char *err, const char *par)
-{
-    fprintf(stderr, err, par);
-    return -1;
-}
-
-FileMgr::FileMgr(const char *file, const char *key)
-    : hin(NULL), linenum(0), memin(NULL)
-{
-    in[0] = '\0';
-
-    CFileMemory *file_memory = CSpellchecker::Get(file);
-    if (!file_memory)
-    {
-        fail(MSG_OPEN, file);
-    }
-    else
-    {
-        memin.from_buffer((char *)file_memory->data, file_memory->len);
-    }
-}
-
-FileMgr::~FileMgr()
-{
-    if (hin)
-        delete hin;
-}
-
-bool FileMgr::getline(std::string &dest)
-{
-	bool ret = memin.get_line(dest);
-	if (ret)
-		++linenum;	
-    return ret;
-}
-
-int FileMgr::getlinenum()
-{
-    return linenum;
-}

Common/3dParty/hunspell/wasm/src/main.cpp

@@ -1,37 +0,0 @@
-#include "./base.h"
-#include <iostream>
-
-int main()
-{
-    CSpellchecker* spell = Spellchecker_Create(100);
-
-    FILE* fAff = fopen("en_GB.aff", "rb");
-    fseek(fAff, 0, SEEK_END);
-    unsigned int nAffSize = (unsigned int)ftell(fAff);
-    fseek(fAff, 0, SEEK_SET);
-    unsigned char* pAffData = (unsigned char*)Spellchecker_Malloc(nAffSize);
-    size_t nAffSizeRead = fread((void*)pAffData, 1, (size_t)nAffSize, fAff);
-    fclose(fAff);
-
-    FILE* fDic = fopen("en_GB.dic", "rb");
-    fseek(fDic, 0, SEEK_END);
-    unsigned int nDicSize = (unsigned int)ftell(fDic);
-    fseek(fDic, 0, SEEK_SET);
-    unsigned char* pDicData = (unsigned char*)Spellchecker_Malloc(nDicSize);
-    size_t nDicSizeRead = fread((void*)pDicData, 1, (size_t)nDicSize, fDic);
-    fclose(fDic);
-
-    int bIsAdd1 = Spellchecker_AddDictionary(spell, "en_US.aff", pAffData, nAffSize);
-    int bIsAdd2 = Spellchecker_AddDictionary(spell, "en_US.dic", pDicData, nDicSize);
-    while(1) {
-        Spellchecker_Load(spell, "en_US.aff", "en_US.dic");
-        Spellchecker_RemoveEngine(spell, "en_US.affen_US.dic");
-        std::cout << Spellchecker_Debug() << std::endl;
-    }
-
-    // int nCheck1 = Spellchecker_Spell(spell, "hello");
-    // int nCheck2 = Spellchecker_Spell(spell, "hellop");
-    // unsigned char* pSuggestData = Spellchecker_Suggest(spell, "hellop");
-    Spellchecker_Destroy(spell);
-    return 0;
-}

Common/3dParty/hunspell/wasm/src/string_buffer_stream.h

@@ -1,50 +0,0 @@
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-class string_buffer_stream
-{
-private:
-	char* m_buffer;
-	unsigned int m_pos;
-	unsigned int m_size;
-	
-public:
-	string_buffer_stream(char* buf = NULL, unsigned int len = 0)
-	{
-		m_buffer = buf;
-		m_pos = 0;
-		m_size = len;
-	}
-	void from_buffer(char* buf, unsigned int len)
-	{
-		m_buffer = buf;
-		m_pos = 0;
-		m_size = len;
-	}
-	
-	// emulate
-	// https://en.cppreference.com/w/cpp/string/basic_string/getline
-	bool get_line(std::string& data)
-	{
-		data.erase();
-		
-		if (m_pos >= m_size)
-			return false;
-		
-		while (m_pos < m_size)
-		{
-			char c = m_buffer[m_pos++];
-			if (c == '\n')
-				break;
-			if (c == '\r')
-			{
-				if (m_pos < m_size && m_buffer[m_pos] == '\n')
-					++m_pos;				
-				break;
-			}
-			data += c;
-		}
-		return true;
-	}
-};

Common/3dParty/hyphen/js/hyphen_build/after.py

@@ -1,14 +0,0 @@
-import sys
-sys.path.append("../../../../../../build_tools/scripts")
-import base
-
-base.configure_common_apps()
-base.replaceInFile("../deploy/engine/hyphen.js", "__ATPOSTRUN__=[];", "__ATPOSTRUN__=[onLoadModule];")
-base.replaceInFile("../deploy/engine/hyphen_ie.js", "__ATPOSTRUN__=[];", "__ATPOSTRUN__=[onLoadModule];")
-base.replaceInFile("../deploy/engine/hyphen.js", "__ATPOSTRUN__ = [];", "__ATPOSTRUN__=[onLoadModule];")
-base.replaceInFile("../deploy/engine/hyphen_ie.js", "__ATPOSTRUN__ = [];", "__ATPOSTRUN__=[onLoadModule];")
-
-base.replaceInFile("../deploy/engine/hyphen.js", "function getBinaryPromise()", "function getBinaryPromise2()")
-base.replaceInFile("../deploy/engine/hyphen_ie.js", "function getBinaryPromise()", "function getBinaryPromise2()")
-
-base.copy_file("../library.js", "../deploy/hyphen.js")

Common/3dParty/hyphen/js/hyphen_build/hyphen.json

@@ -1,40 +0,0 @@
-{
-	"name": "hyphen",
-	"res_folder": "../deploy/engine",
-	"wasm": true,
-	"asm": true,
-	"embed_mem_file": true,
-	"run_before": "",
-	"run_after": "after.py",
-	"base_js_content": "../module.js",
-
-	"compiler_flags": [
-		"-O3",
-		"-fno-exceptions",
-		"-fno-rtti",
-		"-Wno-unused-command-line-argument",
-		"-sALLOW_MEMORY_GROWTH"
-	],
-	"exported_functions": [
-		"_malloc",
-		"_free",
-		"_hyphenCreateApplication",
-		"_hyphenDestroyApplication",
-		"_hyphenLoadDictionary",
-		"_hyphenWord"
-	],
-	"include_path": ["../src"],
-	"define": ["GRAPHICS_NO_USE_DYNAMIC_LIBRARY", "HYPHEN_ENGINE_DISABLE_FILESYSTEM"],
-	"compile_files_array": [
-	{
-		"name": "h_e",
-		"folder": "../../../../../DesktopEditor/fontengine",
-		"files": ["TextHyphen.cpp"]
-	},
-	{
-		"name": "h_m",
-		"folder": "../src",
-		"files": ["hyphen.cpp"]
-	}
-	]
-}

Common/3dParty/hyphen/js/library.js

@@ -1,43 +0,0 @@
-(function(window) {
-
-	window.hyphen = window.hyphen || {};
-	window.hyphen.isReady = false;
-
-	var not_ready = function() {
-		console.log('Module is not ready');
-	}
-
-	window.hyphen.destroyApplication = not_ready;
-	window.hyphen.loadDictionary = not_ready;
-	window.hyphen.hyphenWord = not_ready;
-
-	window.hyphen.onLoadModule = function(exports) {
-		window.hyphen.isReady = true;
-
-		window.hyphen.destroyApplication = exports.destroyApplication;
-		window.hyphen.loadDictionary = exports.loadDictionary;
-		window.hyphen.hyphenWord = exports.hyphenWord;
-	};
-
-	window.hyphen.loadModule = function() {
-		var path = '../deploy/engine/';
-
-		// wasm support check
-		var useWasm = false;
-		const webAsmObj = window['WebAssembly'];
-		if (typeof webAsmObj === 'object') {
-			if (typeof webAsmObj['Memory'] === 'function') {
-				if ((typeof webAsmObj['instantiateStreaming'] === 'function') || (typeof webAsmObj['instantiate'] === 'function')) {
-					useWasm = true;
-				}
-			}
-		}
-		path += (useWasm ? 'hyphen.js' : 'hyphen_ie.js');
-
-		const script = document.createElement('script');
-		script.type = 'text/javascript';
-		script.src = path;
-		document.head.appendChild(script);
-
-	}
-})(self);

Common/3dParty/hyphen/js/module.js

@@ -1,81 +0,0 @@
-(function(window) {
-
-	var isModuleLoaded = false;
-	var application;
-
-	function onLoadModule() {
-		isModuleLoaded = true;
-		application = Module._hyphenCreateApplication();
-		if (window.hyphen) {			
-			window.hyphen.onLoadModule && window.hyphen.onLoadModule({
-				destroyApplication: function() {
-					Module._hyphenDestroyApplication(application);
-				},
-				loadDictionary: hyphenLoadDictionary,
-				hyphenWord: hyphenWord
-			});
-		}
-	};
-
-	//desktop_fetch
-
-	//polyfill
-
-	//string_utf8
-
-	//module
-
-	/**
-	 * 
-	 * @param {Number} app 
-	 * @param {Number} lang
-	 * @param {arraybuffer} dict
-	 * @returns {Boolean} isSuccess
-	 */
-	function hyphenLoadDictionary(lang, dict) 
-	{
-		if (!isModuleLoaded)
-			return;
-
-		let dictSize = dict.byteLength;
-		let dictPointer = Module._malloc(dictSize);
-		Module.HEAP8.set(new Uint8ClampedArray(dict), dictPointer);
-
-		let result = Module._hyphenLoadDictionary(application, lang, dictPointer, dictSize);
-
-		Module._free(dictPointer);
-		
-		return (result === 0) ? true : false;
-	}
-
-	/**
-	 * 
-	 * @param {Number} lang 
-	 * @param {String} word 
-	 * @returns {Array}
-	 * Returns hyphen vector of word
-	 */
-	function hyphenWord(lang, word) 
-	{
-		if (!isModuleLoaded)
-			return;
-
-		let wordPointer = word.toUtf8Pointer();
-		let wordLen = wordPointer.length;
-		let hyphens = [];
-
-		if (wordPointer) 
-		{
-			const ptr = Module._hyphenWord(application, lang, wordPointer.ptr, wordLen);
-			wordPointer.free();
-
-			let vector = new Uint8ClampedArray(Module.HEAP8.buffer, ptr, wordLen + 5);
-			for (let i = 0; vector[i] != 0; i++) 
-			{
-				if (1 == (vector[i] & 1))
-					hyphens.push((i + 1));
-			}
-		}
-		return hyphens;
-	}
-})(self);

Common/3dParty/hyphen/js/src/hyphen.cpp

@@ -1,68 +0,0 @@
-/*
- * (c) Copyright Ascensio System SIA 2010-2023
- *
- * This program is a free software product. You can redistribute it and/or
- * modify it under the terms of the GNU Affero General Public License (AGPL)
- * version 3 as published by the Free Software Foundation. In accordance with
- * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
- * that Ascensio System SIA expressly excludes the warranty of non-infringement
- * of any third-party rights.
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the implied
- * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
- * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
- *
- * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
- * street, Riga, Latvia, EU, LV-1050.
- *
- * The  interactive user interfaces in modified source and object code versions
- * of the Program must display Appropriate Legal Notices, as required under
- * Section 5 of the GNU AGPL version 3.
- *
- * Pursuant to Section 7(b) of the License you must retain the original Product
- * logo when distributing the program. Pursuant to Section 7(e) we decline to
- * grant you any rights under trademark law for use of our trademarks.
- *
- * All the Product's GUI elements, including illustrations and icon sets, as
- * well as technical writing content are licensed under the terms of the
- * Creative Commons Attribution-ShareAlike 4.0 International. See the License
- * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
- *
- */
-#include "../../../../../DesktopEditor/fontengine/TextHyphen.h"
-
-#ifdef _WIN32
-#define WASM_EXPORT __declspec(dllexport)
-#else
-#define WASM_EXPORT __attribute__((visibility("default")))
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-WASM_EXPORT NSHyphen::CEngine* hyphenCreateApplication()
-{
-	return new NSHyphen::CEngine();
-}
-WASM_EXPORT void hyphenDestroyApplication(NSHyphen::CEngine* app)
-{
-	delete app;
-}
-
-WASM_EXPORT int hyphenLoadDictionary(NSHyphen::CEngine* app, const int lang, const char *dict, const unsigned int dict_size)
-{
-	return app->LoadDictionary(lang, (const unsigned char*)dict, dict_size);
-}
-WASM_EXPORT int hyphenCheckDictionary(NSHyphen::CEngine* app, const int lang)
-{
-	return app->IsDictionaryExist(lang) ? 1 : 0;
-}
-WASM_EXPORT char* hyphenWord(NSHyphen::CEngine* app, const int lang, const char *word, const int word_len)
-{
-	return app->Process(lang, word, word_len);
-}
-
-#ifdef __cplusplus
-}
-#endif

Common/3dParty/hyphen/js/test/index.html

@@ -1,52 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-	<head>
-		<meta charset="UTF-8">
-		<title>test</title>
-		<link rel="stylesheet" href="styles.css">
-	</head>
-	<body>
-		<form>
-			<textarea id = "textarea"></textarea>
-			<button type = "submit">OK</button>
-			<select name  = "combobox" id = "combobox">
-			<option></option>
-			<option value = "bg_BG">bg_BG</option>
-			<option value = "ca_ES">ca_ES</option>
-			<option value = "da_DK">da_DK</option>
-			<option value = "de_AT">de_AT</option>
-			<option value = "de_CH">de_CH</option>
-			<option value = "de_DE">de_DE</option>
-			<option value = "el_GR">el_GR</option>
-			<option value = "en_AU">en_AU</option>
-			<option value = "en_GB">en_GB</option>
-			<option value = "en_US">en_US</option>
-			<option value = "es_ES">es_ES</option>
-			<option value = "fr_FR">fr_FR</option>
-			<option value = "gl_ES">gl_ES</option>
-			<option value = "hr_HR">hr_HR</option>
-			<option value = "hu_HU">hu_HU</option>
-			<option value = "id_ID">id_ID</option>
-			<option value = "it_IT">it_IT</option>
-			<option value = "lv_LV">lv_LV</option>
-			<option value = "mn_MN">mn_MN</option>
-			<option value = "nb_NO">nb_NO</option>
-			<option value = "nl_NL">nl_NL</option>
-			<option value = "nn_NO">nn_NO</option>
-			<option value = "pl_PL">pl_PL</option>
-			<option value = "pt_BR">pt_BR</option>
-			<option value = "pt_PT">pt_PT</option>
-			<option value = "ro_RO">ro_RO</option>
-			<option value = "ru_RU">ru_RU</option>
-			<option value = "sk_SK">sk_SK</option>
-			<option value = "sl_SI">sl_SI</option>
-			<option value = "sr_Cyrl_RS">sr_Cyrl_RS</option>
-			<option value = "sr_Latn_RS">sr_Latn_RS</option>
-			<option value = "sv_SE">sv_SE</option>
-			<option value = "uk_UA">uk_UA</option>
-			</select>
-		</form>
-		<script src = "../deploy/hyphen.js"></script>
-		<script src = "main.js"></script>
-	</body>
-</html>

Common/3dParty/hyphen/js/test/main.js

@@ -1,117 +0,0 @@
-(function (window, undefined) {
-
-    window.hyphen.loadModule();
-
-    var langs = {
-        "az_Latn_AZ"     : 1068,
-        "bg_BG"          : 1026,
-        "ca_ES"          : 1027,
-        "ca_ES_valencia" : 2051,
-        "cs_CZ"          : 1029,
-        "da_DK"          : 1030,
-        "de_AT"          : 3079,
-        "de_CH"          : 2055,
-        "de_DE"          : 1031,
-        "el_GR"          : 1032,
-        "en_AU"          : 3081,
-        "en_CA"          : 4105,
-        "en_GB"          : 2057,
-        "en_US"          : 1033,
-        "en_ZA"          : 7177,
-        "es_ES"          : 3082,
-        "eu_ES"          : 1069,
-        "fr_FR"          : 1036,
-        "gl_ES"          : 1110,
-        "hr_HR"          : 1050,
-        "hu_HU"          : 1038,
-        "id_ID"          : 1057,
-        "it_IT"          : 1040,
-        "kk_KZ"          : 1087,
-        "ko_KR"          : 1042,
-        "lb_LU"          : 1134,
-        "lt_LT"          : 1063,
-        "lv_LV"          : 1062,
-        "mn_MN"          : 1104,
-        "nb_NO"          : 1044,
-        "nl_NL"          : 1043,
-        "nn_NO"          : 2068,
-        "oc_FR"          : 1154,
-        "pl_PL"          : 1045,
-        "pt_BR"          : 1046,
-        "pt_PT"          : 2070,
-        "ro_RO"          : 1048,
-        "ru_RU"          : 1049,
-        "sk_SK"          : 1051,
-        "sl_SI"          : 1060,
-        "sr_Cyrl_RS"     : 10266,
-        "sr_Latn_RS"     : 9242,
-        "sv_SE"          : 1053,
-        "tr_TR"          : 1055,
-        "uk_UA"          : 1058,
-        "uz_Cyrl_UZ"     : 2115,
-        "uz_Latn_UZ"     : 1091,
-        "vi_VN"          : 1066,
-        "nl_NL"          : 2067
-    };
-
-	var textarea = document.getElementById("textarea");
-	var form = document.querySelector("form");
-	var combobox = document.getElementById("combobox");
-
-	combobox.value = "en_US";
-	textarea.value = "expedition";
-
-	form.onsubmit = function(event)
-	{
-	    if(combobox.value == "")
-	        return;
-
-	    var lang = combobox.value;
-	    var text = textarea.value.split("\n").join(" ").split(" ");
-
-	    var request = new XMLHttpRequest();
-	    var path = '../../../../../../dictionaries/' + lang + '/' + 'hyph_' + lang  + '.dic';
-
-	    request.responseType = 'arraybuffer';
-
-	    if (request.overrideMimeType) {
-	        request.overrideMimeType('text/plain; charset=x-user-defined');
-	    } else {
-	        request.setRequestHeader('Accept-Charset', 'x-user-defined');
-	    }
-	    request.open('GET', path, true);
-	    request.send(null);
-
-	    request.onload = function ()
-	    {
-	        var dict = request.response;
-	        var langInt = langs[lang];
-	        window.hyphen.loadDictionary(langInt, dict);
-
-	        for (var i = 0; i < text.length; i++) 
-	        {
-	            var hyphens = window.hyphen.hyphenWord(langInt, text[i].toLowerCase());
-
-	            let itemUtf8 = text[i].toUtf8(true);
-	            let start = 0;
-	            let hword = "";
-
-	            for (let j = 0, len = hyphens.length; j < len; j++) 
-	            {
-	                hword += "".fromUtf8(itemUtf8, start, hyphens[j] - start);
-	                hword += "=";
-	                start = hyphens[j];
-	            }
-
-	            if (start < itemUtf8.length) 
-	            {
-	                hword += "".fromUtf8(itemUtf8, start);
-	                hword += "=";
-	            }
-
-	            console.log(hword);
-	        }
-	    }
-	    event.preventDefault();
-	}
-})(self);

Common/3dParty/hyphen/js/test/styles.css

@@ -1,10 +0,0 @@
-button {
-	width: 60px;
-	height: 30px;
-}
-
-#textarea{
-	display: block;
-	width: 300px;
-	height: 300px;
-}

Common/3dParty/icu/icu.pri

@@ -1,13 +1,21 @@
-ICU_MAJOR_VER = 58
+ICU_MAJOR_VER = 74
 
 core_windows {
     exists($$PWD/$$CORE_BUILDS_PLATFORM_PREFIX/icu) {
         INCLUDEPATH += $$PWD/$$CORE_BUILDS_PLATFORM_PREFIX/icu/include
     } else {
-        INCLUDEPATH += $$PWD/icu/include
+        build_xp {
+            INCLUDEPATH += $$PWD/icu58/include
+        } else {
+            INCLUDEPATH += $$PWD/icu/include
+        }
     }
 
-    LIBS        += -L$$PWD/$$CORE_BUILDS_PLATFORM_PREFIX/build -licuuc
+    ICU_LIBS_PATH_WIN = $$PWD/$$CORE_BUILDS_PLATFORM_PREFIX/build
+    build_xp {
+        ICU_LIBS_PATH_WIN = $$ICU_LIBS_PATH_WIN/xp
+    }
+    LIBS        += -L$$ICU_LIBS_PATH_WIN -licuuc
 }
 
 core_linux {
@@ -20,8 +28,15 @@ core_linux {
 core_mac {
     INCLUDEPATH += $$PWD/$$CORE_BUILDS_PLATFORM_PREFIX/build/include
 
-    LIBS        += $$PWD/$$CORE_BUILDS_PLATFORM_PREFIX/build/libicuuc.$${ICU_MAJOR_VER}.dylib
-    LIBS        += $$PWD/$$CORE_BUILDS_PLATFORM_PREFIX/build/libicudata.$${ICU_MAJOR_VER}.dylib
+	ICU_LIBS_PATH_MAC = $$PWD/$$CORE_BUILDS_PLATFORM_PREFIX/build
+	bundle_dylibs {
+		LIBS	+= $$ICU_LIBS_PATH_MAC/libicudata.a
+		LIBS	+= $$ICU_LIBS_PATH_MAC/libicui18n.a
+		LIBS	+= $$ICU_LIBS_PATH_MAC/libicuuc.a
+	} else {
+		LIBS	+= $$ICU_LIBS_PATH_MAC/libicuuc.$${ICU_MAJOR_VER}.dylib
+		LIBS	+= $$ICU_LIBS_PATH_MAC/libicudata.$${ICU_MAJOR_VER}.dylib
+	}
 }
 
 core_ios {

Common/3dParty/icu/icu_ios.sh

@@ -1,7 +1,5 @@
 #!/bin/bash
 
-ICU_VERSION="58"
-
 ICU_DIR="$PWD/icu"
 
 ICU_SOURCE="${ICU_DIR}/source"
@@ -47,8 +45,6 @@ defines_utypes=(
 
 function prebuild() {
 
-    svn export http://source.icu-project.org/repos/icu/tags/release-${ICU_VERSION}/icu4c/ ${ICU_DIR} --native-eol LF
-
     echo "===== REMOVING data from bundle ====="
 
     #Data bundle reduction

Common/3dParty/libvlc/.gitignore

@@ -1,2 +1,4 @@
 vlc
+vlc.*
 src
+!build

Common/3dParty/libvlc/build/linux_64/include/vlc/deprecated.h

@@ -2,7 +2,7 @@
  * deprecated.h:  libvlc deprecated API
  *****************************************************************************
  * Copyright (C) 1998-2008 VLC authors and VideoLAN
- * $Id: 27323a434498604ca281900c3e4087a42d22a5d8 $
+ * $Id$
  *
  * Authors: Clément Stenac <zorglub@videolan.org>
  *          Jean-Paul Saman <jpsaman@videolan.org>

Common/3dParty/libvlc/build/linux_64/include/vlc/libvlc.h

@@ -2,7 +2,7 @@
  * libvlc.h:  libvlc external API
  *****************************************************************************
  * Copyright (C) 1998-2009 VLC authors and VideoLAN
- * $Id: b12d900469fa6438c41421f2ac7697b93ffc8a35 $
+ * $Id$
  *
  * Authors: Clément Stenac <zorglub@videolan.org>
  *          Jean-Paul Saman <jpsaman@videolan.org>

Common/3dParty/libvlc/build/linux_64/include/vlc/libvlc_media.h

@@ -2,7 +2,7 @@
  * libvlc_media.h:  libvlc external API
  *****************************************************************************
  * Copyright (C) 1998-2009 VLC authors and VideoLAN
- * $Id: 383f366b6940f7b3d89f5945e015793833ea541f $
+ * $Id$
  *
  * Authors: Clément Stenac <zorglub@videolan.org>
  *          Jean-Paul Saman <jpsaman@videolan.org>
@@ -30,6 +30,12 @@
 extern "C" {
 # endif
 
+#if defined(_MSC_VER)
+#include <basetsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+
+
 /** \defgroup libvlc_media LibVLC media
  * \ingroup libvlc
  * @ref libvlc_media_t is an abstract representation of a playable media.

Common/3dParty/libvlc/build/linux_64/include/vlc/libvlc_media_discoverer.h

@@ -2,7 +2,7 @@
  * libvlc_media_discoverer.h:  libvlc external API
  *****************************************************************************
  * Copyright (C) 1998-2009 VLC authors and VideoLAN
- * $Id: 96c0515ffec98f439867814d68525288b2702b0f $
+ * $Id$
  *
  * Authors: Clément Stenac <zorglub@videolan.org>
  *          Jean-Paul Saman <jpsaman@videolan.org>

Common/3dParty/libvlc/build/linux_64/include/vlc/libvlc_media_library.h

@@ -2,7 +2,7 @@
  * libvlc_media_library.h:  libvlc external API
  *****************************************************************************
  * Copyright (C) 1998-2009 VLC authors and VideoLAN
- * $Id: facbf813aa16140461c6e72f166d2985c52b1d6f $
+ * $Id$
  *
  * Authors: Clément Stenac <zorglub@videolan.org>
  *          Jean-Paul Saman <jpsaman@videolan.org>

Common/3dParty/libvlc/build/linux_64/include/vlc/libvlc_media_list.h

@@ -2,7 +2,7 @@
  * libvlc_media_list.h:  libvlc_media_list API
  *****************************************************************************
  * Copyright (C) 1998-2008 VLC authors and VideoLAN
- * $Id: fa3b90932be8c3a9cce27925d4867aeddde748d7 $
+ * $Id$
  *
  * Authors: Pierre d'Herbemont
  *

Common/3dParty/libvlc/build/linux_64/include/vlc/libvlc_media_list_player.h

@@ -2,7 +2,7 @@
  * libvlc_media_list_player.h:  libvlc_media_list API
  *****************************************************************************
  * Copyright (C) 1998-2008 VLC authors and VideoLAN
- * $Id: 04f7d9b9f0d47e1b8304b51ca20fd2b1045a0ff2 $
+ * $Id$
  *
  * Authors: Pierre d'Herbemont
  *

Common/3dParty/libvlc/build/linux_64/include/vlc/libvlc_media_player.h

@@ -2,7 +2,7 @@
  * libvlc_media_player.h:  libvlc_media_player external API
  *****************************************************************************
  * Copyright (C) 1998-2015 VLC authors and VideoLAN
- * $Id: c431c235e92ced9e6e7d7712eb7ff0e73dc4f933 $
+ * $Id$
  *
  * Authors: Clément Stenac <zorglub@videolan.org>
  *          Jean-Paul Saman <jpsaman@videolan.org>
@@ -559,6 +559,8 @@ LIBVLC_API uint32_t libvlc_media_player_get_xwindow ( libvlc_media_player_t *p_m
  * render its video output. If LibVLC was built without Win32/Win64 API output
  * support, then this has no effects.
  *
+ * \warning the HWND must have the WS_CLIPCHILDREN set in its style.
+ *
  * \param p_mi the Media Player
  * \param drawable windows handle of the drawable
  */

Common/3dParty/libvlc/build/linux_64/include/vlc/libvlc_version.h

@@ -39,7 +39,7 @@
 # define LIBVLC_VERSION_MINOR    (0)
 
 /** LibVLC revision */
-# define LIBVLC_VERSION_REVISION (18)
+# define LIBVLC_VERSION_REVISION (21)
 
 # define LIBVLC_VERSION_EXTRA    (0)
 

Common/3dParty/libvlc/build/linux_64/include/vlc/libvlc_vlm.h

@@ -2,7 +2,7 @@
  * libvlc_vlm.h:  libvlc_* new external API
  *****************************************************************************
  * Copyright (C) 1998-2008 VLC authors and VideoLAN
- * $Id: cfa2d956463056b287cdb0a4faeb46442040a010 $
+ * $Id$
  *
  * Authors: Clément Stenac <zorglub@videolan.org>
  *          Jean-Paul Saman <jpsaman _at_ m2x _dot_ nl>

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_access.h

@@ -2,7 +2,7 @@
  * vlc_access.h: Access descriptor, queries and methods
  *****************************************************************************
  * Copyright (C) 1999-2006 VLC authors and VideoLAN
- * $Id: da06554814885d03823aefbf58e858f6941b3400 $
+ * $Id$
  *
  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  *

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_actions.h

@@ -2,7 +2,7 @@
  * vlc_actions.h: handle vlc actions
  *****************************************************************************
  * Copyright (C) 2003-2016 VLC authors and VideoLAN
- * $Id: 404c1662a82ef3f3ffc983a81fa73b90f5773eef $
+ * $Id$
  *
  * Authors: Sigmund Augdal Helberg <dnumgis@videolan.org>
  *

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_aout.h

@@ -129,7 +129,7 @@ struct audio_output
     /**< Stops the existing stream (optional, may be NULL).
       * \note A stream must have been started when called.
       */
-    int (*time_get)(audio_output_t *, mtime_t *delay);
+    int (*time_get)(audio_output_t *, vlc_tick_t *delay);
     /**< Estimates playback buffer latency (optional, may be NULL).
       * \param delay pointer to the delay until the next sample to be written
       *              to the playback buffer is rendered [OUT]
@@ -140,7 +140,7 @@ struct audio_output
     /**< Queues a block of samples for playback (mandatory, cannot be NULL).
       * \note A stream must have been started when called.
       */
-    void (*pause)( audio_output_t *, bool pause, mtime_t date);
+    void (*pause)( audio_output_t *, bool pause, vlc_tick_t date);
     /**< Pauses or resumes playback (optional, may be NULL).
       * \param pause pause if true, resume from pause if false
       * \param date timestamp when the pause or resume was requested

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_aout_volume.h

@@ -2,7 +2,7 @@
  * vlc_aout_volume.h: audio volume module
  *****************************************************************************
  * Copyright (C) 2002-2009 VLC authors and VideoLAN
- * $Id: df85b8fd14e00454e88c08061e3059fa67927dab $
+ * $Id$
  *
  * Authors: Christophe Massiot <massiot@via.ecp.fr>
  *          Laurent Aimar <fenrir _AT_ videolan _DOT_ org>

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_arrays.h

@@ -2,7 +2,7 @@
  * vlc_arrays.h : Arrays and data structures handling
  *****************************************************************************
  * Copyright (C) 1999-2004 VLC authors and VideoLAN
- * $Id: 39b69952ffce040330da239f52778c3e82024bc4 $
+ * $Id$
  *
  * Authors: Samuel Hocevar <sam@zoy.org>
  *          Clément Stenac <zorglub@videolan.org>

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_bits.h

@@ -2,7 +2,7 @@
  * vlc_bits.h : Bit handling helpers
  *****************************************************************************
  * Copyright (C) 2001, 2002, 2003, 2006, 2015 VLC authors and VideoLAN
- * $Id: 395a789eba46ac42413f5fb5418619332589f824 $
+ * $Id$
  *
  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  *          Gildas Bazin <gbazin at videolan dot org>

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_block.h

@@ -2,7 +2,7 @@
  * vlc_block.h: Data blocks management functions
  *****************************************************************************
  * Copyright (C) 2003 VLC authors and VideoLAN
- * $Id: 1c9478301687233398adbb7de7da4ffc4a101f89 $
+ * $Id$
  *
  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  *
@@ -49,7 +49,7 @@
  * - i_flags may not always be set (ie could be 0, even for a key frame
  *      it depends where you receive the buffer (before/after a packetizer
  *      and the demux/packetizer implementations.
- * - i_dts/i_pts could be VLC_TS_INVALID, it means no pts/dts
+ * - i_dts/i_pts could be VLC_TICK_INVALID, it means no pts/dts
  * - i_length: length in microseond of the packet, can be null except in the
  *      sout where it is mandatory.
  *
@@ -121,9 +121,9 @@ struct block_t
     uint32_t    i_flags;
     unsigned    i_nb_samples; /* Used for audio */
 
-    mtime_t     i_pts;
-    mtime_t     i_dts;
-    mtime_t     i_length;
+    vlc_tick_t  i_pts;
+    vlc_tick_t  i_dts;
+    vlc_tick_t  i_length;
 
     /* Rudimentary support for overloading block (de)allocation. */
     block_free_t pf_release;
@@ -175,7 +175,7 @@ VLC_API block_t *block_Realloc(block_t *, ssize_t pre, size_t body) VLC_USED;
  *
  * @note
  * If the block is in a chain, this function does <b>not</b> release any
- * subsequent block in the chain. Use block_ChainRelease() for that purpose. 
+ * subsequent block in the chain. Use block_ChainRelease() for that purpose.
  *
  * @param block block to release (cannot be NULL)
  */
@@ -364,10 +364,10 @@ static size_t block_ChainExtract( block_t *p_list, void *p_data, size_t i_max )
     return i_total;
 }
 
-static inline void block_ChainProperties( block_t *p_list, int *pi_count, size_t *pi_size, mtime_t *pi_length )
+static inline void block_ChainProperties( block_t *p_list, int *pi_count, size_t *pi_size, vlc_tick_t *pi_length )
 {
     size_t i_size = 0;
-    mtime_t i_length = 0;
+    vlc_tick_t i_length = 0;
     int i_count = 0;
 
     while( p_list )
@@ -390,7 +390,7 @@ static inline void block_ChainProperties( block_t *p_list, int *pi_count, size_t
 static inline block_t *block_ChainGather( block_t *p_list )
 {
     size_t  i_total = 0;
-    mtime_t i_length = 0;
+    vlc_tick_t i_length = 0;
     block_t *g;
 
     if( p_list->p_next == NULL )
@@ -534,7 +534,7 @@ VLC_API void vlc_fifo_WaitCond(vlc_fifo_t *, vlc_cond_t *);
  * Atomically unlocks the FIFO and waits until one thread signals the FIFO up
  * to a certain date, then locks the FIFO again. See vlc_fifo_Wait().
  */
-int vlc_fifo_TimedWaitCond(vlc_fifo_t *, vlc_cond_t *, mtime_t);
+int vlc_fifo_TimedWaitCond(vlc_fifo_t *, vlc_cond_t *, vlc_tick_t);
 
 /**
  * Queues a linked-list of blocks into a locked FIFO.

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_charset.h

@@ -3,7 +3,7 @@
  *****************************************************************************
  * Copyright (C) 2003-2005 VLC authors and VideoLAN
  * Copyright © 2005-2010 Rémi Denis-Courmont
- * $Id: c77f19892047f406a69695a255aaf9ef6ef32ec3 $
+ * $Id$
  *
  * Author: Rémi Denis-Courmont
  *

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_codec.h

@@ -2,7 +2,7 @@
  * vlc_codec.h: Definition of the decoder and encoder structures
  *****************************************************************************
  * Copyright (C) 1999-2003 VLC authors and VideoLAN
- * $Id: 3499ede27c1dbb94ff665a51d000c55bd45f2794 $
+ * $Id$
  *
  * Authors: Gildas Bazin <gbazin@netcourrier.com>
  *
@@ -169,7 +169,7 @@ struct decoder_t
 
     /* Display date
      * XXX use decoder_GetDisplayDate */
-    mtime_t         (*pf_get_display_date)( decoder_t *, mtime_t );
+    vlc_tick_t      (*pf_get_display_date)( decoder_t *, vlc_tick_t );
 
     /* Display rate
      * XXX use decoder_GetDisplayRate */
@@ -409,7 +409,7 @@ VLC_API int decoder_GetInputAttachments( decoder_t *, input_attachment_t ***ppp_
  * to mdate().
  * You MUST use it *only* for gathering statistics about speed.
  */
-VLC_API mtime_t decoder_GetDisplayDate( decoder_t *, mtime_t ) VLC_USED;
+VLC_API vlc_tick_t decoder_GetDisplayDate( decoder_t *, vlc_tick_t ) VLC_USED;
 
 /**
  * This function returns the current input rate.

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_common.h

@@ -152,7 +152,11 @@
  * epoch). Note that date and time intervals can be manipulated using regular
  * arithmetic operators, and that no special functions are required.
  */
-typedef int64_t mtime_t;
+typedef int64_t vlc_tick_t;
+typedef vlc_tick_t mtime_t; /* deprecated, use vlc_tick_t */
+
+#define VLC_TICK_INVALID  VLC_TS_INVALID
+#define VLC_TICK_0        VLC_TS_0
 
 /**
  * The vlc_fourcc_t type.
@@ -943,6 +947,11 @@ static inline void SetQWLE (void *p, uint64_t qw)
 #       define O_NONBLOCK 0
 #   endif
 
+/* the mingw32 swab() and win32 _swab() prototypes expect a char* instead of a
+   const void* */
+#  define swab(a,b,c)  swab((char*) (a), (char*) (b), (c))
+
+
 #   include <tchar.h>
 #endif /* _WIN32 */
 

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_config_cat.h

@@ -2,7 +2,7 @@
  * vlc_config_cat.h : Definition of configuration categories
  *****************************************************************************
  * Copyright (C) 2003 VLC authors and VideoLAN
- * $Id: 55d2e468d1ccc3fcd8d165dcecc10ec753021a5e $
+ * $Id$
  *
  * Authors: Clément Stenac <zorglub@videolan.org>
  *          Anil Daoud <anil@videolan.org>

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_configuration.h

@@ -4,7 +4,7 @@
  * It includes functions allowing to declare, get or set configuration options.
  *****************************************************************************
  * Copyright (C) 1999-2006 VLC authors and VideoLAN
- * $Id: 209168615be2a7bc5db889282b32389093ab262e $
+ * $Id$
  *
  * Authors: Gildas Bazin <gbazin@videolan.org>
  *

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_demux.h

@@ -2,7 +2,7 @@
  * vlc_demux.h: Demuxer descriptor, queries and methods
  *****************************************************************************
  * Copyright (C) 1999-2005 VLC authors and VideoLAN
- * $Id: f359f547fa79d9818ed74420d906a6683be3d037 $
+ * $Id$
  *
  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  *

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_epg.h

@@ -2,7 +2,7 @@
  * vlc_epg.h: Electronic Program Guide
  *****************************************************************************
  * Copyright (C) 2007 VLC authors and VideoLAN
- * $Id: f7b9044e7c0aa1af4a44066d73f2ead943fc6a46 $
+ * $Id$
  *
  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  *

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_es.h

@@ -2,7 +2,7 @@
  * vlc_es.h: Elementary stream formats descriptions
  *****************************************************************************
  * Copyright (C) 1999-2012 VLC authors and VideoLAN
- * $Id: 3c8e04e1b15740166df2e0b2d9a651ffb2c5bc2f $
+ * $Id$
  *
  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  *

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_es_out.h

@@ -2,7 +2,7 @@
  * vlc_es_out.h: es_out (demuxer output) descriptor, queries and methods
  *****************************************************************************
  * Copyright (C) 1999-2004 VLC authors and VideoLAN
- * $Id: fe53c2a3d34f76eec76d83032cd0d3111be915aa $
+ * $Id$
  *
  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  *
@@ -93,8 +93,8 @@ enum es_out_query_e
     ES_OUT_SET_META, /* arg1=const vlc_meta_t * */
 
     /* PCR system clock manipulation for external clock synchronization */
-    ES_OUT_GET_PCR_SYSTEM, /* arg1=mtime_t *, arg2=mtime_t * res=can fail */
-    ES_OUT_MODIFY_PCR_SYSTEM, /* arg1=int is_absolute, arg2=mtime_t, res=can fail */
+    ES_OUT_GET_PCR_SYSTEM, /* arg1=vlc_tick_t *, arg2=vlc_tick_t * res=can fail */
+    ES_OUT_MODIFY_PCR_SYSTEM, /* arg1=int is_absolute, arg2=vlc_tick_t, res=can fail */
 
     ES_OUT_POST_SUBNODE, /* arg1=input_item_node_t *, res=can fail */
 
@@ -167,11 +167,11 @@ static inline int es_out_ControlSetMeta( es_out_t *out, const vlc_meta_t *p_meta
     return es_out_Control( out, ES_OUT_SET_META, p_meta );
 }
 
-static inline int es_out_ControlGetPcrSystem( es_out_t *out, mtime_t *pi_system, mtime_t *pi_delay )
+static inline int es_out_ControlGetPcrSystem( es_out_t *out, vlc_tick_t *pi_system, vlc_tick_t *pi_delay )
 {
     return es_out_Control( out, ES_OUT_GET_PCR_SYSTEM, pi_system, pi_delay );
 }
-static inline int es_out_ControlModifyPcrSystem( es_out_t *out, bool b_absolute, mtime_t i_system )
+static inline int es_out_ControlModifyPcrSystem( es_out_t *out, bool b_absolute, vlc_tick_t i_system )
 {
     return es_out_Control( out, ES_OUT_MODIFY_PCR_SYSTEM, b_absolute, i_system );
 }

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_events.h

@@ -3,7 +3,7 @@
  * Interface used to send events.
  *****************************************************************************
  * Copyright (C) 2007 VLC authors and VideoLAN
- * $Id: 229f4f677029763a837558932dad3e47b283e61c $
+ * $Id$
  *
  * Authors: Pierre d'Herbemont
  *
@@ -142,7 +142,7 @@ typedef struct vlc_event_t
         } input_item_subitem_tree_added;
         struct vlc_input_item_duration_changed
         {
-            mtime_t new_duration;
+            vlc_tick_t new_duration;
         } input_item_duration_changed;
         struct vlc_input_item_preparsed_changed
         {

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_filter.h

@@ -95,7 +95,7 @@ struct filter_t
                                  int, int, int );
 
         /** Generate a subpicture (sub source) */
-        subpicture_t *(*pf_sub_source)( filter_t *, mtime_t );
+        subpicture_t *(*pf_sub_source)( filter_t *, vlc_tick_t );
 
         /** Filter a subpicture (sub filter) */
         subpicture_t *(*pf_sub_filter)( filter_t *, subpicture_t * );
@@ -431,7 +431,7 @@ VLC_API void filter_chain_VideoFlush( filter_chain_t * );
  * \param display_date of subpictures
  */
 void filter_chain_SubSource(filter_chain_t *chain, spu_t *,
-                            mtime_t display_date);
+                            vlc_tick_t display_date);
 
 /**
  * Apply filter chain to subpictures.

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_fourcc.h

@@ -2,7 +2,7 @@
  * vlc_fourcc.h: Definition of various FOURCC and helpers
  *****************************************************************************
  * Copyright (C) 2009 Laurent Aimar
- * $Id: 97827bd4c146461408fbfd5d0aed6e45a91dc89a $
+ * $Id$
  *
  * Authors: Laurent Aimar <fenrir _AT_ videolan _DOT_ com>
  *

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_http.h

@@ -2,7 +2,7 @@
  * vlc_http.h: Shared code for HTTP clients
  *****************************************************************************
  * Copyright (C) 2001-2008 VLC authors and VideoLAN
- * $Id: a48ea794963ad476fc059eb3ffcf787186b78b47 $
+ * $Id$
  *
  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  *          Christophe Massiot <massiot@via.ecp.fr>

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_httpd.h

@@ -2,7 +2,7 @@
  * vlc_httpd.h: builtin HTTP/RTSP server.
  *****************************************************************************
  * Copyright (C) 2004-2006 VLC authors and VideoLAN
- * $Id: 29b8229e7b6baa7a8eedf37f6fdb1e97bf6a9ca7 $
+ * $Id$
  *
  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  *

Common/3dParty/libvlc/build/linux_64/include/vlc/plugins/vlc_image.h

@@ -2,7 +2,7 @@
  * vlc_image.h : wrapper for image reading/writing facilities
  *****************************************************************************
  * Copyright (C) 2004 VLC authors and VideoLAN
- * $Id: 2b308fd0e52f4d4d6e20f95d08e0d63c53822eef $
+ * $Id$
  *
  * Authors: Gildas Bazin <gbazin@videolan.org>
  *