Merge pull request 'feature/custom-sysroot' (#417) from feature/custom-sysroot into release/v9.1.0

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

Common/.gitignore

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

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,12 +26,17 @@ 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
 
     BOOST_POSTFIX = -vc$${VS_VERSION}-mt-$${VS_DEBUG}$${VS_ARCH}-1_72

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/html/css/src/CCompiledStyle.cpp

@@ -12,7 +12,7 @@
 #include "StaticFunctions.h"
 #include "ConstValues.h"
 
-#define DEFAULT_FONT_SIZE 14
+#define DEFAULT_FONT_SIZE 12
 
 namespace NSCSS
 {
@@ -49,6 +49,8 @@ namespace NSCSS
 		if (!oElement.m_sId.empty())
 			m_sId += L'+' + oElement.m_sId;
 
+		m_arParentsStyles.insert(oElement.m_arParentsStyles.begin(), oElement.m_arParentsStyles.end());
+
 		return *this;
 	}
 
@@ -69,6 +71,8 @@ namespace NSCSS
 		m_oDisplay      = oElement.m_oDisplay;
 		m_oTransform    = oElement.m_oTransform;
 
+		m_arParentsStyles = oElement.m_arParentsStyles;
+
 		return *this;
 	}
 
@@ -109,7 +113,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 +319,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 +341,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 +363,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 +385,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 +444,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 +535,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>
 
@@ -186,7 +184,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;
@@ -472,7 +470,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);
 
@@ -488,6 +486,95 @@ namespace NSCSS
 	{}
 
 	#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();
+			}
+
+			return true;
+		}
+
+		const std::map<std::vector<CNode>, CCompiledStyle>::iterator oItem = m_mUsedStyles.find(arSelectors);
+
+		if (oItem != m_mUsedStyles.end())
+		{
+			arSelectors.back().SetCompiledStyle(new CCompiledStyle(oItem->second));
+			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);
+		std::vector<std::wstring> arPrevNodes;
+		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;
+
+			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->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);
+
+			// Скидываем некоторые внешние стили, которые внутри таблицы переопределяются
+			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:: пересмотреть данный метод
@@ -505,11 +592,11 @@ 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)
 	{
 		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(); oNode != arSelectors.rend() - unStart; ++oNode)
 		{
 			if (!oNode->m_wsName.empty())
 				arNodes.push_back(oNode->m_wsName);
@@ -620,6 +707,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(),
@@ -631,79 +728,6 @@ namespace NSCSS
 	}
 
 	#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);
@@ -766,6 +790,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 +939,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

@@ -37,7 +37,7 @@ namespace NSCSS
 		void ClearPageData();
 		#endif
 
-		const CElement* FindElement(const std::wstring& wsSelector);
+		const CElement* FindElement(const std::wstring& wsSelector) const;
 	private:
 		typedef struct
 		{
@@ -77,7 +77,7 @@ 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;
 	};
 
 	class CCssCalculator_Private
@@ -102,8 +102,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 +110,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 = 0);
 		std::vector<const CElement*> FindElements(std::vector<std::wstring>& arNodes, std::vector<std::wstring>& arNextNodes);
 
 		void AddStyles(const std::string& sStyle);
@@ -123,6 +122,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/CNode.cpp

@@ -1,19 +1,58 @@
 #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();
+		*m_pCompiledStyle = *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();
 	}
 
+	#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();

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

@@ -7,6 +7,9 @@
 
 namespace NSCSS
 {
+	#ifdef CSS_CALCULATOR_WITH_XHTML
+	class CCompiledStyle;
+	#endif
 	class CNode
 	{
 	public:
@@ -16,12 +19,21 @@ namespace NSCSS
 		std::wstring m_wsStyle; // Стиль тэга
 		std::map<std::wstring, std::wstring> m_mAttributes; // Остальные аттрибуты тэга
 
+		#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;
 
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		void SetCompiledStyle(CCompiledStyle* pCompiledStyle);
+		#endif
+
 		void Clear();
 
 		std::vector<std::wstring> GetData() const;

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

@@ -1328,8 +1328,14 @@ namespace NSCSS
 
 	// DISPLAY
 	CDisplay::CDisplay()
-	    : m_oDisplay(L"inline", 0)
-	{}
+	{
+		m_eWhiteSpace.SetMapping({{L"normal",   EWhiteSpace::Normal  },
+		                          {L"nowrap",   EWhiteSpace::Nowrap  },
+		                          {L"pre",      EWhiteSpace::Pre     },
+		                          {L"pre-line", EWhiteSpace::Pre_Line},
+		                          {L"pre-wrap", EWhiteSpace::Pre_Wrap}},
+		                                        EWhiteSpace::Normal);
+	}
 
 	void CDisplay::Equation(CDisplay &oFirstDisplay, CDisplay &oSecondDisplay)
 	{
@@ -1342,6 +1348,8 @@ namespace NSCSS
 		CString::Equation(oFirstDisplay.m_oHAlign, oSecondDisplay.m_oHAlign);
 
 		CString::Equation(oFirstDisplay.m_oDisplay, oSecondDisplay.m_oDisplay);
+
+		CEnum::Equation(oFirstDisplay.m_eWhiteSpace, oSecondDisplay.m_eWhiteSpace);
 	}
 
 	bool CDisplay::SetX(const std::wstring &wsValue, unsigned int unLevel, bool bHardMode)
@@ -1405,6 +1413,11 @@ namespace NSCSS
 		return m_oDisplay.SetValue(wsValue, NSConstValues::DISPLAY_VALUES, unLevel, bHardMode);
 	}
 
+	bool CDisplay::SetWhiteSpace(const std::wstring& wsValue, unsigned int unLevel, bool bHardMode)
+	{
+		return m_eWhiteSpace.SetValue(wsValue, unLevel, bHardMode);
+	}
+
 	const CDigit& CDisplay::GetX() const
 	{
 		return m_oX;
@@ -1440,34 +1453,42 @@ namespace NSCSS
 		return m_oDisplay;
 	}
 
+	const CEnum& CDisplay::GetWhiteSpace() const
+	{
+		return m_eWhiteSpace;
+	}
+
 	bool CDisplay::Empty() const
 	{
 		return m_oX.Empty() && m_oY.Empty() && m_oWidth.Empty() && m_oHeight.Empty() &&
-		       m_oHeight.Empty() && m_oVAlign.Empty() && m_oDisplay.Empty();
+		       m_oHeight.Empty() && m_oVAlign.Empty() && m_oDisplay.Empty() &&
+		       (m_eWhiteSpace.Empty() || m_eWhiteSpace == EWhiteSpace::Normal);
 	}
 
 	CDisplay &CDisplay::operator+=(const CDisplay &oDisplay)
 	{
-		m_oX       += oDisplay.m_oX;
-		m_oY       += oDisplay.m_oY;
-		m_oWidth   = oDisplay.m_oWidth;
-		m_oHeight  = oDisplay.m_oHeight;
-		m_oHAlign  += oDisplay.m_oHAlign;
-		m_oVAlign  += oDisplay.m_oVAlign;
-		m_oDisplay += oDisplay.m_oDisplay;
+		m_oX          += oDisplay.m_oX;
+		m_oY          += oDisplay.m_oY;
+		m_oWidth       = oDisplay.m_oWidth;
+		m_oHeight      = oDisplay.m_oHeight;
+		m_oHAlign     += oDisplay.m_oHAlign;
+		m_oVAlign     += oDisplay.m_oVAlign;
+		m_oDisplay    += oDisplay.m_oDisplay;
+		m_eWhiteSpace += oDisplay.m_eWhiteSpace;
 
 		return *this;
 	}
 
 	bool CDisplay::operator==(const CDisplay &oDisplay) const
 	{
-		return m_oX       == oDisplay.m_oX      &&
-		       m_oY       == oDisplay.m_oY      &&
-		       m_oWidth   == oDisplay.m_oWidth  &&
-		       m_oHeight  == oDisplay.m_oHeight &&
-		       m_oHAlign  == oDisplay.m_oHAlign &&
-		       m_oVAlign  == oDisplay.m_oVAlign &&
-		       m_oDisplay == oDisplay.m_oDisplay;
+		return m_oX          == oDisplay.m_oX       &&
+		       m_oY          == oDisplay.m_oY       &&
+		       m_oWidth      == oDisplay.m_oWidth   &&
+		       m_oHeight     == oDisplay.m_oHeight  &&
+		       m_oHAlign     == oDisplay.m_oHAlign  &&
+		       m_oVAlign     == oDisplay.m_oVAlign  &&
+		       m_oDisplay    == oDisplay.m_oDisplay &&
+		       m_eWhiteSpace == oDisplay.m_eWhiteSpace.ToInt();
 	}
 
 	// STROKE

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

@@ -328,6 +328,15 @@ namespace NSCSS
 	};
 
 	// PROPERTIES
+	typedef enum
+	{
+		Normal,
+		Nowrap,
+		Pre,
+		Pre_Line,
+		Pre_Wrap
+	} EWhiteSpace;
+
 	class CDisplay
 	{
 	public:
@@ -347,6 +356,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,6 +368,8 @@ namespace NSCSS
 
 		const CString& GetDisplay() const;
 
+		const CEnum& GetWhiteSpace() const;
+
 		bool Empty() const;
 
 		CDisplay& operator+=(const CDisplay& oDisplay);
@@ -371,6 +384,8 @@ namespace NSCSS
 		CString m_oVAlign;
 
 		CString m_oDisplay;
+
+		CEnum m_eWhiteSpace;
 	};
 
 	class CStroke

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

@@ -22,10 +22,10 @@ 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) 
+	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;
 
@@ -470,9 +470,6 @@ 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"\"";
 	}
 
@@ -559,7 +556,7 @@ namespace NSCSS
 
 		if (oXmlElement.Empty())
 			return false;
-		
+
 		m_sStyle += oXmlElement.GetPStyle(true);
 		return true;
 	}

Common/3dParty/html/fetch.py

@@ -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/htmltoxhtml.h

@@ -19,7 +19,6 @@ static std::string nonbreaking_inline  = "|a|abbr|acronym|b|bdo|big|cite|code|df
 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",
@@ -69,10 +68,10 @@ static std::wstring htmlToXhtml(std::string& sFileContent, bool bNeedConvert)
 {
 	if (bNeedConvert)
 	{ // Определение кодировки
-		std::string sEncoding = NSStringFinder::FindPropety(sFileContent, "charset", {"="}, {";", "\\n", "\\r", " ", "\""}).m_sValue;
+		std::string sEncoding = NSStringFinder::FindProperty(sFileContent, "charset", {"="}, {";", "\\n", "\\r", " ", "\""}).m_sValue;
 
 		if (sEncoding.empty())
-			sEncoding = NSStringFinder::FindPropety(sFileContent, "encoding", {"="}, {";", "\\n", "\\r", " "}).m_sValue;
+			sEncoding = NSStringFinder::FindProperty(sFileContent, "encoding", {"="}, {";", "\\n", "\\r", " "}).m_sValue;
 
 		if (!sEncoding.empty() && !NSStringFinder::Equals("utf-8", sEncoding))
 		{
@@ -211,7 +210,7 @@ static void ReadMht(const std::string& sMhtContent, std::map<std::string, std::s
 	NSStringFinder::TFoundedData<char> oData;
 	
 	// Content-Type
-	oData =  NSStringFinder::FindPropety(sMhtContent, "content-type", {":"}, {";", "\\n", "\\r"});
+	oData =  NSStringFinder::FindProperty(sMhtContent, "content-type", {":"}, {";", "\\n", "\\r"});
 	const std::string sContentType{oData.m_sValue};
 
 	if (sContentType.empty())
@@ -227,18 +226,18 @@ static void ReadMht(const std::string& sMhtContent, std::map<std::string, std::s
 	unCharsetBegin = oData.m_unEndPosition;
 
 	// name
-//	std::string sName = NSStringFinder::FindPropety(sMhtContent, "name", {"="}, {";", "\\n", "\\r"}, 0, unLastPosition);
+//	std::string sName = NSStringFinder::FindProperty(sMhtContent, "name", {"="}, {";", "\\n", "\\r"}, 0, unLastPosition);
 //	unContentPosition = std::max(unContentPosition, unLastPosition);
 
 	// Content-Location
-	oData = NSStringFinder::FindPropety(sMhtContent, "content-location", {":"}, {";", "\\n", "\\r"});
+	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::FindPropety(sMhtContent, "content-id", {":"}, {";", "\\n", "\\r"});
+	oData = NSStringFinder::FindProperty(sMhtContent, "content-id", {":"}, {";", "\\n", "\\r"});
 	std::string sContentID{oData.m_sValue};
 
 	if (!oData.Empty())
@@ -252,7 +251,7 @@ static void ReadMht(const std::string& sMhtContent, std::map<std::string, std::s
 		sContentLocation = "cid:" + sContentID;
 
 	// Content-Transfer-Encoding
-	oData = NSStringFinder::FindPropety(sMhtContent, "content-transfer-encoding", {":"}, {";", "\\n", "\\r"});
+	oData = NSStringFinder::FindProperty(sMhtContent, "content-transfer-encoding", {":"}, {";", "\\n", "\\r"});
 	const std::string sContentEncoding{oData.m_sValue};
 
 	if (!oData.Empty())
@@ -266,7 +265,7 @@ static void ReadMht(const std::string& sMhtContent, std::map<std::string, std::s
 
 	if (std::string::npos != unCharsetEnd && unCharsetBegin < unCharsetEnd)
 	{
-		sCharset = NSStringFinder::FindPropety(sMhtContent.substr(unCharsetBegin, unCharsetEnd - unCharsetBegin), "charset", {"="}, {";", "\\n", "\\r"}).m_sValue;
+		sCharset = NSStringFinder::FindProperty(sMhtContent.substr(unCharsetBegin, unCharsetEnd - unCharsetBegin), "charset", {"="}, {";", "\\n", "\\r"}).m_sValue;
 		NSStringFinder::CutInside<std::string>(sCharset, "\"");
 	}
 
@@ -338,7 +337,7 @@ static std::string mhtTohtml(const std::string& sFileContent)
 	NSStringUtils::CStringBuilderA oRes;
 
 	// Поиск boundary
-	NSStringFinder::TFoundedData<char> oData{NSStringFinder::FindPropety(sFileContent, "boundary", {"="}, {"\\r", "\\n", "\""})};
+	NSStringFinder::TFoundedData<char> oData{NSStringFinder::FindProperty(sFileContent, "boundary", {"="}, {"\\r", "\\n", "\""})};
 
 	size_t nFound{oData.m_unEndPosition};
 	std::string sBoundary{oData.m_sValue};
@@ -436,9 +435,25 @@ static void substitute_xml_entities_into_text(std::string& text)
 	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; });
+	}
+}
+
 // Заменяет сущности " в 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;");
 }
@@ -474,6 +489,7 @@ static void build_doctype(GumboNode* node, NSStringUtils::CStringBuilderA& oBuil
 		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 \"");
@@ -486,7 +502,7 @@ static void build_doctype(GumboNode* node, NSStringUtils::CStringBuilderA& oBuil
 	}
 }
 
-static void build_attributes(const GumboVector* attribs, bool no_entities, NSStringUtils::CStringBuilderA& atts)
+static void build_attributes(const GumboVector* attribs, NSStringUtils::CStringBuilderA& atts)
 {
 	std::vector<std::string> arrRepeat;
 	for (size_t i = 0; i < attribs->length; ++i)
@@ -494,6 +510,10 @@ static void build_attributes(const GumboVector* attribs, bool no_entities, NSStr
 		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;
@@ -532,8 +552,7 @@ static void build_attributes(const GumboVector* attribs, bool no_entities, NSStr
 		std::string qs ="\"";
 		atts.WriteString("=");
 		atts.WriteString(qs);
-		if(!no_entities)
-			substitute_xml_entities_into_attributes(sVal);
+		substitute_xml_entities_into_attributes(sVal);
 		atts.WriteString(sVal);
 		atts.WriteString(qs);
 	}
@@ -542,7 +561,6 @@ static void build_attributes(const GumboVector* attribs, bool no_entities, NSStr
 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;
@@ -556,8 +574,8 @@ static void prettyprint_contents(GumboNode* node, NSStringUtils::CStringBuilderA
 		if (child->type == GUMBO_NODE_TEXT)
 		{
 			std::string val(child->v.text.text);
-			if(!no_entity_substitution)
-				substitute_xml_entities_into_text(val);
+			remove_control_symbols(val);
+			substitute_xml_entities_into_text(val);
 
 			// Избавление от FF
 			size_t found = val.find_first_of("\014");
@@ -596,6 +614,7 @@ static void prettyprint(GumboNode* node, NSStringUtils::CStringBuilderA& oBuilde
 	}
 
 	std::string tagname            = get_tag_name(node);
+	remove_control_symbols(tagname);
 
 	if (NodeIsUnprocessed(tagname))
 		return;
@@ -613,7 +632,6 @@ static void prettyprint(GumboNode* node, NSStringUtils::CStringBuilderA& oBuilde
 	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)
@@ -626,7 +644,7 @@ static void prettyprint(GumboNode* node, NSStringUtils::CStringBuilderA& oBuilde
 
 	// build attr string
 	const GumboVector* attribs = &node->v.element.attributes;
-	build_attributes(attribs, no_entity_substitution, oBuilder);
+	build_attributes(attribs, oBuilder);
 	oBuilder.WriteString(close + ">");
 
 	// prettyprint your contents

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/icu/icu.pri

@@ -1,4 +1,4 @@
-ICU_MAJOR_VER = 58
+ICU_MAJOR_VER = 74
 
 core_windows {
     exists($$PWD/$$CORE_BUILDS_PLATFORM_PREFIX/icu) {
@@ -20,8 +20,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/md/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+md4c
+# Except this file
+!.gitignore

Common/3dParty/md/fetch.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+
+import sys
+sys.path.append('../../../../build_tools/scripts')
+import config
+import base
+import os
+
+base_directory = os.getcwd()
+
+if not base.is_dir("md4c"):
+  base.cmd("git", ["clone", "https://github.com/mity/md4c.git"])
+  base.cmd_in_dir("md4c", "git", ["checkout", "481fbfbdf72daab2912380d62bb5f2187d438408"])

Common/3dParty/md/md2html.cpp

@@ -0,0 +1,105 @@
+#include "md2html.h"
+
+#include "md4c/src/md4c-html.h"
+#include "../../../DesktopEditor/common/File.h"
+
+namespace Md
+{
+void ToHtml(const MD_CHAR* pValue, MD_SIZE uSize, void* pData)
+{
+	if (NULL != pData)
+		(*(std::string*)pData).append(pValue, uSize);
+}
+
+std::string ConvertMdStringToHtml(const std::string& sMdString)
+{
+	std::string sData;
+	md_html(sMdString.c_str(), sMdString.length(), ToHtml, &sData, 0, 0);
+	return sData;
+}
+
+void ToHtmlFile(const MD_CHAR* pValue, MD_SIZE uSize, void* pData)
+{
+	if (NULL != pData)
+		((NSFile::CFileBinary*)pData)->WriteFile(pValue, uSize);
+}
+
+void WriteBaseHtmlStyles(NSFile::CFileBinary& oFile)
+{
+	oFile.WriteStringUTF8(L"<style>");
+
+	// Main styles
+	oFile.WriteStringUTF8(L"* { font-family: Arial; color:black; white-space:pre; }");
+	oFile.WriteStringUTF8(L"p { margin: 0 0 10px; display: block; }");
+	oFile.WriteStringUTF8(L"a { color: #0553c1; text-decoration: underline; } a:visited { color: #954f72; text-decoration: underline; }");
+	oFile.WriteStringUTF8(L"ul { margin-top: 0; margin-bottom: 10px; }");
+	oFile.WriteStringUTF8(L"img { vertical-align: middle; }");
+
+	// Styles for tables
+	oFile.WriteStringUTF8(L"table { margin-bottom: 20px; width: 100%; max-width: 100%; border-spacing:0; border-collapse: collapse; border-color: gray;}");
+	oFile.WriteStringUTF8(L"thead { display: table-header-group; vertical-align: middle; }");
+	oFile.WriteStringUTF8(L"tr { display: table-row; }");
+	oFile.WriteStringUTF8(L"th { text-align: left; display: table-cell; font-weight: bold; }");
+
+	oFile.WriteStringUTF8(L"table thead tr th { vertical-align: bottom; border-bottom: 2px solid #ddd; }");
+	oFile.WriteStringUTF8(L"table thead tr th, table tbody tr th, table thead tr td, table tbody tr td { padding 8px; line-height: 1.4; vertical-align: top; border-top: 1px solid #ddd; }");
+	oFile.WriteStringUTF8(L"table > caption + thead > tr > th, table > colgroup + thead > tr > th, table > thead > tr > th, table > caption + thead > tr > td, table > colgroup + thead > tr > td, table > thead > tr > td { border-top: 0; }");
+
+	// Styles for blockquote
+	oFile.WriteStringUTF8(L"blockquote { border-left: 3px solid #e9e9e9;  margin: 1.5em 0; padding: 0.5em 10px 0.5em 24px; font-size: 1.25rem; display: block; margin-top: 8pt; font-style: italic; color: #404040; }");
+
+	// Styles for code
+	oFile.WriteStringUTF8(L"code { padding: 2px 4px; font-size: 90%; color: #c7254e; background-color: #f9f2f4; border-radius: 4px; }");
+	oFile.WriteStringUTF8(L"pre code { padding: 0px; white-space: pre-wrap; border-radius: 0; background-color: #f5f5f5; color:black; }");
+	oFile.WriteStringUTF8(L"pre { display: block; padding: 9.5px; margin: 0 0 10px; line-height: 1.4; word-break: break-all; word-wrap: break-word; background-color: #f5f5f5; border: 1px solid #ccc; border-radius: 4px; font-size: 1em; }");
+	oFile.WriteStringUTF8(L"code, pre { font-family: Menlo, Monaco, Consolas, \"Courier New\", monospace; }");
+
+	// Styles for headings
+	oFile.WriteStringUTF8(L"h1 { font-size: 20pt; color: #0f4761; margin-top: 18pt; margin-bottom: 4pt; }");
+	oFile.WriteStringUTF8(L"h2 { font-size: 16pt; color: #0f4761; margin-top: 8pt; margin-bottom: 4pt; }");
+	oFile.WriteStringUTF8(L"h3 { font-size: 14pt; color: #0f4761; margin-top: 8pt; margin-bottom: 4pt; }");
+	oFile.WriteStringUTF8(L"h4 { font-style: italic; color: #0f4761; margin-top: 4pt; margin-bottom: 2pt; }");
+	oFile.WriteStringUTF8(L"h5 { color: #0f4761; margin-top: 4pt; margin-bottom: 2pt; }");
+	oFile.WriteStringUTF8(L"h6 { font-style: italic; color: #595959; margin-top: 2pt; margin-bottom: 0; }");
+
+	oFile.WriteStringUTF8(L"</style>");
+}
+
+bool ConvertMdFileToHtml(const std::wstring& wsPathToMdFile, const std::wstring& wsPathToHtmlFile)
+{
+	std::string sMdData;
+
+	if (!NSFile::CFileBinary::ReadAllTextUtf8A(wsPathToMdFile, sMdData))
+		return false;
+
+	NSFile::CFileBinary oFile;
+
+	if (!oFile.CreateFile(wsPathToHtmlFile))
+		return false;
+
+	oFile.WriteStringUTF8(L"<html><body>");
+
+	oFile.WriteStringUTF8(L"<head>");
+	//oFile.WriteStringUTF8(L"<meta charset=\"UTF-8\">");
+	oFile.WriteStringUTF8(L"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">");
+	WriteBaseHtmlStyles(oFile);
+	oFile.WriteStringUTF8(L"</head>");
+
+	bool bResult = true;
+
+	if (0 != md_html(sMdData.c_str(), sMdData.length(), ToHtmlFile, &oFile,
+					 MD_DIALECT_GITHUB | MD_FLAG_NOINDENTEDCODEBLOCKS | MD_HTML_FLAG_SKIP_UTF8_BOM,
+					 0))
+		bResult = false;
+
+	oFile.WriteStringUTF8(L"</body></html>");
+
+	oFile.CloseFile();
+
+	if (!bResult)
+		NSFile::CFileBinary::Remove(wsPathToHtmlFile);
+
+	return bResult;
+}
+}
+

Common/3dParty/md/md2html.h

@@ -0,0 +1,19 @@
+#ifndef MD2HTML_H
+#define MD2HTML_H
+
+#include <string>
+
+#ifndef MDCONVERTER_DECL_EXPORT
+#define MDCONVERTER_DECL_EXPORT
+#else
+#include "../../../DesktopEditor/common/base_export.h"
+#define MDCONVERTER_DECL_EXPORT Q_DECL_EXPORT
+#endif
+
+namespace Md
+{
+std::string MDCONVERTER_DECL_EXPORT ConvertMdStringToHtml(const std::string& sMdString);
+bool MDCONVERTER_DECL_EXPORT ConvertMdFileToHtml(const std::wstring& wsPathToMdFile, const std::wstring& wsPathToHtmlFile);
+}
+
+#endif // MD2HTML_H

Common/3dParty/md/md2html.pri

@@ -0,0 +1,11 @@
+DEFINES += MD4C_USE_UTF8
+
+HEADERS += $$PWD/md4c/src/md4c.h \
+           $$PWD/md4c/src/md4c-html.h \
+           $$PWD/md4c/src/entity.h \
+           $$PWD/md2html.h \
+
+SOURCES += $$PWD/md4c/src/md4c.c \
+           $$PWD/md4c/src/md4c-html.c \
+           $$PWD/md4c/src/entity.c \
+           $$PWD/md2html.cpp

Common/3dParty/md/test/TestMd.pro

@@ -0,0 +1,16 @@
+QT -= core
+QT -= gui
+
+TARGET = test
+TEMPLATE = app
+
+CONFIG += console
+CONFIG -= app_bundle
+
+CORE_ROOT_DIR = $$PWD/../../../../
+
+SOURCES += main.cpp
+
+include($$CORE_ROOT_DIR/Common/3dParty/md/md2html.pri)
+
+DESTDIR = $$PWD/build/$$CORE_BUILDS_PLATFORM_PREFIX

Common/3dParty/md/test/files/file-1.md

@@ -0,0 +1 @@
+ * foo **bar [link](http://example.com) baz**

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

@@ -0,0 +1,10 @@
+#include <iostream>
+
+#include "../md2html.h"
+
+int main(int argc, char *argv[])
+{
+	std::cout << (ConvertMdFileToHtml(L"YOUR_PATH", L"YOUR_PATH") ? "Good" : "Bad") << std::endl;
+
+	return 0;
+}

Common/OfficeFileFormatChecker.h

@@ -68,6 +68,7 @@ public:
 	bool isOOXFormatFile(const std::wstring& fileName, bool unpacked = false);
 	bool isOpenOfficeFormatFile(const std::wstring& fileName, std::wstring& documentID);
 	bool isOnlyOfficeFormatFile(const std::wstring& fileName);
+	bool isMacFormatFile(const std::wstring& fileName);
 
 	bool isDocFormatFile(const std::wstring& fileName);
 	bool isXlsFormatFile(const std::wstring& fileName);
@@ -80,6 +81,7 @@ public:
 	bool isMS_MITCRYPTOFormatFile(POLE::Storage* storage, std::wstring& documentID);
 	bool isVbaProjectFile(POLE::Storage* storage);
 	bool isMS_OFFCRYPTOFormatFile(const std::wstring& fileName, std::wstring& documentID);
+	bool isHwpFile(POLE::Storage* storage);
 
 	bool iXmlFile(const std::wstring& fileName);
 
@@ -101,9 +103,11 @@ public:
 	bool isBinaryDoctFormatFile(unsigned char* pBuffer, int dwBytes);
 	bool isBinaryXlstFormatFile(unsigned char* pBuffer, int dwBytes);
 	bool isBinaryPpttFormatFile(unsigned char* pBuffer, int dwBytes);
+	bool isBinaryVsdtFormatFile(unsigned char* pBuffer, int dwBytes);
 
 	bool isDjvuFormatFile(unsigned char* pBuffer, int dwBytes);
 	bool isMobiFormatFile(unsigned char* pBuffer, int dwBytes);
 	bool isFB2FormatFile(unsigned char* pBuffer, int dwBytes);
 	bool isXpsFile(const std::wstring& fileName);
+	bool isOFDFile(const std::wstring& fileName);
 };

Common/OfficeFileFormatChecker2.cpp

@@ -44,6 +44,7 @@
 
 #include "3dParty/pole/pole.h"
 #include <algorithm>
+#include <limits>
 
 #include "OfficeFileFormatDefines.h"
 
@@ -222,6 +223,16 @@ bool COfficeFileFormatChecker::isBinaryPpttFormatFile(unsigned char *pBuffer, in
 
 	return false;
 }
+bool COfficeFileFormatChecker::isBinaryVsdtFormatFile(unsigned char* pBuffer, int dwBytes)
+{
+	if (pBuffer == NULL)
+		return false;
+
+	if ((4 <= dwBytes) && ('V' == pBuffer[0] && 'S' == pBuffer[1] && 'D' == pBuffer[2] && 'Y' == pBuffer[3]))
+		return true;
+
+	return false;
+}
 bool COfficeFileFormatChecker::isPdfFormatFile(unsigned char *pBuffer, int dwBytes, std::wstring &documentID)
 {
 	if (pBuffer == NULL)
@@ -229,7 +240,7 @@ bool COfficeFileFormatChecker::isPdfFormatFile(unsigned char *pBuffer, int dwByt
 
 	documentID.clear();
 
-	if (dwBytes < 1)
+	if (dwBytes < 5 || (pBuffer[0] == 'P' && pBuffer[1] == 'K'))
 		return false;
 
 	pBuffer[dwBytes - 1] = '\0';
@@ -451,6 +462,20 @@ bool COfficeFileFormatChecker::isVbaProjectFile(POLE::Storage *storage)
 	}
 	return true;
 }
+bool COfficeFileFormatChecker::isHwpFile(POLE::Storage* storage)
+{
+	if (storage == NULL)
+		return false;
+
+	unsigned char buffer[10];
+
+	POLE::Stream stream(storage, L"BodyText/Section0");
+	if (stream.read(buffer, 10) < 1)
+	{
+		return false;
+	}	
+	return true;
+}
 bool COfficeFileFormatChecker::isXlsFormatFile(POLE::Storage *storage)
 {
 	if (storage == NULL)
@@ -721,6 +746,11 @@ bool COfficeFileFormatChecker::isOfficeFile(const std::wstring &_fileName)
 			nFileType = AVS_OFFICESTUDIO_FILE_OTHER_MS_VBAPROJECT;
 			return true;
 		}
+		else if (isHwpFile(&storage))
+		{
+			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HWP;
+			return true;
+		}
 	}
 	NSFile::CFileBinary file;
 	if (!file.OpenFile(fileName))
@@ -767,6 +797,20 @@ bool COfficeFileFormatChecker::isOfficeFile(const std::wstring &_fileName)
             bufferDetect = NULL;
             return true;
         }
+		else if (isOFDFile(fileName))
+		{
+			if (bufferDetect)
+				delete[] bufferDetect;
+			bufferDetect = NULL;
+			return true;
+		}
+		else if (isMacFormatFile(fileName))
+		{
+			if (bufferDetect)
+				delete[] bufferDetect;
+			bufferDetect = NULL;
+			return true;
+		}
 	}
 
 	//-----------------------------------------------------------------------------------------------
@@ -790,6 +834,10 @@ bool COfficeFileFormatChecker::isOfficeFile(const std::wstring &_fileName)
 		{
 			nFileType = AVS_OFFICESTUDIO_FILE_CANVAS_PRESENTATION;
 		}
+		else if (isBinaryVsdtFormatFile(bufferDetect, sizeRead)) // min size - 4
+		{
+			nFileType = AVS_OFFICESTUDIO_FILE_CANVAS_DRAW;
+		}
 		else if (isOOXFlatFormatFile(bufferDetect, sizeRead))
 		{
 			// nFileType;
@@ -889,6 +937,8 @@ bool COfficeFileFormatChecker::isOfficeFile(const std::wstring &_fileName)
 	}
 	else if (0 == sExt.compare(L".mht") || 0 == sExt.compare(L".mhtml"))
 		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_MHT;
+	else if (0 == sExt.compare(L".md"))
+		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_MD;
 	else if (0 == sExt.compare(L".csv") || 0 == sExt.compare(L".xls") || 0 == sExt.compare(L".xlsx") || 0 == sExt.compare(L".xlsb"))
 		nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_CSV;
 	else if (0 == sExt.compare(L".html") || 0 == sExt.compare(L".htm"))
@@ -897,7 +947,7 @@ bool COfficeFileFormatChecker::isOfficeFile(const std::wstring &_fileName)
 		nFileType = AVS_OFFICESTUDIO_FILE_CANVAS_PDF;
 	else if (0 == sExt.compare(L".doct")) // случай архива с html viewer
 		nFileType = AVS_OFFICESTUDIO_FILE_TEAMLAB_DOCY;
-	else if (0 == sExt.compare(L".txt") || 0 == sExt.compare(L".xml") || 0 == sExt.compare(L".rtf")	|| 0 == sExt.compare(L".doc") || 0 == sExt.compare(L".docx") || 0 == sExt.compare(L".md"))
+	else if (0 == sExt.compare(L".txt") || 0 == sExt.compare(L".xml") || 0 == sExt.compare(L".rtf")	|| 0 == sExt.compare(L".doc") || 0 == sExt.compare(L".docx"))
 		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_TXT;
 	else if (0 == sExt.compare(L".pages"))
 		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_PAGES;
@@ -1124,6 +1174,10 @@ bool COfficeFileFormatChecker::isOnlyOfficeFormatFile(const std::wstring &fileNa
 		{
 			nFileType = AVS_OFFICESTUDIO_FILE_TEAMLAB_PPTY;
 		}
+		else if (isBinaryVsdtFormatFile(pBuffer, nBufferSize))
+		{
+			nFileType = AVS_OFFICESTUDIO_FILE_TEAMLAB_VSDY;
+		}
 
 		delete[] pBuffer;
 		pBuffer = NULL;
@@ -1133,6 +1187,222 @@ bool COfficeFileFormatChecker::isOnlyOfficeFormatFile(const std::wstring &fileNa
 	}
 	return false;
 }
+
+struct TIWAField
+{
+	size_t m_unStart;
+	size_t m_unEnd;
+	unsigned m_uIndex;
+	unsigned m_unWireType;
+	uint64_t m_oValue;
+};
+
+bool ReadUVar(BYTE* pBuffer, size_t unEndPos, size_t& unPos, uint64_t& unValue)
+{
+	std::vector<unsigned char> arBytes;
+	arBytes.reserve(8);
+
+	unValue = 0;
+
+	bool bNext = true;
+	while (unPos < unEndPos && bNext)
+	{
+		const unsigned char c = pBuffer[unPos++];
+		arBytes.push_back((unsigned char)(c & ~0x80));
+		bNext = c & 0x80;
+	}
+
+	if (bNext && unPos == unEndPos)
+		return false;
+
+	for (std::vector<unsigned char>::const_reverse_iterator it = arBytes.rbegin(); it != arBytes.rend(); ++it)
+	{
+		if (std::numeric_limits<uint64_t>::max() >> 7 < unValue ||
+		    std::numeric_limits<uint64_t>::max() - (unValue << 7) < *it) // overflow
+		return false;
+
+		unValue = (unValue << 7) + *it;
+	}
+
+	return true;
+}
+
+bool ReadIWAField(BYTE* pBuffer, size_t unEndPos, size_t& unPos, TIWAField& oIWAField)
+{
+	if (NULL == pBuffer || unPos + 2 > unEndPos)
+		return false;
+
+	unsigned uSpec;
+
+	uSpec = (unsigned)pBuffer[unPos++];
+	oIWAField.m_unWireType = uSpec & 0x7;
+
+	oIWAField.m_unStart = unPos;
+
+	switch (oIWAField.m_unWireType)
+	{
+		case 0:
+		{
+			if (!ReadUVar(pBuffer, unEndPos, unPos, oIWAField.m_oValue))
+				return false;
+
+			break;
+		}
+		case 1:
+		{
+			unPos += 4;
+			break;
+		}
+		case 2:
+		{
+			uint64_t unLen;
+			if (!ReadUVar(pBuffer, unEndPos, unPos, unLen) || unPos + unLen > unEndPos)
+				return false;
+
+			oIWAField.m_unStart = unPos;
+			unPos += unLen;
+			break;
+		}
+		case 5:
+		{
+			unPos += 2;
+			break;
+		}
+		default:
+			return false;
+	}
+
+	oIWAField.m_unEnd = unPos;
+	oIWAField.m_uIndex = uSpec >> 3;
+
+	return true;
+}
+
+bool DetectIWorkFormat(const std::wstring& fileName, int &nType)
+{
+	COfficeUtils OfficeUtils(NULL);
+
+	ULONG unSize = 0;
+	BYTE* pBuffer = NULL;
+
+	HRESULT hresult = OfficeUtils.LoadFileFromArchive(fileName, L"Index/Document.iwa", &pBuffer, unSize);
+
+	if (hresult != S_OK || NULL == pBuffer)
+		return false;
+
+	#define CLEAR_BUFFER_AND_RETURN(return_value)\
+	do{\
+		delete[] pBuffer;\
+		return return_value;\
+	}while(false)
+
+	if (unSize < 13)
+		CLEAR_BUFFER_AND_RETURN(false);
+
+	size_t uPos = 6;
+
+	for (; uPos < 12; ++uPos)
+	{
+		if (0x08 == pBuffer[uPos] && 0x01 == pBuffer[uPos + 1])
+		{
+			--uPos;
+			break;
+		}
+	}
+
+	if (12 == uPos)
+		CLEAR_BUFFER_AND_RETURN(false);
+
+	uint64_t unHeaderLen;
+	if (!ReadUVar(pBuffer, unSize, uPos, unHeaderLen))
+		CLEAR_BUFFER_AND_RETURN(false);
+
+	const size_t uStartPos = uPos;
+
+	if (unHeaderLen < 8 || unSize < unHeaderLen + uStartPos)
+		CLEAR_BUFFER_AND_RETURN(false);
+
+	uPos += 2;
+
+	TIWAField oMessageField;
+
+	if (!ReadIWAField(pBuffer, uStartPos + unHeaderLen, uPos, oMessageField) || 2 != oMessageField.m_unWireType ||
+	    2 != oMessageField.m_uIndex)
+		CLEAR_BUFFER_AND_RETURN(false);
+
+	size_t uSubPos = oMessageField.m_unStart;
+	TIWAField oField;
+
+	if (!ReadIWAField(pBuffer, oMessageField.m_unEnd, uSubPos, oField) || 0 != oField.m_unWireType ||
+	    1 != oField.m_uIndex)
+		CLEAR_BUFFER_AND_RETURN(false);
+
+	switch (oField.m_oValue)
+	{
+		case 1:
+		{
+			uint32_t unDataLen = 0;
+
+			TIWAField oTempField;
+			if (ReadIWAField(pBuffer, oMessageField.m_unEnd, uSubPos, oTempField) &&
+			    ReadIWAField(pBuffer, oMessageField.m_unEnd, uSubPos, oTempField) && 0 == oTempField.m_unWireType &&
+			    3 == oTempField.m_uIndex)
+				unDataLen += oTempField.m_oValue;
+
+			size_t unTempPos = uStartPos + unHeaderLen;
+
+			// keynote: presentation ref in 2
+			// number: sheet ref in 1
+			if (ReadIWAField(pBuffer, uStartPos + unDataLen, unTempPos, oTempField) &&
+			    (2 != oTempField.m_unWireType || 1 != oTempField.m_uIndex || oTempField.m_unEnd - oTempField.m_unStart < 2))
+			{
+				nType = AVS_OFFICESTUDIO_FILE_PRESENTATION_KEY;
+				CLEAR_BUFFER_AND_RETURN(true);
+			}
+			else if (ReadIWAField(pBuffer, uStartPos + unDataLen, unTempPos, oTempField) &&
+			        (2 != oTempField.m_unWireType || 2 != oTempField.m_uIndex || oTempField.m_unEnd - oTempField.m_unStart < 2))
+			{
+				nType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_NUMBERS;
+				CLEAR_BUFFER_AND_RETURN(true);
+			}
+
+			break;
+		}
+		case 10000:
+		{
+			nType = AVS_OFFICESTUDIO_FILE_DOCUMENT_PAGES;
+			CLEAR_BUFFER_AND_RETURN(true);
+		}
+	}
+
+	CLEAR_BUFFER_AND_RETURN(false);
+}
+
+bool COfficeFileFormatChecker::isMacFormatFile(const std::wstring& fileName)
+{
+	if (DetectIWorkFormat(fileName, nFileType))
+		return true;
+
+	std::wstring::size_type nExtPos = fileName.rfind(L'.');
+	std::wstring sExt = L"unknown";
+
+	if (nExtPos != std::wstring::npos)
+		sExt = fileName.substr(nExtPos);
+
+	std::transform(sExt.begin(), sExt.end(), sExt.begin(), tolower);
+
+	if (0 == sExt.compare(L".pages"))
+		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_PAGES;
+	else if (0 == sExt.compare(L".numbers"))
+		nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_NUMBERS;
+	else if (0 == sExt.compare(L".key"))
+		nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_KEY;
+	else
+		return false;
+
+	return true;
+}
+
 bool COfficeFileFormatChecker::isOpenOfficeFormatFile(const std::wstring &fileName, std::wstring &documentID)
 {
 	documentID.clear();
@@ -1331,12 +1601,15 @@ bool COfficeFileFormatChecker::isOOXFlatFormatFile(unsigned char *pBuffer, int d
 	const char *xlsxPackage = "progid=\"Excel.Sheet\"";
 	const char *pptxPackage = "progid=\"PowerPoint.Show\"";
 	const char *packageFormatLine = "xmlns:pkg=\"http://schemas.microsoft.com/office/2006/xmlPackage\"";
+	const char* workbookFormatLine = "<Workbook";
+	const char* htmlFormatLine = "<html";
 
 	if (std::string::npos != xml_string.find(docxFormatLine))
 	{
 		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX_FLAT;
 	}
-	else if (std::string::npos != xml_string.find(xlsxFormatLine))
+	else if (std::string::npos != xml_string.find(xlsxFormatLine) && (	std::string::npos != xml_string.find(workbookFormatLine) ||
+																		std::string::npos == xml_string.find(htmlFormatLine)))
 	{
 		nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX_FLAT;
 	}
@@ -1397,6 +1670,14 @@ std::wstring COfficeFileFormatChecker::GetExtensionByType(int type)
 		return L".fodt";
 	case AVS_OFFICESTUDIO_FILE_DOCUMENT_OTT:
 		return L".ott";
+	case AVS_OFFICESTUDIO_FILE_DOCUMENT_PAGES:
+		return L".pages";
+	case AVS_OFFICESTUDIO_FILE_DOCUMENT_HWP:
+		return L".hwp";
+	case AVS_OFFICESTUDIO_FILE_DOCUMENT_HWPX:
+		return L".hwpx";
+	case AVS_OFFICESTUDIO_FILE_DOCUMENT_MD:
+		return L".md";
 
 	case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX:
 		return L".pptx";
@@ -1418,6 +1699,10 @@ std::wstring COfficeFileFormatChecker::GetExtensionByType(int type)
 		return L".fodp";
 	case AVS_OFFICESTUDIO_FILE_PRESENTATION_OTP:
 		return L".otp";
+	case AVS_OFFICESTUDIO_FILE_PRESENTATION_ODG:
+		return L".odg";
+	case AVS_OFFICESTUDIO_FILE_PRESENTATION_KEY:
+		return L".key";
 
 	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX:
 		return L".xlsx";
@@ -1439,6 +1724,8 @@ std::wstring COfficeFileFormatChecker::GetExtensionByType(int type)
 		return L".fods";
 	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_OTS:
 		return L".ots";
+	case AVS_OFFICESTUDIO_FILE_SPREADSHEET_NUMBERS:
+		return L".numbers";
 
 	case AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF:
 	case AVS_OFFICESTUDIO_FILE_DOCUMENT_OFORM_PDF:
@@ -1449,6 +1736,8 @@ std::wstring COfficeFileFormatChecker::GetExtensionByType(int type)
 		return L".djvu";
 	case AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS:
 		return L".xps";
+	case AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_OFD:
+		return L".ofd";
 	case AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_SVG:
 		return L".svg";
 	case AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_HTMLR:
@@ -1490,12 +1779,15 @@ std::wstring COfficeFileFormatChecker::GetExtensionByType(int type)
 	case AVS_OFFICESTUDIO_FILE_CANVAS_WORD:
 	case AVS_OFFICESTUDIO_FILE_CANVAS_SPREADSHEET:
 	case AVS_OFFICESTUDIO_FILE_CANVAS_PRESENTATION:
+	case AVS_OFFICESTUDIO_FILE_CANVAS_DRAW:
 		return L".bin";
 	case AVS_OFFICESTUDIO_FILE_OTHER_OLD_DOCUMENT:
 	case AVS_OFFICESTUDIO_FILE_TEAMLAB_DOCY:
 		return L".doct";
 	case AVS_OFFICESTUDIO_FILE_TEAMLAB_XLSY:
 		return L".xlst";
+	case AVS_OFFICESTUDIO_FILE_TEAMLAB_VSDY:
+		return L".vsdt";
 	case AVS_OFFICESTUDIO_FILE_OTHER_OLD_PRESENTATION:
 	case AVS_OFFICESTUDIO_FILE_OTHER_OLD_DRAWING:
 	case AVS_OFFICESTUDIO_FILE_TEAMLAB_PPTY:
@@ -1563,6 +1855,14 @@ int COfficeFileFormatChecker::GetFormatByExtension(const std::wstring &sExt)
 		return AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT_FLAT;
 	if (L".ott" == ext)
 		return AVS_OFFICESTUDIO_FILE_DOCUMENT_OTT;
+	if (L".pages" == ext)
+		return AVS_OFFICESTUDIO_FILE_DOCUMENT_PAGES;
+	if (L".hwp" == ext)
+		return AVS_OFFICESTUDIO_FILE_DOCUMENT_HWP;
+	if (L".hwpx" == ext)
+		return AVS_OFFICESTUDIO_FILE_DOCUMENT_HWPX;
+	if (L".md" == ext)
+		return AVS_OFFICESTUDIO_FILE_DOCUMENT_MD;
 
 	if (L".pptx" == ext)
 		return AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX;
@@ -1584,6 +1884,10 @@ int COfficeFileFormatChecker::GetFormatByExtension(const std::wstring &sExt)
 		return AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP_FLAT;
 	if (L".otp" == ext)
 		return AVS_OFFICESTUDIO_FILE_PRESENTATION_OTP;
+	if (L".odg" == ext)
+		return AVS_OFFICESTUDIO_FILE_PRESENTATION_ODG;
+	if (L".key" == ext)
+		return AVS_OFFICESTUDIO_FILE_PRESENTATION_KEY;
 
 	if (L".xlsx" == ext)
 		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX;
@@ -1611,6 +1915,8 @@ int COfficeFileFormatChecker::GetFormatByExtension(const std::wstring &sExt)
 		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_OTS;
 	if (L".ods" == ext)
 		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS;
+	if (L".numbers" == ext)
+		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_NUMBERS;
 
 	if (L".ooxml" == ext)
 		return AVS_OFFICESTUDIO_FILE_OTHER_OOXML;
@@ -1623,6 +1929,8 @@ int COfficeFileFormatChecker::GetFormatByExtension(const std::wstring &sExt)
 		return AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_DJVU;
 	if (L".xps" == ext || L".oxps" == ext)
 		return AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS;
+	if (L"ofd" == ext)
+		return AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_OFD;
 
 	if (L".jpg" == ext || L".jpeg" == ext || L".jpe" == ext || L".jfif" == ext)
 		return AVS_OFFICESTUDIO_FILE_IMAGE_JPG;
@@ -1657,6 +1965,8 @@ int COfficeFileFormatChecker::GetFormatByExtension(const std::wstring &sExt)
 		return AVS_OFFICESTUDIO_FILE_TEAMLAB_XLSY;
 	if (L".pptt" == ext)
 		return AVS_OFFICESTUDIO_FILE_TEAMLAB_PPTY;
+	if (L".vsdt" == ext)
+		return AVS_OFFICESTUDIO_FILE_TEAMLAB_VSDY;
 
 	if (L".vsdx" == ext)
 		return AVS_OFFICESTUDIO_FILE_DRAW_VSDX;
@@ -1759,3 +2069,26 @@ bool COfficeFileFormatChecker::isXpsFile(const std::wstring &fileName)
 	}
 	return false;
 }
+
+bool COfficeFileFormatChecker::isOFDFile(const std::wstring& fileName)
+{
+	COfficeUtils OfficeUtils(NULL);
+
+	ULONG nBufferSize = 0;
+	BYTE *pBuffer = NULL;
+
+	HRESULT hresult = OfficeUtils.LoadFileFromArchive(fileName, L"OFD.xml", &pBuffer, nBufferSize);
+	if (hresult == S_OK && pBuffer != NULL)
+	{
+		if (19 <= nBufferSize && NULL != strstr((char *)pBuffer, "ofd:OFD"))
+			nFileType = AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_OFD;
+
+		delete[] pBuffer;
+		pBuffer = NULL;
+
+		if (nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN)
+			return true;
+	}
+
+	return false;
+}

Common/OfficeFileFormats.h

@@ -58,7 +58,8 @@
 #define AVS_OFFICESTUDIO_FILE_DOCUMENT_OFORM_PDF		AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x0017
 #define AVS_OFFICESTUDIO_FILE_DOCUMENT_PAGES			AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x0018
 #define AVS_OFFICESTUDIO_FILE_DOCUMENT_HWP				AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x0019
-#define AVS_OFFICESTUDIO_FILE_DOCUMENT_HWPX				AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x0020
+#define AVS_OFFICESTUDIO_FILE_DOCUMENT_HWPX				AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x001a
+#define AVS_OFFICESTUDIO_FILE_DOCUMENT_MD				AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x001b
 
 #define AVS_OFFICESTUDIO_FILE_DOCUMENT_XML				AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x0030
 
@@ -103,6 +104,7 @@
 #define AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_HTMLRMenu	AVS_OFFICESTUDIO_FILE_CROSSPLATFORM + 0x0007
 #define AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_HTMLRCanvas	AVS_OFFICESTUDIO_FILE_CROSSPLATFORM + 0x0008
 #define AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDFA		AVS_OFFICESTUDIO_FILE_CROSSPLATFORM + 0x0009
+#define AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_OFD			AVS_OFFICESTUDIO_FILE_CROSSPLATFORM + 0x000a
 
 #define AVS_OFFICESTUDIO_FILE_IMAGE						0x0400
 #define AVS_OFFICESTUDIO_FILE_IMAGE_JPG					AVS_OFFICESTUDIO_FILE_IMAGE + 0x0001
@@ -138,12 +140,14 @@
 #define AVS_OFFICESTUDIO_FILE_TEAMLAB_DOCY				AVS_OFFICESTUDIO_FILE_TEAMLAB + 0x0001
 #define AVS_OFFICESTUDIO_FILE_TEAMLAB_XLSY				AVS_OFFICESTUDIO_FILE_TEAMLAB + 0x0002
 #define AVS_OFFICESTUDIO_FILE_TEAMLAB_PPTY				AVS_OFFICESTUDIO_FILE_TEAMLAB + 0x0003
+#define AVS_OFFICESTUDIO_FILE_TEAMLAB_VSDY				AVS_OFFICESTUDIO_FILE_TEAMLAB + 0x0004
 
 #define AVS_OFFICESTUDIO_FILE_CANVAS					0x2000
 #define AVS_OFFICESTUDIO_FILE_CANVAS_WORD				AVS_OFFICESTUDIO_FILE_CANVAS + 0x0001
 #define AVS_OFFICESTUDIO_FILE_CANVAS_SPREADSHEET		AVS_OFFICESTUDIO_FILE_CANVAS + 0x0002
 #define AVS_OFFICESTUDIO_FILE_CANVAS_PRESENTATION		AVS_OFFICESTUDIO_FILE_CANVAS + 0x0003
 #define AVS_OFFICESTUDIO_FILE_CANVAS_PDF				AVS_OFFICESTUDIO_FILE_CANVAS + 0x0004
+#define AVS_OFFICESTUDIO_FILE_CANVAS_DRAW				AVS_OFFICESTUDIO_FILE_CANVAS + 0x0005
 
 #define AVS_OFFICESTUDIO_FILE_DRAW						0x4000
 #define AVS_OFFICESTUDIO_FILE_DRAW_VSDX					AVS_OFFICESTUDIO_FILE_DRAW + 0x0001

Common/base.pri

@@ -47,7 +47,7 @@ win32 {
 DEFINES += COPYRIGHT_YEAR=$${CURRENT_YEAR}
 
 QMAKE_TARGET_COMPANY = $$PUBLISHER_NAME
-QMAKE_TARGET_COPYRIGHT = Copyright (C) $${PUBLISHER_NAME} $${CURRENT_YEAR}. All rights reserved
+QMAKE_TARGET_COPYRIGHT = © $${PUBLISHER_NAME} $${CURRENT_YEAR}. All rights reserved.
 
 # CONFIGURATION
 CONFIG(debug, debug|release) {
@@ -91,6 +91,10 @@ isEqual(QT_MAJOR_VERSION, 5) {
 
 greaterThan(QT_MAJOR_VERSION, 5) {
 	DEFINES += QT_VERSION_6
+
+	core_windows {
+		QMAKE_CXXFLAGS += /permissive-
+	}
 }
 
 ios {
@@ -108,6 +112,35 @@ win32:contains(QMAKE_TARGET.arch, x86_64): {
 win32:!contains(QMAKE_TARGET.arch, x86_64): {
 	CONFIG += core_win_32
 }
+win32:contains(QMAKE_TARGET.arch, arm64): {
+	CONFIG -= core_win_32
+	CONFIG += core_win_arm64
+}
+
+linux-clang-libc++ {
+    CONFIG += core_linux
+	CONFIG += core_linux_64
+	CONFIG += core_linux_clang
+	message("linux-64-clang-libc++")
+}
+linux-clang-libc++-32 {
+    CONFIG += core_linux
+	CONFIG += core_linux_32
+	CONFIG += core_linux_clang
+	message("linux-32-clang-libc++")
+}
+linux-clang {
+	CONFIG += core_linux
+	CONFIG += core_linux_64
+	CONFIG += core_linux_clang
+	message("linux-64-clang")
+}
+linux-clang-32 {
+	CONFIG += core_linux
+	CONFIG += core_linux_32
+	CONFIG += core_linux_clang
+	message("linux-32-clang")
+}
 
 linux-g++ {
 	CONFIG += core_linux
@@ -174,6 +207,25 @@ core_win_64 {
 
 core_linux {
 	DEFINES += LINUX _LINUX
+
+    QMAKE_CUSTOM_SYSROOT = $$(QMAKE_CUSTOM_SYSROOT)
+	QMAKE_CUSTOM_SYSROOT_BIN = $$(QMAKE_CUSTOM_SYSROOT)/usr/bin/
+
+    core_linux_64 {
+	    !linux_arm64 { # x86_64
+		    QMAKE_CUSTOM_SYSROOT_LIB = $$(QMAKE_CUSTOM_SYSROOT)/usr/lib/x86_64-linux-gnu
+			!isEmpty(QMAKE_CUSTOM_SYSROOT) {
+			    message("using custom sysroot $$QMAKE_CUSTOM_SYSROOT")
+				QMAKE_CC          = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "gcc")
+				QMAKE_CXX         = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "g++")
+				QMAKE_LINK        = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "g++")
+				QMAKE_LINK_SHLIB  = $$join(QMAKE_CUSTOM_SYSROOT_BIN, , , "g++")
+
+                QMAKE_CXXFLAGS    += --sysroot $$QMAKE_CUSTOM_SYSROOT
+				QMAKE_LFLAGS      += --sysroot $$QMAKE_CUSTOM_SYSROOT
+			}
+		}
+	}
 }
 core_linux_host_arm64 {
 	message("build on arm64")
@@ -196,6 +248,10 @@ core_mac {
 	}
 }
 
+core_linux_clang {
+	QMAKE_CFLAGS += -Wno-implicit-function-declaration
+}
+
 # PREFIXES
 core_windows {
 	CONFIG -= debug_and_release debug_and_release_target
@@ -256,6 +312,9 @@ core_win_32 {
 core_win_64 {
 	CORE_BUILDS_PLATFORM_PREFIX = win_64
 }
+core_win_arm64 {
+    CORE_BUILDS_PLATFORM_PREFIX = win_arm64
+}
 core_linux_32 {
 	CORE_BUILDS_PLATFORM_PREFIX = linux_32
 }
@@ -282,8 +341,8 @@ linux_arm64 {
 
 	!isEmpty(ARM64_TOOLCHAIN_BIN){
 		!isEmpty(ARM64_TOOLCHAIN_BIN_PREFIX){
-
 			ARM64_TOOLCHAIN_BIN_FULL = $$ARM64_TOOLCHAIN_BIN/$$ARM64_TOOLCHAIN_BIN_PREFIX
+			message("using arm64 toolchain $$ARM64_TOOLCHAIN_BIN")
 
 			QMAKE_CC          = $$join(ARM64_TOOLCHAIN_BIN_FULL, , , "gcc")
 			QMAKE_CXX         = $$join(ARM64_TOOLCHAIN_BIN_FULL, , , "g++")
@@ -416,6 +475,12 @@ message($$CORE_BUILDS_PLATFORM_PREFIX/$$CORE_BUILDS_CONFIGURATION_PREFIX)
 # COMPILER
 CONFIG += c++11
 
+#CONFIG += enable_cpp_17
+enable_cpp_17 {
+	CONFIG += c++1z
+	DEFINES += _LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION
+}
+
 !core_windows {
 	QMAKE_CXXFLAGS += -Wno-register
 	QMAKE_CFLAGS += -Wno-register
@@ -423,7 +488,11 @@ CONFIG += c++11
 
 core_linux {
 core_static_link_libstd {
-	QMAKE_LFLAGS += -static-libstdc++ -static-libgcc
+	!core_linux_clang {
+		QMAKE_LFLAGS += -static-libstdc++ -static-libgcc
+	} else {
+		# TODO: add libc++abi?
+	}
 	message(core_static_link_libstd)
 }
 plugin {
@@ -533,42 +602,45 @@ core_windows {
 DEFINES += CRYPTOPP_DISABLE_ASM
 }
 
-core_ios:CONFIG+=support_bundle_dylibs
+core_ios|core_mac {
+	CONFIG += support_bundle_dylibs
+}
 
 !support_bundle_dylibs:CONFIG-=bundle_dylibs
 
-core_ios {
-	bundle_dylibs {
-		plugin {
-			CONFIG -= plugin
-			CONFIG += lib_bundle
+bundle_dylibs {
+	plugin {
+		CONFIG -= plugin
+		CONFIG += lib_bundle
 
-			QMAKE_LFLAGS_SONAME = -Wl,-install_name,@rpath/
-			#QMAKE_LFLAGS += -Xlinker -rpath -Xlinker @executable_path/Frameworks
-			#QMAKE_LFLAGS += -Xlinker -rpath -Xlinker @loader_path/Frameworks
+		QMAKE_LFLAGS_SONAME = -Wl,-install_name,@rpath/
+		#QMAKE_LFLAGS += -Xlinker -rpath -Xlinker @executable_path/Frameworks
+		#QMAKE_LFLAGS += -Xlinker -rpath -Xlinker @loader_path/Frameworks
 
-			# correct version to < 256
-			VERSIONS = $$split(VERSION, ".")
-			VERSION_1 = $$member(VERSIONS, 0)
-			VERSION_2 = $$member(VERSIONS, 1)
-			VERSION_3 = $$member(VERSIONS, 2)
-			VERSION_4 = $$member(VERSIONS, 3)
+		# correct version to < 256
+		VERSIONS = $$split(VERSION, ".")
+		VERSION_1 = $$member(VERSIONS, 0)
+		VERSION_2 = $$member(VERSIONS, 1)
+		VERSION_3 = $$member(VERSIONS, 2)
+		VERSION_4 = $$member(VERSIONS, 3)
 
-			greaterThan(VERSION_1, 255): VERSION_1 = 255
-			greaterThan(VERSION_2, 255): VERSION_2 = 255
-			greaterThan(VERSION_3, 255): VERSION_3 = 255
-			greaterThan(VERSION_4, 255): VERSION_4 = 255
+		greaterThan(VERSION_1, 255): VERSION_1 = 255
+		greaterThan(VERSION_2, 255): VERSION_2 = 255
+		greaterThan(VERSION_3, 255): VERSION_3 = 255
+		greaterThan(VERSION_4, 255): VERSION_4 = 255
 
-			VERSION_CORRECT = $$VERSION_1
-			VERSION_CORRECT = $$join(VERSION_CORRECT, "", "", ".")
-			VERSION_CORRECT = $$join(VERSION_CORRECT, "", "", $$VERSION_2)
-			VERSION_CORRECT = $$join(VERSION_CORRECT, "", "", ".")
-			VERSION_CORRECT = $$join(VERSION_CORRECT, "", "", $$VERSION_3)
-			VERSION_CORRECT = $$join(VERSION_CORRECT, "", "", ".")
-			VERSION_CORRECT = $$join(VERSION_CORRECT, "", "", $$VERSION_4)
+		VERSION_CORRECT = $$VERSION_1
+		VERSION_CORRECT = $$join(VERSION_CORRECT, "", "", ".")
+		VERSION_CORRECT = $$join(VERSION_CORRECT, "", "", $$VERSION_2)
+		VERSION_CORRECT = $$join(VERSION_CORRECT, "", "", ".")
+		VERSION_CORRECT = $$join(VERSION_CORRECT, "", "", $$VERSION_3)
+		VERSION_CORRECT = $$join(VERSION_CORRECT, "", "", ".")
+		VERSION_CORRECT = $$join(VERSION_CORRECT, "", "", $$VERSION_4)
 
-			VERSION = $$VERSION_CORRECT
-		}
+		VERSION = $$VERSION_CORRECT
+		MAJOR_VERSION = $$VERSION_1
+		# set framework version as A
+		QMAKE_FRAMEWORK_VERSION = A
 	}
 }
 

Common/js/.gitignore

@@ -1 +1,2 @@
 emsdk
+__pycache__

DesktopEditor/agg-2.4/include/agg_color_rgba.h

@@ -416,6 +416,16 @@ namespace agg
         {
             return self_type(rgba::from_wavelength(wl, gamma));
         }
+
+		bool operator==(const self_type& other)
+		{
+			return a == other.a && r == other.r && g == other.g && b == other.b;
+		}
+
+		bool operator!=(const self_type& other)
+		{
+			return !operator==(other);
+		}
     };
 
 

DesktopEditor/agg-2.4/include/agg_pixfmt_rgba.h

@@ -207,9 +207,9 @@ namespace agg
 			}
 
 			p[Order::A] = (value_type)((alpha + a) - ((alpha * a + base_mask) >> base_shift));
-			p[Order::R] = (value_type)((alpha * cr + a * r - ((a * r * alpha + base_mask) >> base_shift)) / p[Order::A]);
-			p[Order::G] = (value_type)((alpha * cg + a * g - ((a * g * alpha + base_mask) >> base_shift)) / p[Order::A]);
-			p[Order::B] = (value_type)((alpha * cb + a * b - ((a * b * alpha + base_mask) >> base_shift)) / p[Order::A]);
+			if (r != cr) p[Order::R] = (value_type)((alpha * cr + a * r - ((a * r * alpha + base_mask) >> base_shift)) / p[Order::A]);
+			if (g != cg) p[Order::G] = (value_type)((alpha * cg + a * g - ((a * g * alpha + base_mask) >> base_shift)) / p[Order::A]);
+			if (b != cb) p[Order::B] = (value_type)((alpha * cb + a * b - ((a * b * alpha + base_mask) >> base_shift)) / p[Order::A]);
 		}
 
 		static AGG_INLINE void blend_pix_subpix(value_type* p,
@@ -1465,7 +1465,29 @@ namespace agg
         }
     };
 
+    template<class ColorT, class Order> struct comp_op_rgba_draw_on_black
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        enum base_scale_e
+        {
+            base_shift = color_type::base_shift,
+            base_mask  = color_type::base_mask
+        };
 
+        static AGG_INLINE void blend_pix(value_type* p,
+                                         unsigned sr, unsigned sg, unsigned sb,
+                                         unsigned sa, unsigned cover)
+        {
+
+            if (0x00 != p[Order::R] || 0x00 != p[Order::G] || 0x00 != p[Order::B])
+                return;
+
+            comp_op_rgba_src_over   <ColorT,Order>::blend_pix(p, sr, sg, sb, sa, cover);
+        }
+    };
 
 
 
@@ -1515,6 +1537,9 @@ namespace agg
         comp_op_rgba_contrast   <ColorT,Order>::blend_pix,
         comp_op_rgba_invert     <ColorT,Order>::blend_pix,
         comp_op_rgba_invert_rgb <ColorT,Order>::blend_pix,
+
+        //Custom function
+        comp_op_rgba_draw_on_black<ColorT,Order>::blend_pix,
         0
     };
 
@@ -1551,6 +1576,9 @@ namespace agg
         comp_op_invert,        //----comp_op_invert
         comp_op_invert_rgb,    //----comp_op_invert_rgb
 
+        //Custom modes
+        comp_op_draw_on_black, //----comp_op_draw_on_black
+
         end_of_comp_op_e
     };
 

DesktopEditor/agg-2.4/include/test_grads/custom_gradients.h

@@ -1000,7 +1000,17 @@ namespace agg
 				{
 					if (i < RES && j < RES)
 					{
-						precalc[i][j] = c;
+						if (m_oGradientInfo.luminocity)
+						{
+							ColorT fillC;
+							fillC.r = m_oGradientInfo.shading.fill_color.r * c.r / 255 + 255 - c.r;
+							fillC.g = m_oGradientInfo.shading.fill_color.g * c.g / 255 + 255 - c.g;
+							fillC.b = m_oGradientInfo.shading.fill_color.b * c.b / 255 + 255 - c.b;
+							fillC.a = 255;
+							precalc[i][j] = fillC;
+						}
+						else
+							precalc[i][j] = c;
 					}
 				}
 			}

DesktopEditor/common/Directory.cpp

@@ -506,7 +506,7 @@ namespace NSDirectory
 		rmdir((char*)pUtf8);
 		delete [] pUtf8;
 
-		if (deleteRoot = false)CreateDirectory(strDirectory);
+		if (deleteRoot == false)CreateDirectory(strDirectory);
 #elif MAC
 		BYTE* pUtf8 = NULL;
 		LONG lLen = 0;
@@ -514,7 +514,7 @@ namespace NSDirectory
 		rmdir((char*)pUtf8);
 		delete [] pUtf8;
 
-		if (deleteRoot = false)CreateDirectory(strDirectory);
+		if (deleteRoot == false)CreateDirectory(strDirectory);
 #endif
 	}
 	std::wstring GetFolderPath(const std::wstring& wsFolderPath)

DesktopEditor/common/File.cpp

@@ -1629,6 +1629,10 @@ namespace NSFile
 		{
 			wsTemp = L"";
 		}
+#if defined(_WIN32) || defined (_WIN64)
+		if (wsTempDir)
+			free(wsTempDir);
+#endif
 		wsTemp += L"x";
 		int nTime = (int)time(NULL);
 		for (int nIndex = 0; nIndex < 1000; ++nIndex)
@@ -1864,7 +1868,7 @@ namespace NSFile
 
 namespace NSFile
 {
-	bool CBase64Converter::Encode(BYTE* pDataSrc, int nLenSrc, char*& pDataDst, int& nLenDst, DWORD dwFlags)
+	bool CBase64Converter::Encode(const BYTE* pDataSrc, int nLenSrc, char*& pDataDst, int& nLenDst, DWORD dwFlags)
 	{
 		if (!pDataSrc || nLenSrc < 1)
 			return false;

DesktopEditor/common/File.h

@@ -212,7 +212,7 @@ namespace NSFile
 	class KERNEL_DECL CBase64Converter
 	{
 	public:
-		static bool Encode(BYTE* pDataSrc, int nLenSrc, char*& pDataDst, int& nLenDst, DWORD dwFlags = NSBase64::B64_BASE64_FLAG_NONE);
+		static bool Encode(const BYTE* pDataSrc, int nLenSrc, char*& pDataDst, int& nLenDst, DWORD dwFlags = NSBase64::B64_BASE64_FLAG_NONE);
 		static bool Decode(const char* pDataSrc, int nLenSrc, BYTE*& pDataDst, int& nLenDst);
 	};
 

DesktopEditor/common/ProcessEnv.h

@@ -46,6 +46,7 @@ namespace NSProcessEnv
 		static const char* gc_proxy               = "proxy";
 		static const char* gc_proxyUser           = "proxyUser";
 		static const char* gc_proxyHeader         = "proxyHeader";
+		static const char* gc_oformAsPdf          = "oformAsPdf";
 	}
 
 	// serialize

DesktopEditor/common/StringBuilder.cpp

@@ -319,7 +319,14 @@ namespace NSStringUtils
 	{
 		WriteEncodeXmlString(sString.c_str(), (int)sString.length());
 	}
-
+	void CStringBuilder::WriteEncodeXmlString(const std::string& sString)
+	{
+		WriteEncodeXmlString(std::wstring(sString.begin(), sString.end()));
+	}
+	void CStringBuilder::WriteUtf8EncodeXmlString(const std::string& sString)
+    {
+        WriteEncodeXmlString(NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)sString.c_str(), sString.size()));
+	}
 	void CStringBuilder::WriteEncodeXmlString(const wchar_t* pString, int nCount)
 	{
 		if (sizeof(wchar_t) == 2)

DesktopEditor/common/StringBuilder.h

@@ -110,6 +110,9 @@ namespace NSStringUtils
 		void WriteEncodeXmlString(const std::wstring& sString);
 		void WriteEncodeXmlString(const wchar_t* pString, int nCount = -1);
 
+		void WriteEncodeXmlString(const std::string& sString);
+		void WriteUtf8EncodeXmlString(const std::string& sString);
+
 		void WriteEncodeXmlStringHHHH(const std::wstring& sString);
 		void WriteEncodeXmlStringHHHH(const wchar_t* pString, int nCount = -1);
 

DesktopEditor/common/SystemUtils.h

@@ -1,4 +1,4 @@
-/*
+/*
  * (c) Copyright Ascensio System SIA 2010-2023
  *
  * This program is a free software product. You can redistribute it and/or
@@ -59,7 +59,7 @@ namespace NSSystemUtils
 	static const wchar_t* gc_EnvLastModifiedBy = L"LAST_MODIFIED_BY";
 	static const wchar_t* gc_EnvModified = L"MODIFIED";
 	static const wchar_t* gc_EnvMemoryLimit = L"X2T_MEMORY_LIMIT";
-	static const wchar_t* gc_EnvMemoryLimitDefault = L"4GiB";
+	static const wchar_t* gc_EnvMemoryLimitDefault = L"3GiB";
 
     KERNEL_DECL std::string GetEnvVariableA(const std::wstring& strName);
     KERNEL_DECL std::wstring GetEnvVariable(const std::wstring& strName);

DesktopEditor/cximage/png/pngpriv.h

@@ -332,6 +332,7 @@
     *  DBL_MAX  Maximum floating point number (can be set to an arbitrary value)
     */
 #  include <float.h>
+#  include <math.h>
 
 #  if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \
     defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)

DesktopEditor/doctrenderer/addon/docbuilder_addon.h

@@ -0,0 +1,61 @@
+/*
+ * (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
+ *
+ */
+#ifndef DOC_BUILDER_ADDON_PRIVATE
+#define DOC_BUILDER_ADDON_PRIVATE
+
+#include <string>
+#include "../docbuilder.h"
+
+namespace NSDoctRenderer
+{
+	class CDocBuilderAddon
+	{
+	private:
+		std::wstring m_sWorkDirectory;
+	public:
+		CDocBuilderAddon(const std::wstring& sWorkDir)
+		{
+			m_sWorkDirectory = sWorkDir;
+		}
+	public:
+		std::wstring GetX2tSaveAddon(NSDoctRenderer::CDocBuilder* builder, const int& filetype)
+		{
+			return L"";
+		}
+		int GetX2tPreSaveError(NSDoctRenderer::CDocBuilder* builder, const int& filetype)
+		{
+			return 0;
+		}
+	};
+}
+
+#endif // DOC_BUILDER_ADDON_PRIVATE

DesktopEditor/doctrenderer/app_builder/main.cpp

@@ -33,6 +33,7 @@
 #include "./../common_deploy.h"
 #include "../docbuilder.h"
 #include "../../common/File.h"
+#include "../../common/SystemUtils.h"
 
 #ifdef LINUX
 #include "../../../DesktopEditor/common/File.h"
@@ -78,6 +79,15 @@ void parse_args(NSDoctRenderer::CDocBuilder* builder, int argc, char *argv[])
 	}
 }
 
+bool CheckLicense(const std::wstring& sSrc, const std::wstring& sDst)
+{
+	if (sDst.empty())
+		return false;
+	NSFile::CFileBinary::Remove(sDst);
+	NSFile::CFileBinary::Copy(sSrc, sDst);
+	return NSFile::CFileBinary::Exists(sDst);
+}
+
 #ifdef WIN32
 int wmain(int argc, wchar_t *argv[])
 #else
@@ -89,6 +99,7 @@ int main(int argc, char *argv[])
 
 	bool bIsHelp = false;
 	bool bIsFonts = false;
+	bool bIsLicense = false;
 	for (int i = 0; i < argc; ++i)
 	{
 #ifdef WIN32
@@ -121,6 +132,33 @@ int main(int argc, char *argv[])
 		{
 			bIsFonts = true;
 		}
+		else if (sParam == "-register")
+		{
+			bIsLicense = true;
+		}
+		else
+		{
+			if (bIsLicense)
+			{
+				std::wstring sLicensePathSrc = UTF8_TO_U(sParam);
+				if (!NSFile::CFileBinary::Exists(sLicensePathSrc))
+					return 1;
+
+				std::wstring sLicensePath = NSSystemUtils::GetEnvVariable(L"ONLYOFFICE_BUILDER_LICENSE");
+				if (CheckLicense(sLicensePathSrc, sLicensePath))
+					return 0;
+
+				sLicensePath = NSFile::GetProcessDirectory() + L"/license.xml";
+				if (CheckLicense(sLicensePathSrc, sLicensePath))
+					return 0;
+
+				sLicensePath = NSSystemUtils::GetAppDataDir() + L"/docbuilder/license.xml";
+				if (CheckLicense(sLicensePathSrc, sLicensePath))
+					return 0;
+
+				return 1;
+			}
+		}
 	}
 
 	if (bIsFonts)

DesktopEditor/doctrenderer/config.h

@@ -191,7 +191,7 @@ namespace NSDoctRenderer
 			m_strSdkPath = oNode.ReadNodeText(L"sdkjs");
 			if (!m_strSdkPath.empty())
 			{
-				if (!NSDirectory::Exists(m_strSdkPath))
+				if (0 == m_strSdkPath.find(L"./") || !NSDirectory::Exists(m_strSdkPath))
 					m_strSdkPath = sConfigDir + m_strSdkPath;
 			}
 

DesktopEditor/doctrenderer/docbuilder.cpp

@@ -47,14 +47,6 @@ namespace NSDoctRenderer
 		RELEASEOBJECT(m_pInternal);
 	}
 
-	int CDocBuilder::OpenFile(const wchar_t* path, const wchar_t* params)
-	{
-		m_pInternal->m_nFileType = -1;
-		if (!NSDirectory::Exists(m_pInternal->m_sTmpFolder))
-			NSDirectory::CreateDirectory(m_pInternal->m_sTmpFolder);
-
-		return m_pInternal->OpenFile(path, params);
-	}
 	int CDocBuilder::SaveFile(const int& type, const wchar_t* path, const wchar_t* params)
 	{
 		return m_pInternal->SaveFile(type, path, params);
@@ -65,7 +57,7 @@ namespace NSDoctRenderer
 	}
 	bool CDocBuilder::ExecuteCommand(const wchar_t* command, CDocBuilderValue* retValue)
 	{
-		return m_pInternal->ExecuteCommand(command, retValue);
+		return m_pInternal->ExecuteCommand(command, retValue, false, false);
 	}
 
 	CDocBuilderContext CDocBuilder::GetContext(bool enterContext)

DesktopEditor/doctrenderer/docbuilder.h

@@ -475,6 +475,13 @@ namespace NSDoctRenderer
 		 */
 		void SetPropertyW(const wchar_t* param, const wchar_t* value);
 
+		/**
+		 * GetProperty method.
+		 * @param param The parameter name in the Unicode format, the value is always --argument.
+		 * @return int value for property
+		 */
+		int GetPropertyInt(const wchar_t* param);
+
 		/**
 		 * Writes data to the log file. It is used for logs in JS code.
 		 * @param path The path to the file where all the logs will be written.
@@ -526,6 +533,7 @@ namespace NSDoctRenderer
 		CDocBuilder_Private* m_pInternal;
 
 		friend class CBuilderDocumentEmbed;
+		friend class CBuilderEmbed;
 	};
 
 	/**

DesktopEditor/doctrenderer/docbuilder.java/src/java/docbuilder/utils/NativeLibraryLoader.java

@@ -23,6 +23,30 @@ public class NativeLibraryLoader {
         }
     }
 
+    private static String libPrefix;
+    private static String libExtension;
+
+    private static boolean loadIfExist(String libPath) {
+        File libFile = new File(libPath);
+        if (libFile.exists()) {
+            System.load(libPath);
+            return true;
+        }
+        return false;
+    }
+
+    private static void load(Path libDirPath, String libName) {
+        String libPath = libDirPath.resolve(libPrefix + libName + libExtension).toString();
+        if (OSChecker.isMac()) {
+            if (!loadIfExist(libPath)) {
+                // if dylib does not exist, load framework library
+                System.load(libDirPath.resolve(libName + ".framework/" + libName).toString());
+            }
+        } else {
+            System.load(libPath);
+        }
+    }
+
     static {
         try {
             Path libDirPath = getLibPath();
@@ -31,8 +55,8 @@ public class NativeLibraryLoader {
                 System.load(libDirPath.resolve("icudt58.dll").toString());
                 System.load(libDirPath.resolve("icuuc58.dll").toString());
             } else if (OSChecker.isMac()) {
-                System.load(libDirPath.resolve("libicudata.58.dylib").toString());
-                System.load(libDirPath.resolve("libicuuc.58.dylib").toString());
+                loadIfExist(libDirPath.resolve("libicudata.58.dylib").toString());
+                loadIfExist(libDirPath.resolve("libicuuc.58.dylib").toString());
             } else if (OSChecker.isLinux()) {
                 System.load(libDirPath.resolve("libicudata.so.58").toString());
                 System.load(libDirPath.resolve("libicuuc.so.58").toString());
@@ -42,24 +66,25 @@ public class NativeLibraryLoader {
 
             String[] libs = {"UnicodeConverter", "kernel", "kernel_network", "graphics", "PdfFile", "XpsFile", "DjVuFile", "DocxRenderer", "doctrenderer", "docbuilder.jni"};
 
-            String prefix = "";
+            libPrefix = "";
             if (OSChecker.isMac() || OSChecker.isLinux()) {
-                prefix = "lib";
+                libPrefix = "lib";
             }
 
-            String extension = "";
+            libExtension = "";
             if (OSChecker.isWindows()) {
-                extension = ".dll";
+                libExtension = ".dll";
             } else if (OSChecker.isMac()) {
-                extension = ".dylib";
+                libExtension = ".dylib";
             } else {
-                extension = ".so";
+                libExtension = ".so";
             }
 
             for (String lib : libs) {
-                System.load(libDirPath.resolve(prefix + lib + extension).toString());
+                load(libDirPath, lib);
             }
-        } catch (UnsatisfiedLinkError e) {
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
             throw new RuntimeException("Cannot load dynamic libraries. Check if JAR file is in the same directory as all docbuilder libraries.");
         }
     }

DesktopEditor/doctrenderer/docbuilder.java/src/jni/docbuilder_CDocBuilder.cpp

@@ -16,18 +16,18 @@ static std::wstring wstringFromJavaString(JNIEnv* env, jstring jstr)
 	return wstr;
 }
 
-jlong Java_docbuilder_CDocBuilder_c_1Create(JNIEnv* env, jclass cls)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilder_c_1Create(JNIEnv* env, jclass cls)
 {
 	return reinterpret_cast<jlong>(new CDocBuilder());
 }
 
-void Java_docbuilder_CDocBuilder_c_1Destroy(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilder_c_1Destroy(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	delete pSelf;
 }
 
-jint Java_docbuilder_CDocBuilder_c_1OpenFile(JNIEnv* env, jclass cls, jlong self, jstring path, jstring params)
+JNIEXPORT jint JNICALL Java_docbuilder_CDocBuilder_c_1OpenFile(JNIEnv* env, jclass cls, jlong self, jstring path, jstring params)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	std::wstring strPath = wstringFromJavaString(env, path);
@@ -35,34 +35,34 @@ jint Java_docbuilder_CDocBuilder_c_1OpenFile(JNIEnv* env, jclass cls, jlong self
 	return (jint)pSelf->OpenFile(strPath.c_str(), strParams.c_str());
 }
 
-jboolean Java_docbuilder_CDocBuilder_c_1CreateFileByType(JNIEnv* env, jclass cls, jlong self, jint type)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilder_c_1CreateFileByType(JNIEnv* env, jclass cls, jlong self, jint type)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	return (jboolean)pSelf->CreateFile((int)type);
 }
 
-jboolean Java_docbuilder_CDocBuilder_c_1CreateFileByExtension(JNIEnv* env, jclass cls, jlong self, jstring extension)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilder_c_1CreateFileByExtension(JNIEnv* env, jclass cls, jlong self, jstring extension)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	std::wstring strExtension = wstringFromJavaString(env, extension);
 	return (jboolean)pSelf->CreateFile(strExtension.c_str());
 }
 
-void Java_docbuilder_CDocBuilder_c_1SetTmpFolder(JNIEnv* env, jclass cls, jlong self, jstring folder)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilder_c_1SetTmpFolder(JNIEnv* env, jclass cls, jlong self, jstring folder)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	std::wstring strFolder = wstringFromJavaString(env, folder);
 	pSelf->SetTmpFolder(strFolder.c_str());
 }
 
-jint Java_docbuilder_CDocBuilder_c_1SaveFileByType(JNIEnv* env, jclass cls, jlong self, jint type, jstring path)
+JNIEXPORT jint JNICALL Java_docbuilder_CDocBuilder_c_1SaveFileByType(JNIEnv* env, jclass cls, jlong self, jint type, jstring path)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	std::wstring strPath = wstringFromJavaString(env, path);
 	return (jint)pSelf->SaveFile((int)type, strPath.c_str());
 }
 
-jint Java_docbuilder_CDocBuilder_c_1SaveFileByTypeWithParams(JNIEnv* env, jclass cls, jlong self, jint type, jstring path, jstring params)
+JNIEXPORT jint JNICALL Java_docbuilder_CDocBuilder_c_1SaveFileByTypeWithParams(JNIEnv* env, jclass cls, jlong self, jint type, jstring path, jstring params)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	std::wstring strPath = wstringFromJavaString(env, path);
@@ -70,7 +70,7 @@ jint Java_docbuilder_CDocBuilder_c_1SaveFileByTypeWithParams(JNIEnv* env, jclass
 	return (jint)pSelf->SaveFile((int)type, strPath.c_str(), strParams.c_str());
 }
 
-jint Java_docbuilder_CDocBuilder_c_1SaveFileByExtension(JNIEnv* env, jclass cls, jlong self, jstring extension, jstring path)
+JNIEXPORT jint JNICALL Java_docbuilder_CDocBuilder_c_1SaveFileByExtension(JNIEnv* env, jclass cls, jlong self, jstring extension, jstring path)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	std::wstring strExtension = wstringFromJavaString(env, extension);
@@ -78,7 +78,7 @@ jint Java_docbuilder_CDocBuilder_c_1SaveFileByExtension(JNIEnv* env, jclass cls,
 	return (jint)pSelf->SaveFile(strExtension.c_str(), strPath.c_str());
 }
 
-jint Java_docbuilder_CDocBuilder_c_1SaveFileByExtensionWithParams(JNIEnv* env, jclass cls, jlong self, jstring extension, jstring path, jstring params)
+JNIEXPORT jint JNICALL Java_docbuilder_CDocBuilder_c_1SaveFileByExtensionWithParams(JNIEnv* env, jclass cls, jlong self, jstring extension, jstring path, jstring params)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	std::wstring strExtension = wstringFromJavaString(env, extension);
@@ -87,20 +87,20 @@ jint Java_docbuilder_CDocBuilder_c_1SaveFileByExtensionWithParams(JNIEnv* env, j
 	return (jint)pSelf->SaveFile(strExtension.c_str(), strPath.c_str(), strParams.c_str());
 }
 
-void Java_docbuilder_CDocBuilder_c_1CloseFile(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilder_c_1CloseFile(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	pSelf->CloseFile();
 }
 
-jboolean Java_docbuilder_CDocBuilder_c_1ExecuteCommand(JNIEnv* env, jclass cls, jlong self, jstring command)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilder_c_1ExecuteCommand(JNIEnv* env, jclass cls, jlong self, jstring command)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	std::wstring strCommand = wstringFromJavaString(env, command);
 	return (jboolean)pSelf->ExecuteCommand(strCommand.c_str());
 }
 
-jboolean Java_docbuilder_CDocBuilder_c_1ExecuteCommandWithRetValue(JNIEnv* env, jclass cls, jlong self, jstring command, jlong retValue)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilder_c_1ExecuteCommandWithRetValue(JNIEnv* env, jclass cls, jlong self, jstring command, jlong retValue)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	std::wstring strCommand = wstringFromJavaString(env, command);
@@ -108,14 +108,14 @@ jboolean Java_docbuilder_CDocBuilder_c_1ExecuteCommandWithRetValue(JNIEnv* env,
 	return (jboolean)pSelf->ExecuteCommand(strCommand.c_str(), pRetValue);
 }
 
-jboolean Java_docbuilder_CDocBuilder_c_1Run(JNIEnv* env, jclass cls, jlong self, jstring path)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilder_c_1Run(JNIEnv* env, jclass cls, jlong self, jstring path)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	std::wstring strPath = wstringFromJavaString(env, path);
 	return (jboolean)pSelf->Run(strPath.c_str());
 }
 
-jboolean Java_docbuilder_CDocBuilder_c_1RunText(JNIEnv* env, jclass cls, jlong self, jstring commands)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilder_c_1RunText(JNIEnv* env, jclass cls, jlong self, jstring commands)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	const char* strUtfCommands = env->GetStringUTFChars(commands, nullptr);
@@ -124,7 +124,7 @@ jboolean Java_docbuilder_CDocBuilder_c_1RunText(JNIEnv* env, jclass cls, jlong s
 	return result;
 }
 
-void Java_docbuilder_CDocBuilder_c_1SetProperty(JNIEnv* env, jclass cls, jlong self, jstring param, jstring value)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilder_c_1SetProperty(JNIEnv* env, jclass cls, jlong self, jstring param, jstring value)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	const char* strUtfParam = env->GetStringUTFChars(param, nullptr);
@@ -133,7 +133,7 @@ void Java_docbuilder_CDocBuilder_c_1SetProperty(JNIEnv* env, jclass cls, jlong s
 	env->ReleaseStringUTFChars(param, strUtfParam);
 }
 
-void Java_docbuilder_CDocBuilder_c_1WriteData(JNIEnv* env, jclass cls, jlong self, jstring path, jstring data, jboolean append)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilder_c_1WriteData(JNIEnv* env, jclass cls, jlong self, jstring path, jstring data, jboolean append)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	std::wstring strPath = wstringFromJavaString(env, path);
@@ -141,13 +141,13 @@ void Java_docbuilder_CDocBuilder_c_1WriteData(JNIEnv* env, jclass cls, jlong sel
 	pSelf->WriteData(strPath.c_str(), strData.c_str(), (bool)append);
 }
 
-jboolean Java_docbuilder_CDocBuilder_c_1IsSaveWithDoctrendererMode(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilder_c_1IsSaveWithDoctrendererMode(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	return (jboolean)pSelf->IsSaveWithDoctrendererMode();
 }
 
-jstring Java_docbuilder_CDocBuilder_c_1GetVersion(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jstring JNICALL Java_docbuilder_CDocBuilder_c_1GetVersion(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	char* strUtfVersion = pSelf->GetVersion();
@@ -156,30 +156,30 @@ jstring Java_docbuilder_CDocBuilder_c_1GetVersion(JNIEnv* env, jclass cls, jlong
 	return jstrVersion;
 }
 
-jlong Java_docbuilder_CDocBuilder_c_1GetContext(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilder_c_1GetContext(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	return reinterpret_cast<jlong>(new CDocBuilderContext(pSelf->GetContext()));
 }
 
-jlong Java_docbuilder_CDocBuilder_c_1GetContextWithEnterParam(JNIEnv* env, jclass cls, jlong self, jboolean enterContext)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilder_c_1GetContextWithEnterParam(JNIEnv* env, jclass cls, jlong self, jboolean enterContext)
 {
 	CDocBuilder* pSelf = reinterpret_cast<CDocBuilder*>(self);
 	return reinterpret_cast<jlong>(new CDocBuilderContext(pSelf->GetContext((bool)enterContext)));
 }
 
-void Java_docbuilder_CDocBuilder_c_1Initialize(JNIEnv* env, jclass cls)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilder_c_1Initialize(JNIEnv* env, jclass cls)
 {
 	CDocBuilder::Initialize();
 }
 
-void Java_docbuilder_CDocBuilder_c_1InitializeWithDirectory(JNIEnv* env, jclass cls, jstring directory)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilder_c_1InitializeWithDirectory(JNIEnv* env, jclass cls, jstring directory)
 {
 	std::wstring strDirectory = wstringFromJavaString(env, directory);
 	CDocBuilder::Initialize(strDirectory.c_str());
 }
 
-void Java_docbuilder_CDocBuilder_c_1Dispose(JNIEnv* env, jclass cls)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilder_c_1Dispose(JNIEnv* env, jclass cls)
 {
 	CDocBuilder::Dispose();
 }

DesktopEditor/doctrenderer/docbuilder.java/src/jni/docbuilder_CDocBuilderContext.cpp

@@ -4,60 +4,60 @@
 
 using namespace NSDoctRenderer;
 
-jlong Java_docbuilder_CDocBuilderContext_c_1Create(JNIEnv* env, jclass cls)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderContext_c_1Create(JNIEnv* env, jclass cls)
 {
 	return reinterpret_cast<jlong>(new CDocBuilderContext());
 }
 
-jlong Java_docbuilder_CDocBuilderContext_c_1Copy(JNIEnv* env, jclass cls, jlong other)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderContext_c_1Copy(JNIEnv* env, jclass cls, jlong other)
 {
 	CDocBuilderContext* pOther = reinterpret_cast<CDocBuilderContext*>(other);
 	return reinterpret_cast<jlong>(new CDocBuilderContext(*pOther));
 }
 
-void Java_docbuilder_CDocBuilderContext_c_1Destroy(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilderContext_c_1Destroy(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderContext* pSelf = reinterpret_cast<CDocBuilderContext*>(self);
 	delete pSelf;
 }
 
-jlong Java_docbuilder_CDocBuilderContext_c_1CreateUndefined(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderContext_c_1CreateUndefined(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderContext* pSelf = reinterpret_cast<CDocBuilderContext*>(self);
 	return reinterpret_cast<jlong>(new CDocBuilderValue(pSelf->CreateUndefined()));
 }
 
-jlong Java_docbuilder_CDocBuilderContext_c_1CreateNull(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderContext_c_1CreateNull(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderContext* pSelf = reinterpret_cast<CDocBuilderContext*>(self);
 	return reinterpret_cast<jlong>(new CDocBuilderValue(pSelf->CreateNull()));
 }
 
-jlong Java_docbuilder_CDocBuilderContext_c_1CreateObject(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderContext_c_1CreateObject(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderContext* pSelf = reinterpret_cast<CDocBuilderContext*>(self);
 	return reinterpret_cast<jlong>(new CDocBuilderValue(pSelf->CreateObject()));
 }
 
-jlong Java_docbuilder_CDocBuilderContext_c_1CreateArray(JNIEnv* env, jclass cls, jlong self, jint length)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderContext_c_1CreateArray(JNIEnv* env, jclass cls, jlong self, jint length)
 {
 	CDocBuilderContext* pSelf = reinterpret_cast<CDocBuilderContext*>(self);
 	return reinterpret_cast<jlong>(new CDocBuilderValue(pSelf->CreateArray((int)length)));
 }
 
-jlong Java_docbuilder_CDocBuilderContext_c_1GetGlobal(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderContext_c_1GetGlobal(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderContext* pSelf = reinterpret_cast<CDocBuilderContext*>(self);
 	return reinterpret_cast<jlong>(new CDocBuilderValue(pSelf->GetGlobal()));
 }
 
-jlong Java_docbuilder_CDocBuilderContext_c_1CreateScope(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderContext_c_1CreateScope(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderContext* pSelf = reinterpret_cast<CDocBuilderContext*>(self);
 	return reinterpret_cast<jlong>(new CDocBuilderContextScope(pSelf->CreateScope()));
 }
 
-jboolean Java_docbuilder_CDocBuilderContext_c_1IsError(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilderContext_c_1IsError(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderContext* pSelf = reinterpret_cast<CDocBuilderContext*>(self);
 	return (jboolean)pSelf->IsError();

DesktopEditor/doctrenderer/docbuilder.java/src/jni/docbuilder_CDocBuilderContextScope.cpp

@@ -4,24 +4,24 @@
 
 using namespace NSDoctRenderer;
 
-jlong Java_docbuilder_CDocBuilderContextScope_c_1Create(JNIEnv* env, jclass cls)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderContextScope_c_1Create(JNIEnv* env, jclass cls)
 {
 	return reinterpret_cast<jlong>(new CDocBuilderContextScope());
 }
 
-jlong Java_docbuilder_CDocBuilderContextScope_c_1Copy(JNIEnv* env, jclass cls, jlong other)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderContextScope_c_1Copy(JNIEnv* env, jclass cls, jlong other)
 {
 	CDocBuilderContextScope* pOther = reinterpret_cast<CDocBuilderContextScope*>(other);
 	return reinterpret_cast<jlong>(new CDocBuilderContextScope(*pOther));
 }
 
-void Java_docbuilder_CDocBuilderContextScope_c_1Destroy(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilderContextScope_c_1Destroy(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderContextScope* pSelf = reinterpret_cast<CDocBuilderContextScope*>(self);
 	delete pSelf;
 }
 
-void Java_docbuilder_CDocBuilderContextScope_c_1Close(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilderContextScope_c_1Close(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderContextScope* pSelf = reinterpret_cast<CDocBuilderContextScope*>(self);
 	pSelf->Close();

DesktopEditor/doctrenderer/docbuilder.java/src/jni/docbuilder_CDocBuilderValue.cpp

@@ -8,114 +8,114 @@
 
 using namespace NSDoctRenderer;
 
-jlong Java_docbuilder_CDocBuilderValue_c_1Create(JNIEnv* env, jclass cls)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1Create(JNIEnv* env, jclass cls)
 {
 	return reinterpret_cast<jlong>(new CDocBuilderValue());
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1Copy(JNIEnv* env, jclass cls, jlong other)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1Copy(JNIEnv* env, jclass cls, jlong other)
 {
 	CDocBuilderValue* pOther = reinterpret_cast<CDocBuilderValue*>(other);
 	return reinterpret_cast<jlong>(new CDocBuilderValue(*pOther));
 }
 
-void Java_docbuilder_CDocBuilderValue_c_1Destroy(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilderValue_c_1Destroy(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	delete pSelf;
 }
 
-jboolean Java_docbuilder_CDocBuilderValue_c_1IsEmpty(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilderValue_c_1IsEmpty(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	return (jboolean)pSelf->IsEmpty();
 }
 
-void Java_docbuilder_CDocBuilderValue_c_1Clear(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilderValue_c_1Clear(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	pSelf->Clear();
 }
 
-jboolean Java_docbuilder_CDocBuilderValue_c_1IsNull(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilderValue_c_1IsNull(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	return (jboolean)pSelf->IsNull();
 }
 
-jboolean Java_docbuilder_CDocBuilderValue_c_1IsUndefined(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilderValue_c_1IsUndefined(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	return (jboolean)pSelf->IsUndefined();
 }
 
-jboolean Java_docbuilder_CDocBuilderValue_c_1IsBool(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilderValue_c_1IsBool(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	return (jboolean)pSelf->IsBool();
 }
 
-jboolean Java_docbuilder_CDocBuilderValue_c_1IsInt(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilderValue_c_1IsInt(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	return (jboolean)pSelf->IsInt();
 }
 
-jboolean Java_docbuilder_CDocBuilderValue_c_1IsDouble(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilderValue_c_1IsDouble(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	return (jboolean)pSelf->IsDouble();
 }
 
-jboolean Java_docbuilder_CDocBuilderValue_c_1IsString(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilderValue_c_1IsString(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	return (jboolean)pSelf->IsString();
 }
 
-jboolean Java_docbuilder_CDocBuilderValue_c_1IsFunction(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilderValue_c_1IsFunction(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	return (jboolean)pSelf->IsFunction();
 }
 
-jboolean Java_docbuilder_CDocBuilderValue_c_1IsObject(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilderValue_c_1IsObject(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	return (jboolean)pSelf->IsObject();
 }
 
-jboolean Java_docbuilder_CDocBuilderValue_c_1IsArray(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilderValue_c_1IsArray(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	return (jboolean)pSelf->IsArray();
 }
 
-jint Java_docbuilder_CDocBuilderValue_c_1GetLength(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jint JNICALL Java_docbuilder_CDocBuilderValue_c_1GetLength(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	return (jint)pSelf->GetLength();
 }
 
-jboolean Java_docbuilder_CDocBuilderValue_c_1ToBool(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jboolean JNICALL Java_docbuilder_CDocBuilderValue_c_1ToBool(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	return (jboolean)pSelf->ToBool();
 }
 
-jint Java_docbuilder_CDocBuilderValue_c_1ToInt(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jint JNICALL Java_docbuilder_CDocBuilderValue_c_1ToInt(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	return (jint)pSelf->ToInt();
 }
 
-jdouble Java_docbuilder_CDocBuilderValue_c_1ToDouble(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jdouble JNICALL Java_docbuilder_CDocBuilderValue_c_1ToDouble(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	return (jdouble)pSelf->ToDouble();
 }
 
-jstring Java_docbuilder_CDocBuilderValue_c_1ToString(JNIEnv* env, jclass cls, jlong self)
+JNIEXPORT jstring JNICALL Java_docbuilder_CDocBuilderValue_c_1ToString(JNIEnv* env, jclass cls, jlong self)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	CString strValue = pSelf->ToString();
@@ -123,7 +123,7 @@ jstring Java_docbuilder_CDocBuilderValue_c_1ToString(JNIEnv* env, jclass cls, jl
 	return env->NewStringUTF(strUtfData.c_str());
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1GetProperty(JNIEnv* env, jclass cls, jlong self, jstring name)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1GetProperty(JNIEnv* env, jclass cls, jlong self, jstring name)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	const char* strUtfName = env->GetStringUTFChars(name, nullptr);
@@ -132,14 +132,14 @@ jlong Java_docbuilder_CDocBuilderValue_c_1GetProperty(JNIEnv* env, jclass cls, j
 	return reinterpret_cast<jlong>(pValue);
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1GetByIndex(JNIEnv* env, jclass cls, jlong self, jint index)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1GetByIndex(JNIEnv* env, jclass cls, jlong self, jint index)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	CDocBuilderValue* pValue = new CDocBuilderValue(pSelf->Get((int)index));
 	return reinterpret_cast<jlong>(pValue);
 }
 
-void Java_docbuilder_CDocBuilderValue_c_1SetProperty(JNIEnv* env, jclass cls, jlong self, jstring name, jlong value)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilderValue_c_1SetProperty(JNIEnv* env, jclass cls, jlong self, jstring name, jlong value)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	CDocBuilderValue* pValue = reinterpret_cast<CDocBuilderValue*>(value);
@@ -149,29 +149,29 @@ void Java_docbuilder_CDocBuilderValue_c_1SetProperty(JNIEnv* env, jclass cls, jl
 	env->ReleaseStringUTFChars(name, strUtfName);
 }
 
-void Java_docbuilder_CDocBuilderValue_c_1SetByIndex(JNIEnv* env, jclass cls, jlong self, jint index, jlong value)
+JNIEXPORT void JNICALL Java_docbuilder_CDocBuilderValue_c_1SetByIndex(JNIEnv* env, jclass cls, jlong self, jint index, jlong value)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	CDocBuilderValue* pValue = reinterpret_cast<CDocBuilderValue*>(value);
 	pSelf->Set((int)index, *pValue);
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1CreateWithBool(JNIEnv* env, jclass cls, jboolean value)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1CreateWithBool(JNIEnv* env, jclass cls, jboolean value)
 {
 	return reinterpret_cast<jlong>(new CDocBuilderValue((bool)value));
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1CreateWithInt(JNIEnv* env, jclass cls, jint value)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1CreateWithInt(JNIEnv* env, jclass cls, jint value)
 {
 	return reinterpret_cast<jlong>(new CDocBuilderValue((int)value));
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1CreateWithDouble(JNIEnv* env, jclass cls, jdouble value)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1CreateWithDouble(JNIEnv* env, jclass cls, jdouble value)
 {
 	return reinterpret_cast<jlong>(new CDocBuilderValue((double)value));
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1CreateWithString(JNIEnv* env, jclass cls, jstring str)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1CreateWithString(JNIEnv* env, jclass cls, jstring str)
 {
 	const char* strUtf = env->GetStringUTFChars(str, nullptr);
 	CDocBuilderValue* pValue = new CDocBuilderValue(strUtf);
@@ -179,22 +179,22 @@ jlong Java_docbuilder_CDocBuilderValue_c_1CreateWithString(JNIEnv* env, jclass c
 	return reinterpret_cast<jlong>(pValue);
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1CreateUndefined(JNIEnv* env, jclass cls)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1CreateUndefined(JNIEnv* env, jclass cls)
 {
 	return reinterpret_cast<jlong>(new CDocBuilderValue(CDocBuilderValue::CreateUndefined()));
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1CreateNull(JNIEnv* env, jclass cls)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1CreateNull(JNIEnv* env, jclass cls)
 {
 	return reinterpret_cast<jlong>(new CDocBuilderValue(CDocBuilderValue::CreateNull()));
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1CreateArray(JNIEnv* env, jclass cls, jint length)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1CreateArray(JNIEnv* env, jclass cls, jint length)
 {
 	return reinterpret_cast<jlong>(new CDocBuilderValue(CDocBuilderValue::CreateArray((int)length)));
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1Call0(JNIEnv* env, jclass cls, jlong self, jstring name)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1Call0(JNIEnv* env, jclass cls, jlong self, jstring name)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	const char* strUtfName = env->GetStringUTFChars(name, nullptr);
@@ -203,7 +203,7 @@ jlong Java_docbuilder_CDocBuilderValue_c_1Call0(JNIEnv* env, jclass cls, jlong s
 	return reinterpret_cast<jlong>(pReturnValue);
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1Call1(JNIEnv* env, jclass cls, jlong self, jstring name, jlong p1)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1Call1(JNIEnv* env, jclass cls, jlong self, jstring name, jlong p1)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	CDocBuilderValue* pParam1 = reinterpret_cast<CDocBuilderValue*>(p1);
@@ -213,7 +213,7 @@ jlong Java_docbuilder_CDocBuilderValue_c_1Call1(JNIEnv* env, jclass cls, jlong s
 	return reinterpret_cast<jlong>(pReturnValue);
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1Call2(JNIEnv* env, jclass cls, jlong self, jstring name, jlong p1, jlong p2)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1Call2(JNIEnv* env, jclass cls, jlong self, jstring name, jlong p1, jlong p2)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	CDocBuilderValue* pParam1 = reinterpret_cast<CDocBuilderValue*>(p1);
@@ -224,7 +224,7 @@ jlong Java_docbuilder_CDocBuilderValue_c_1Call2(JNIEnv* env, jclass cls, jlong s
 	return reinterpret_cast<jlong>(pReturnValue);
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1Call3(JNIEnv* env, jclass cls, jlong self, jstring name, jlong p1, jlong p2, jlong p3)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1Call3(JNIEnv* env, jclass cls, jlong self, jstring name, jlong p1, jlong p2, jlong p3)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	CDocBuilderValue* pParam1 = reinterpret_cast<CDocBuilderValue*>(p1);
@@ -236,7 +236,7 @@ jlong Java_docbuilder_CDocBuilderValue_c_1Call3(JNIEnv* env, jclass cls, jlong s
 	return reinterpret_cast<jlong>(pReturnValue);
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1Call4(JNIEnv* env, jclass cls, jlong self, jstring name, jlong p1, jlong p2, jlong p3, jlong p4)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1Call4(JNIEnv* env, jclass cls, jlong self, jstring name, jlong p1, jlong p2, jlong p3, jlong p4)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	CDocBuilderValue* pParam1 = reinterpret_cast<CDocBuilderValue*>(p1);
@@ -249,7 +249,7 @@ jlong Java_docbuilder_CDocBuilderValue_c_1Call4(JNIEnv* env, jclass cls, jlong s
 	return reinterpret_cast<jlong>(pReturnValue);
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1Call5(JNIEnv* env, jclass cls, jlong self, jstring name, jlong p1, jlong p2, jlong p3, jlong p4, jlong p5)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1Call5(JNIEnv* env, jclass cls, jlong self, jstring name, jlong p1, jlong p2, jlong p3, jlong p4, jlong p5)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	CDocBuilderValue* pParam1 = reinterpret_cast<CDocBuilderValue*>(p1);
@@ -263,7 +263,7 @@ jlong Java_docbuilder_CDocBuilderValue_c_1Call5(JNIEnv* env, jclass cls, jlong s
 	return reinterpret_cast<jlong>(pReturnValue);
 }
 
-jlong Java_docbuilder_CDocBuilderValue_c_1Call6(JNIEnv* env, jclass cls, jlong self, jstring name, jlong p1, jlong p2, jlong p3, jlong p4, jlong p5, jlong p6)
+JNIEXPORT jlong JNICALL Java_docbuilder_CDocBuilderValue_c_1Call6(JNIEnv* env, jclass cls, jlong self, jstring name, jlong p1, jlong p2, jlong p3, jlong p4, jlong p5, jlong p6)
 {
 	CDocBuilderValue* pSelf = reinterpret_cast<CDocBuilderValue*>(self);
 	CDocBuilderValue* pParam1 = reinterpret_cast<CDocBuilderValue*>(p1);

DesktopEditor/doctrenderer/docbuilder.net/.gitignore

@@ -0,0 +1 @@
+deploy/

DesktopEditor/doctrenderer/docbuilder.python/src/docbuilder.py

@@ -2,6 +2,7 @@ import ctypes
 import os
 import platform
 import atexit
+import subprocess
 
 OBJECT_HANDLE = ctypes.c_void_p
 STRING_HANDLE = ctypes.c_void_p
@@ -23,6 +24,10 @@ def _loadLibrary(path):
         library_name = 'libdocbuilder.c.so'
     elif 'darwin' == os_name:
         library_name = 'libdocbuilder.c.dylib'
+        # if there is no dylib file, get library from framework
+        if not os.path.exists(path + '/' + library_name):
+            path = path + '/docbuilder.c.framework'
+            library_name = 'docbuilder.c'
 
     _lib = ctypes.CDLL(path + '/' + library_name)
 
@@ -382,6 +387,20 @@ class CDocBuilderValue:
     def __setitem__(self, key, value):
         self.Set(key, value)
 
+    def __getattr__(self, name):
+        def method(*args):
+            return self.Call(name, *args)
+        return method
+
+    def __len__(self):
+        return self.GetLength()
+
+    def __iter__(self):
+        if not self.IsArray():
+            raise TypeError("Object is not iterable")
+        for i in range(self.GetLength()):
+            yield self.Get(i)
+
     @staticmethod
     def CreateUndefined():
         return CDocBuilderValue(OBJECT_HANDLE(_lib.CDocBuilderValue_CreateUndefined()))
@@ -423,6 +442,36 @@ class CDocBuilderValue:
         else:
             raise TypeError("Call() expects at most 6 arguments")
 
+    def append(self, value):
+        if not self.IsArray():
+            raise TypeError("Object is not an array")
+        length = self.GetLength()
+        self.Set(length, value)
+        return self
+
+    def extend(self, iterable):
+        if not self.IsArray():
+            raise TypeError("Object is not an array")
+        length = self.GetLength()
+        for i, value in enumerate(iterable, start=length):
+            self.Set(i, value)
+        return self
+
+    def insert(self, i, x):
+        if not self.IsArray():
+            raise TypeError("Object is not an array")
+        length = self.GetLength()
+        if i < 0:
+            if abs(i) > length:
+                raise IndexError("list index out of range")
+            i = max(0, length + i)
+        if i >= length:
+            raise IndexError("list index out of range")
+        for idx in range(length, i, -1):
+            self.Set(idx, self.Get(idx - 1))
+        self.Set(i, x)
+
+
 class CDocBuilder:
     _initialized = False
 
@@ -434,7 +483,7 @@ class CDocBuilder:
         # using self._lib instead of global _lib because it might be already garbage collected during this function call
         self._lib.CDocBuilder_Destroy(self._internal)
 
-    def OpenFile(self, path, params):
+    def OpenFile(self, path, params=""):
         return _lib.CDocBuilder_OpenFile(self._internal, ctypes.c_wchar_p(path), ctypes.c_wchar_p(params))
 
     def CreateFile(self, type):
@@ -608,8 +657,17 @@ class FileTypes:
         PNG = _IMAGE_MASK + 0x0005
         BMP = _IMAGE_MASK + 0x0008
 
+# NOTE: do not change builder_path manually!
 builder_path = os.path.dirname(os.path.realpath(__file__))
 _loadLibrary(builder_path)
 CDocBuilder.Initialize(builder_path)
 
+def registerLibrary(license_path):
+    docbuilder_bin = os.path.join(builder_path, "docbuilder")
+    if ("windows" == platform.system().lower()):
+        docbuilder_bin += ".exe"
+        return subprocess.call([docbuilder_bin, "-register", license_path], stderr=subprocess.STDOUT, shell=True)
+    command = docbuilder_bin + " -register \"" +  license_path.replace('\"', '\\\"') + "\""
+    return subprocess.call(command, stderr=subprocess.STDOUT, shell=True)
+
 atexit.register(CDocBuilder.Dispose)

DesktopEditor/doctrenderer/docbuilder.python/test/docbuilder_test.py

@@ -13,16 +13,16 @@ scope = context.CreateScope()
 globalObj = context.GetGlobal()
 
 api = globalObj['Api']
-document = api.Call('GetDocument')
-paragraph1 = api.Call('CreateParagraph')
-paragraph1.Call('SetSpacingAfter', 1000, False)
-paragraph1.Call('AddText', 'Hello from Python!')
+document = api.GetDocument()
+paragraph1 = api.CreateParagraph()
+paragraph1.SetSpacingAfter(1000, False)
+paragraph1.AddText('Hello from Python!')
 
-paragraph2 = api.Call('CreateParagraph')
-paragraph2.Call('AddText', 'Goodbye!')
+paragraph2 = api.CreateParagraph()
+paragraph2.AddText('Goodbye!')
 
 content = [paragraph1, paragraph2]
-document.Call('InsertContent', content)
+document.InsertContent(content)
 
 dstPath = os.getcwd() + '/result.docx'
 builder.SaveFile(docbuilder.FileTypes.Document.DOCX, dstPath)

DesktopEditor/doctrenderer/docbuilder.python/test/docbuilder_test_old.py

@@ -0,0 +1,29 @@
+import os
+import sys
+sys.path.append('path_to_docbuilder')
+import docbuilder
+
+builder = docbuilder.CDocBuilder()
+
+builder.CreateFile(docbuilder.FileTypes.Document.DOCX)
+
+context = builder.GetContext()
+scope = context.CreateScope()
+
+globalObj = context.GetGlobal()
+
+api = globalObj['Api']
+document = api.Call('GetDocument')
+paragraph1 = api.Call('CreateParagraph')
+paragraph1.Call('SetSpacingAfter', 1000, False)
+paragraph1.Call('AddText', 'Hello from Python!')
+
+paragraph2 = api.Call('CreateParagraph')
+paragraph2.Call('AddText', 'Goodbye!')
+
+content = [paragraph1, paragraph2]
+document.Call('InsertContent', content)
+
+dstPath = os.getcwd() + '/result.docx'
+builder.SaveFile(docbuilder.FileTypes.Document.DOCX, dstPath)
+builder.CloseFile()

DesktopEditor/doctrenderer/docbuilder_p.cpp

@@ -74,6 +74,7 @@ CV8RealTimeWorker::CV8RealTimeWorker(NSDoctRenderer::CDocBuilder* pBuilder, cons
 	global->set("native", oNativeCtrl);
 
 	CBuilderEmbed* pBuilderJSNative = static_cast<CBuilderEmbed*>(oBuilderJS->getNative());
+	pBuilderJSNative->SetExternalize(true);
 	pBuilderJSNative->m_pBuilder = pBuilder;
 }
 CV8RealTimeWorker::~CV8RealTimeWorker()
@@ -82,7 +83,7 @@ CV8RealTimeWorker::~CV8RealTimeWorker()
 	m_context->Dispose();
 }
 
-bool CV8RealTimeWorker::ExecuteCommand(const std::wstring& command, NSDoctRenderer::CDocBuilderValue* retValue)
+bool CV8RealTimeWorker::ExecuteCommand(const std::wstring& command, NSDoctRenderer::CDocBuilderValue* retValue, const bool& isEnterContextSrc)
 {
 	LOGGER_SPEED_START();
 
@@ -92,14 +93,24 @@ bool CV8RealTimeWorker::ExecuteCommand(const std::wstring& command, NSDoctRender
 	std::string commandA = U_TO_UTF8(command);
 	//commandA = "Api." + commandA;
 
-	CJSContextScope scope(m_context);
+	bool isEnterContext = isEnterContextSrc;
+	if (!isEnterContext && !m_context->IsEntered())
+		isEnterContext = true;
+
+	if (isEnterContext)
+		m_context->Enter();
+
 	JSSmart<CJSTryCatch> try_catch = m_context->GetExceptions();
 
 	LOGGER_SPEED_LAP("compile_command");
 
 	JSSmart<CJSValue> retNativeVal = m_context->runScript(commandA, try_catch);
 	if(try_catch->Check())
+	{
+		if (isEnterContext)
+			m_context->Exit();
 		return false;
+	}
 
 	if (retValue)
 	{
@@ -110,6 +121,9 @@ bool CV8RealTimeWorker::ExecuteCommand(const std::wstring& command, NSDoctRender
 
 	LOGGER_SPEED_LAP("run_command");
 
+	if (isEnterContext)
+		m_context->Exit();
+
 	return true;
 }
 
@@ -344,7 +358,17 @@ bool CV8RealTimeWorker::OpenFile(const std::wstring& sBasePath, const std::wstri
 	return !bIsBreak;
 }
 
-bool CV8RealTimeWorker::SaveFileWithChanges(int type, const std::wstring& _path, const std::wstring& sJsonParams)
+bool CV8RealTimeWorker::NewSimpleJSInstance()
+{
+	return InitVariables();
+}
+
+bool CV8RealTimeWorker::IsSimpleJSInstance()
+{
+	return (-1 == m_nFileType);
+}
+
+bool CV8RealTimeWorker::SaveFileWithChanges(int type, const std::wstring& _path, const std::wstring& sJsonParams, const bool& isEnterContext)
 {
 	NSDoctRenderer::DoctRendererFormat::FormatFile _formatDst = NSDoctRenderer::DoctRendererFormat::DOCT;
 	if (type & AVS_OFFICESTUDIO_FILE_PRESENTATION)
@@ -370,7 +394,9 @@ bool CV8RealTimeWorker::SaveFileWithChanges(int type, const std::wstring& _path,
 		}
 	}
 
-	CJSContextScope scope(m_context);
+	if (isEnterContext)
+		m_context->Enter();
+
 	JSSmart<CJSTryCatch> try_catch = m_context->GetExceptions();
 
 	NSNativeControl::CNativeControl* pNative = NULL;
@@ -399,7 +425,7 @@ bool CV8RealTimeWorker::SaveFileWithChanges(int type, const std::wstring& _path,
 		bIsSilentMode = true;
 
 	if (bIsSilentMode)
-		this->ExecuteCommand(L"Api.asc_SetSilentMode(false);");
+		this->ExecuteCommand(L"Api.asc_SetSilentMode(false);", NULL, isEnterContext);
 
 	std::wstring strError;
 	bool bIsError = Doct_renderer_SaveFile_ForBuilder(_formatDst,
@@ -411,7 +437,10 @@ bool CV8RealTimeWorker::SaveFileWithChanges(int type, const std::wstring& _path,
 													  sJsonParams);
 
 	if (bIsSilentMode)
-		this->ExecuteCommand(L"Api.asc_SetSilentMode(true);");
+		this->ExecuteCommand(L"Api.asc_SetSilentMode(true);", NULL, isEnterContext);
+
+	if (isEnterContext)
+		m_context->Exit();
 
 	return bIsError;
 }
@@ -1213,13 +1242,13 @@ namespace NSDoctRenderer
 
 		while (true)
 		{
-			while (_currentPos < _commandsLen && !(_commandsPtr[_currentPos] == '\"' && _commandsPtr[_currentPos - 1] != '\\'))
+			while (_currentPos < _commandsLen && !((_commandsPtr[_currentPos] == '\"' || _commandsPtr[_currentPos] == '\'') && _commandsPtr[_currentPos - 1] != '\\'))
 				++_currentPos;
 
 			++_currentPos;
 			size_t _start = _currentPos;
 
-			while (_currentPos < _commandsLen && !(_commandsPtr[_currentPos] == '\"' && _commandsPtr[_currentPos - 1] != '\\'))
+			while (_currentPos < _commandsLen && !((_commandsPtr[_currentPos] == '\"' || _commandsPtr[_currentPos] == '\'') && _commandsPtr[_currentPos - 1] != '\\'))
 				++_currentPos;
 
 			if (_currentPos > _start)
@@ -1239,8 +1268,29 @@ namespace NSDoctRenderer
 		nCount = nIndex;
 	}
 
+	int CDocBuilder::OpenFile(const wchar_t* path, const wchar_t* params)
+	{
+		if (m_pInternal->m_nFileType != -1 && m_pInternal->m_bIsOpenedFromSimpleJS)
+		{
+			m_pInternal->m_bIsOpenedFromSimpleJS = false;
+			return 0;
+		}
+
+		m_pInternal->m_nFileType = -1;
+		if (!NSDirectory::Exists(m_pInternal->m_sTmpFolder))
+			NSDirectory::CreateDirectory(m_pInternal->m_sTmpFolder);
+
+		return m_pInternal->OpenFile(path, params);
+	}
+
 	bool CDocBuilder::CreateFile(const int& type)
 	{
+		if (m_pInternal->m_nFileType != -1 && m_pInternal->m_bIsOpenedFromSimpleJS)
+		{
+			m_pInternal->m_bIsOpenedFromSimpleJS = false;
+			return true;
+		}
+
 		m_pInternal->m_nFileType = -1;
 		if (!NSDirectory::Exists(m_pInternal->m_sTmpFolder))
 			NSDirectory::CreateDirectory(m_pInternal->m_sTmpFolder);
@@ -1399,7 +1449,7 @@ namespace NSDoctRenderer
 				if (!sJsCommands.empty())
 				{
 					std::wstring sUnicodeCommand = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)sJsCommands.c_str(), (LONG)sJsCommands.length());
-					bIsNoError = this->ExecuteCommand(sUnicodeCommand.c_str());
+					bIsNoError = this->m_pInternal->ExecuteCommand(sUnicodeCommand.c_str(), NULL, bIsBuilderJSCloseFile);
 					sJsCommands = "";
 					if (!bIsNoError)
 						return false;
@@ -1421,6 +1471,10 @@ namespace NSDoctRenderer
 					if (0 == _builder_params[nCheckParam].find(L"jsValue(") && _builder_params[nCheckParam].length() > 9)
 					{
 						std::wstring sParam = _builder_params[nCheckParam].substr(8, _builder_params[nCheckParam].length() - 9);
+
+						if (NULL == m_pInternal->m_pWorker)
+							m_pInternal->CheckWorker();
+
 						_builder_params[nCheckParam] = m_pInternal->m_pWorker->GetJSVariable(sParam);
 					}
 				}
@@ -1460,7 +1514,8 @@ namespace NSDoctRenderer
 					if (nCountParameters > 2)
 						sParams = _builder_params[2].c_str();
 
-					this->SaveFile(nFormat, _builder_params[1].c_str(), sParams);
+					int nSaveError = this->SaveFile(nFormat, _builder_params[1].c_str(), sParams);
+					bIsNoError = (0 == nSaveError);
 				}
 				else if ("WriteData" == sFuncNum)
 				{
@@ -1486,7 +1541,7 @@ namespace NSDoctRenderer
 		{
 			// Такого быть не должно!!! Так как результат никуда не сохранится. пустое действие.
 			std::wstring sUnicodeCommand = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)sJsCommands.c_str(), (LONG)sJsCommands.length());
-			bool bIsNoError = this->ExecuteCommand(sUnicodeCommand.c_str());
+			bool bIsNoError = this->m_pInternal->ExecuteCommand(sUnicodeCommand.c_str(), NULL, true);
 			sJsCommands = "";
 			if (!bIsNoError)
 				return false;
@@ -1547,6 +1602,15 @@ namespace NSDoctRenderer
 		return this->SetProperty(sA.c_str(), value);
 	}
 
+	int CDocBuilder::GetPropertyInt(const wchar_t* param)
+	{
+		std::wstring sParam = std::wstring(param);
+		std::string sParamA = U_TO_UTF8(sParam);
+		if ("--save-use-only-names" == sParamA)
+			return m_pInternal->m_bIsServerSafeVersion ? 1 : 0;
+		return -1;
+	}
+
 	void CDocBuilder::Initialize(const wchar_t* directory)
 	{
 		std::wstring sDirectory = L"";

DesktopEditor/doctrenderer/docbuilder_p.h

@@ -63,6 +63,8 @@
 
 #include "../common/ProcessEnv.h"
 
+#include "docbuilder_addon.h"
+
 #ifdef CreateFile
 #undef CreateFile
 #endif
@@ -435,14 +437,17 @@ public:
 
 	static void _LOGGING_ERROR_(const std::wstring& strType, const std::wstring& strError);
 
-	bool ExecuteCommand(const std::wstring& command, NSDoctRenderer::CDocBuilderValue* retValue = NULL);
+	bool ExecuteCommand(const std::wstring& command, NSDoctRenderer::CDocBuilderValue* retValue = NULL, const bool& isEnterContext = true);
 
 	std::string GetGlobalVariable();
 	std::wstring GetJSVariable(std::wstring sParam);
 
 	bool OpenFile(const std::wstring& sBasePath, const std::wstring& path, const NSDoctRenderer::DoctRendererEditorType& editorType, NSDoctRenderer::CDoctRendererConfig* config, CV8Params* pParams = NULL);
-	bool SaveFileWithChanges(int type, const std::wstring& _path, const std::wstring& sJsonParams = L"");
+	bool SaveFileWithChanges(int type, const std::wstring& _path, const std::wstring& sJsonParams = L"", const bool& isEnterContext = true);
 	bool InitVariables();
+
+	bool NewSimpleJSInstance();
+	bool IsSimpleJSInstance();
 };
 
 namespace NSDoctRenderer
@@ -476,11 +481,13 @@ namespace NSDoctRenderer
 
 		NSDoctRenderer::CDocBuilder* m_pParent;
 
+		bool m_bIsOpenedFromSimpleJS;
+
 		static std::wstring m_sExternalDirectory;
 	public:
 		CDocBuilder_Private() : CDoctRendererConfig(), m_sTmpFolder(NSFile::CFileBinary::GetTempPath()), m_nFileType(-1),
 			m_pWorker(NULL), m_pAdditionalData(NULL), m_bIsInit(false), m_bIsServerSafeVersion(false),
-			m_sGlobalVariable(""), m_bIsGlobalVariableUse(false), m_pParent(NULL), m_sCommandsBeforeContextCreated(L"")
+			  m_sGlobalVariable(""), m_bIsGlobalVariableUse(false), m_pParent(NULL), m_sCommandsBeforeContextCreated(L""), m_bIsOpenedFromSimpleJS(false)
 		{
 		}
 
@@ -540,6 +547,7 @@ namespace NSDoctRenderer
 			CApplicationFontsWorker oWorker;
 			oWorker.m_bIsUseSystemFonts = m_oParams.m_bIsSystemFonts;
 			oWorker.m_arAdditionalFolders = m_oParams.m_arFontDirs;
+			oWorker.m_arAdditionalFolders.push_back(NSFile::GetProcessDirectory() + L"/fonts");
 			oWorker.m_bIsNeedThumbnails = false;
 			oWorker.m_sDirectory = sDirectory;
 			// это не рабочая папка, где только шрифты
@@ -639,6 +647,13 @@ namespace NSDoctRenderer
 			{
 				NSDirectory::CreateDirectory(m_sFileDir + L"/media");
 				NSDirectory::CreateDirectory(m_sFileDir + L"/changes");
+
+				if (m_pWorker && m_pWorker->IsSimpleJSInstance() && !m_bIsOpenedFromSimpleJS)
+				{
+					RELEASEOBJECT(m_pWorker);
+					CheckWorker();
+				}
+				return bRet;
 			}
 
 			return bRet;
@@ -913,7 +928,7 @@ namespace NSDoctRenderer
 
 			COfficeFileFormatChecker oChecker;
 			if (!oChecker.isOfficeFile(sFileCopy))
-				return false;
+				return 1;
 
 			if (oChecker.nFileType & AVS_OFFICESTUDIO_FILE_DOCUMENT)
 				m_nFileType = 0;
@@ -929,7 +944,14 @@ namespace NSDoctRenderer
 			LOGGER_SPEED_LAP("open_convert");
 
 			if (0 == nReturnCode)
+			{
+				if (m_pWorker && m_pWorker->IsSimpleJSInstance() && !m_bIsOpenedFromSimpleJS)
+				{
+					RELEASEOBJECT(m_pWorker);
+					CheckWorker();
+				}
 				return 0;
+			}
 
 			NSDirectory::DeleteDirectory(m_sFileDir);
 			m_sFileDir = L"";
@@ -976,10 +998,16 @@ namespace NSDoctRenderer
 			return _path;
 		}
 
-		int SaveFile(const int& type, const std::wstring& path, const wchar_t* params = NULL)
+		int SaveFile(const int& type, const std::wstring& path, const wchar_t* params = NULL, const bool& isEnterContext = true)
 		{
 			Init();
 
+			CDocBuilderAddon oSaveAddon(m_sX2tPath);
+
+			int nPreSaveError = oSaveAddon.GetX2tPreSaveError(m_pParent, m_nFileType);
+			if (0 != nPreSaveError)
+				return nPreSaveError;
+
 			if (-1 == m_nFileType)
 			{
 				CV8RealTimeWorker::_LOGGING_ERROR_(L"error (save)", L"file not opened!");
@@ -1018,7 +1046,7 @@ namespace NSDoctRenderer
 					}
 				}
 
-				this->m_pWorker->SaveFileWithChanges(type, m_sFileDir + L"/Editor2.bin", sJsonParams);
+				this->m_pWorker->SaveFileWithChanges(type, m_sFileDir + L"/Editor2.bin", sJsonParams, isEnterContext);
 				sFileBin = L"/Editor2.bin";
 			}
 
@@ -1063,6 +1091,8 @@ namespace NSDoctRenderer
 			if (!sOptions.empty())
 				oBuilder.WriteString(UTF8_TO_U(sOptions));
 
+			oBuilder.WriteString(oSaveAddon.GetX2tSaveAddon(m_pParent, m_nFileType));
+
 			oBuilder.WriteString(L"</TaskQueueDataConvert>");
 
 			std::wstring sXmlConvert = oBuilder.GetData();
@@ -1216,17 +1246,21 @@ namespace NSDoctRenderer
 			if (NULL == m_pWorker)
 			{
 				NSDoctRenderer::DoctRendererEditorType editorType = GetEditorType();
-				if (NSDoctRenderer::DoctRendererEditorType::INVALID == editorType)
-					return false;
-
 				m_pWorker = new CV8RealTimeWorker(m_pParent, editorType, this);
 				m_pWorker->m_sUtf8ArgumentJSON = m_oParams.m_sArgumentJSON;
 				m_pWorker->m_sGlobalVariable = m_sGlobalVariable;
 				m_pWorker->m_sJSCodeStart = U_TO_UTF8(m_sCommandsBeforeContextCreated);
-				m_sCommandsBeforeContextCreated = L"";
 
 				m_pWorker->m_nFileType = m_nFileType;
 
+				if (-1 != m_nFileType)
+					m_sCommandsBeforeContextCreated = L"";
+				else
+				{
+					m_pWorker->NewSimpleJSInstance();
+					return true;
+				}
+
 				CV8Params oParams;
 				oParams.IsServerSaveVersion = m_bIsServerSafeVersion;
 				oParams.DocumentDirectory = m_sFileDir;
@@ -1242,12 +1276,12 @@ namespace NSDoctRenderer
 			return SaveFile(nType, path, params);
 		}
 
-		bool ExecuteCommand(const std::wstring& command, CDocBuilderValue* retValue = NULL)
+		bool ExecuteCommand(const std::wstring& command, CDocBuilderValue* retValue = NULL, const bool& forceExecute = false, const bool& isEnterContext = true)
 		{
 			if (command.length() < 7 && !retValue) // minimum command (!!!)
 				return true;
 
-			if (m_nFileType == -1)
+			if (m_nFileType == -1 && !forceExecute)
 			{
 				m_sCommandsBeforeContextCreated += command;
 				return true;
@@ -1256,7 +1290,20 @@ namespace NSDoctRenderer
 			Init();
 
 			if (CheckWorker())
-				return m_pWorker->ExecuteCommand(command, retValue);
+			{
+				bool bIsOpenedFromSimpleJSOld = m_bIsOpenedFromSimpleJS;
+				bool bResult = m_pWorker->ExecuteCommand(command, retValue, isEnterContext);
+				if (!bResult && !bIsOpenedFromSimpleJSOld && m_bIsOpenedFromSimpleJS)
+				{
+					RELEASEOBJECT(m_pWorker);
+					CheckWorker();
+					return m_pWorker->ExecuteCommand(command, retValue, isEnterContext);
+				}
+				else
+				{
+					return bResult;
+				}
+			}
 
 			return false;
 		}

DesktopEditor/doctrenderer/doctrenderer.pri

@@ -0,0 +1,130 @@
+QT       -= core
+QT       -= gui
+
+VERSION = 1.0.0.3
+TARGET = doctrenderer
+TEMPLATE = lib
+
+CONFIG += shared
+CONFIG += plugin
+
+CORE_ROOT_DIR = $$PWD/../..
+PWD_ROOT_DIR = $$PWD
+
+PWD_CUR = $$PWD
+include($$PWD_CUR/../../Common/base.pri)
+
+DEFINES += DOCTRENDERER_USE_DYNAMIC_LIBRARY_BUILDING
+DEFINES += JSBASE_USE_DYNAMIC_LIBRARY_BUILDING
+ADD_DEPENDENCY(graphics, kernel, UnicodeConverter, kernel_network)
+
+#CONFIG += build_xp
+#CONFIG += v8_version_60
+core_android:DEFINES += DISABLE_MEMORY_LIMITATION
+
+HEADERS += \
+	$$PWD_CUR/config.h \
+	$$PWD_CUR/editors.h \
+	$$PWD_CUR/doctrenderer.h \
+	$$PWD_CUR/docbuilder.h
+
+SOURCES += \
+	$$PWD_CUR/editors.cpp \
+	$$PWD_CUR/nativecontrol.cpp \
+	$$PWD_CUR/doctrenderer.cpp \
+	$$PWD_CUR/docbuilder.cpp \
+	$$PWD_CUR/docbuilder_p.cpp \
+	$$PWD_CUR/graphics.cpp \
+	$$PWD_CUR/hash.cpp
+
+SOURCES += \
+	$$PWD_CUR/../../Common/OfficeFileFormatChecker2.cpp \
+	$$PWD_CUR/../../Common/3dParty/pole/pole.cpp \
+	$$PWD_CUR/../../OOXML/Base/unicode_util.cpp
+
+HEADERS += \
+	$$PWD_CUR/docbuilder_p.h \
+	$$PWD_CUR/nativecontrol.h \
+	$$PWD_CUR/graphics.h \
+	$$PWD_CUR/hash.h \
+	$$PWD_CUR/server.h
+
+HEADERS += \
+	$$PWD_CUR/embed/PointerEmbed.h \
+	$$PWD_CUR/embed/ZipEmbed.h \
+	$$PWD_CUR/embed/GraphicsEmbed.h \
+	$$PWD_CUR/embed/MemoryStreamEmbed.h \
+	$$PWD_CUR/embed/NativeControlEmbed.h \
+	$$PWD_CUR/embed/NativeBuilderEmbed.h \
+	$$PWD_CUR/embed/NativeBuilderDocumentEmbed.h \
+	$$PWD_CUR/embed/TextMeasurerEmbed.h \
+	$$PWD_CUR/embed/HashEmbed.h \
+	$$PWD_CUR/embed/Default.h \
+	$$PWD_CUR/js_internal/js_base.h
+
+SOURCES += \
+	$$PWD_CUR/embed/PointerEmbed.cpp \
+	$$PWD_CUR/embed/ZipEmbed.cpp \
+	$$PWD_CUR/embed/GraphicsEmbed.cpp \
+	$$PWD_CUR/embed/MemoryStreamEmbed.cpp \
+	$$PWD_CUR/embed/NativeControlEmbed.cpp \
+	$$PWD_CUR/embed/NativeBuilderEmbed.cpp \
+	$$PWD_CUR/embed/NativeBuilderDocumentEmbed.cpp \
+	$$PWD_CUR/embed/TextMeasurerEmbed.cpp \
+	$$PWD_CUR/embed/HashEmbed.cpp \
+	$$PWD_CUR/embed/Default.cpp
+
+# Serialize objects to JS
+HEADERS += \
+	$$PWD_CUR/json/json.h \
+	$$PWD_CUR/json/json_p.h \
+	$$PWD_CUR/json/json_values.h \
+	$$PWD_CUR/json/serialization.h
+
+SOURCES += \
+	$$PWD_CUR/json/json.cpp \
+	$$PWD_CUR/json/json_values.cpp
+
+include($$PWD_CUR/js_internal/js_base.pri)
+
+!use_javascript_core {
+	build_xp:DESTDIR=$$DESTDIR/xp
+}
+
+use_javascript_core {
+	OBJECTIVE_SOURCES += $$PWD_CUR/../common/Mac/NSString+StringUtils.mm
+}
+
+# files for embedded classes
+ADD_FILES_FOR_EMBEDDED_CLASS_HEADER($$PWD_CUR/embed/GraphicsEmbed.h)
+ADD_FILES_FOR_EMBEDDED_CLASS_HEADER($$PWD_CUR/embed/HashEmbed.h)
+ADD_FILES_FOR_EMBEDDED_CLASS_HEADER($$PWD_CUR/embed/MemoryStreamEmbed.h)
+ADD_FILES_FOR_EMBEDDED_CLASS_HEADER($$PWD_CUR/embed/NativeBuilderEmbed.h)
+ADD_FILES_FOR_EMBEDDED_CLASS_HEADER($$PWD_CUR/embed/NativeBuilderDocumentEmbed.h)
+ADD_FILES_FOR_EMBEDDED_CLASS_HEADER($$PWD_CUR/embed/NativeControlEmbed.h)
+ADD_FILES_FOR_EMBEDDED_CLASS_HEADER($$PWD_CUR/embed/PointerEmbed.h)
+ADD_FILES_FOR_EMBEDDED_CLASS_HEADER($$PWD_CUR/embed/TextMeasurerEmbed.h)
+ADD_FILES_FOR_EMBEDDED_CLASS_HEADER($$PWD_CUR/embed/ZipEmbed.h)
+
+include($$PWD_CUR/../graphics/pro/textshaper.pri)
+include($$PWD_CUR/../../Common/3dParty/openssl/openssl.pri)
+
+# downloader
+DEFINES += BUIDLER_OPEN_DOWNLOAD_ENABLED
+DEFINES += BUIDLER_OPEN_BASE64_ENABLED
+
+CONFIG += drawingfile_support
+drawingfile_support {
+	DEFINES += WASM_SERIALIZER_USE_ALLOCATOR
+	ADD_DEPENDENCY(PdfFile, XpsFile, DjVuFile, DocxRenderer)
+
+	HEADERS += \
+		$$PWD_CUR/drawingfile.h \
+		$$PWD_CUR/embed/DrawingFileEmbed.h
+
+	SOURCES += \
+		$$PWD_CUR/../graphics/pro/js/wasm/src/HTMLRendererText.cpp \
+		$$PWD_CUR/embed/DrawingFileEmbed.cpp
+
+	ADD_FILES_FOR_EMBEDDED_CLASS_HEADER($$PWD_CUR/embed/DrawingFileEmbed.h)
+}

DesktopEditor/doctrenderer/doctrenderer.pro

@@ -1,128 +1,3 @@
-QT       -= core
-QT       -= gui
+INCLUDEPATH += $$PWD/addon
 
-VERSION = 1.0.0.3
-TARGET = doctrenderer
-TEMPLATE = lib
-
-CONFIG += shared
-CONFIG += plugin
-
-CORE_ROOT_DIR = $$PWD/../..
-PWD_ROOT_DIR = $$PWD
-include(../../Common/base.pri)
-
-DEFINES += DOCTRENDERER_USE_DYNAMIC_LIBRARY_BUILDING
-DEFINES += JSBASE_USE_DYNAMIC_LIBRARY_BUILDING
-ADD_DEPENDENCY(graphics, kernel, UnicodeConverter, kernel_network)
-
-#CONFIG += build_xp
-#CONFIG += v8_version_60
-core_android:DEFINES += DISABLE_MEMORY_LIMITATION
-
-HEADERS += \
-	config.h \
-	editors.h \
-	doctrenderer.h \
-	docbuilder.h
-
-SOURCES += \
-	editors.cpp \
-	nativecontrol.cpp \
-	doctrenderer.cpp \
-	docbuilder.cpp \
-	docbuilder_p.cpp \
-	graphics.cpp \
-	hash.cpp
-
-SOURCES += \
-	../../Common/OfficeFileFormatChecker2.cpp \
-	../../Common/3dParty/pole/pole.cpp \
-	../../OOXML/Base/unicode_util.cpp
-
-HEADERS += \
-	docbuilder_p.h \
-	nativecontrol.h \
-	graphics.h \
-	hash.h \
-	server.h
-
-HEADERS += \
-	embed/PointerEmbed.h \
-	embed/ZipEmbed.h \
-	embed/GraphicsEmbed.h \
-	embed/MemoryStreamEmbed.h \
-	embed/NativeControlEmbed.h \
-	embed/NativeBuilderEmbed.h \
-	embed/NativeBuilderDocumentEmbed.h \
-	embed/TextMeasurerEmbed.h \
-	embed/HashEmbed.h \
-	embed/Default.h \
-	js_internal/js_base.h
-
-SOURCES += \
-	embed/PointerEmbed.cpp \
-	embed/ZipEmbed.cpp \
-	embed/GraphicsEmbed.cpp \
-	embed/MemoryStreamEmbed.cpp \
-	embed/NativeControlEmbed.cpp \
-	embed/NativeBuilderEmbed.cpp \
-	embed/NativeBuilderDocumentEmbed.cpp \
-	embed/TextMeasurerEmbed.cpp \
-	embed/HashEmbed.cpp \
-	embed/Default.cpp
-
-# Serialize objects to JS
-HEADERS += \
-	json/json.h \
-	json/json_p.h \
-	json/json_values.h \
-	json/serialization.h
-
-SOURCES += \
-	json/json.cpp \
-	json/json_values.cpp
-
-include($$PWD/js_internal/js_base.pri)
-
-!use_javascript_core {
-	build_xp:DESTDIR=$$DESTDIR/xp
-}
-
-use_javascript_core {
-	OBJECTIVE_SOURCES += ../common/Mac/NSString+StringUtils.mm
-}
-
-# files for embedded classes
-ADD_FILES_FOR_EMBEDDED_CLASS_HEADER(embed/GraphicsEmbed.h)
-ADD_FILES_FOR_EMBEDDED_CLASS_HEADER(embed/HashEmbed.h)
-ADD_FILES_FOR_EMBEDDED_CLASS_HEADER(embed/MemoryStreamEmbed.h)
-ADD_FILES_FOR_EMBEDDED_CLASS_HEADER(embed/NativeBuilderEmbed.h)
-ADD_FILES_FOR_EMBEDDED_CLASS_HEADER(embed/NativeBuilderDocumentEmbed.h)
-ADD_FILES_FOR_EMBEDDED_CLASS_HEADER(embed/NativeControlEmbed.h)
-ADD_FILES_FOR_EMBEDDED_CLASS_HEADER(embed/PointerEmbed.h)
-ADD_FILES_FOR_EMBEDDED_CLASS_HEADER(embed/TextMeasurerEmbed.h)
-ADD_FILES_FOR_EMBEDDED_CLASS_HEADER(embed/ZipEmbed.h)
-
-include(../graphics/pro/textshaper.pri)
-include(../../Common/3dParty/openssl/openssl.pri)
-
-# downloader
-DEFINES += BUIDLER_OPEN_DOWNLOAD_ENABLED
-DEFINES += BUIDLER_OPEN_BASE64_ENABLED
-
-CONFIG += drawingfile_support
-drawingfile_support {
-	DEFINES += WASM_SERIALIZER_USE_ALLOCATOR
-	ADD_DEPENDENCY(PdfFile, XpsFile, DjVuFile, DocxRenderer)
-
-	HEADERS += \
-		drawingfile.h \
-		embed/DrawingFileEmbed.h
-
-	SOURCES += \
-		../graphics/pro/js/wasm/src/HTMLRendererText.cpp \
-		embed/DrawingFileEmbed.cpp
-
-	ADD_FILES_FOR_EMBEDDED_CLASS_HEADER(embed/DrawingFileEmbed.h)
-}
+include(doctrenderer.pri)

DesktopEditor/doctrenderer/drawingfile.h

@@ -171,7 +171,6 @@ public:
 
 		return m_pFile ? true : false;
 	}
-
 	bool OpenFile(BYTE* data, LONG size, const std::wstring& sPassword)
 	{
 		CloseFile();
@@ -284,6 +283,34 @@ public:
 			return NULL;
 		return m_pFile->ConvertToPixels(nPageIndex, nRasterW, nRasterH, true, m_pFontManager, nBackgroundColor, (nBackgroundColor == 0xFFFFFF) ? false : true);
 	}
+	BYTE* SplitPages(int* arrPageIndex, int nLength, BYTE* data, LONG size)
+	{
+		if (m_nType == 0)
+			return ((CPdfFile*)m_pFile)->SplitPages(arrPageIndex, nLength, data, size);
+		return NULL;
+	}
+	bool MergePages(BYTE* data, LONG size, int nMaxID, const std::string& sPrefixForm, bool bCopy = false)
+	{
+		if (m_nType == 0)
+		{
+			// Память из CDrawingFileEmbed освобождается сразу после вызова функции, поэтому копируем
+			if (bCopy)
+			{
+				BYTE* pCopy = (BYTE*)malloc(size);
+				memcpy(pCopy, data, size);
+				data = pCopy;
+			}
+			// Захватывает полученную память, будет освобождена либо в деструкторе MemStream, либо free в случае неудачи
+			return ((CPdfFile*)m_pFile)->MergePages(data, size, nMaxID, sPrefixForm);
+		}
+		return false;
+	}
+	bool UnmergePages()
+	{
+		if (m_nType == 0)
+			return ((CPdfFile*)m_pFile)->UnmergePages();
+		return false;
+	}
 
 	BYTE* GetGlyphs(int nPageIndex)
 	{
@@ -403,22 +430,32 @@ public:
 		oRenderer.SetExternalImageStorage(m_pImageStorage);
 		oRenderer.SetTextAssociationType(NSDocxRenderer::TextAssociationType::tatParagraphToShape);
 
-		std::vector<std::wstring> arShapes;
-		if (0 == mode)
-			arShapes = oRenderer.ScanPage(m_pFile, nPageIndex);
-		else
-			arShapes = oRenderer.ScanPagePptx(m_pFile, nPageIndex);
-
-		int nLen = (int)arShapes.size();
-
 		NSWasm::CData oRes;
-		oRes.SkipLen();
-		oRes.AddInt(nLen);
+		switch (mode)
+		{
+			case 0:
+			case 1:
+			{
+				std::vector<std::wstring> arShapes = (0 == mode) ? oRenderer.ScanPage(m_pFile, nPageIndex) : oRenderer.ScanPagePptx(m_pFile, nPageIndex);
+				int nLen = (int)arShapes.size();
 
-		for (int i = 0; i < nLen; ++i)
-			oRes.WriteString(arShapes[i]);
+				oRes.SkipLen();
+				oRes.AddInt(nLen);
 
-		oRes.WriteLen();
+				for (int i = 0; i < nLen; ++i)
+					oRes.WriteString(arShapes[i]);
+
+				oRes.WriteLen();
+				break;
+			}
+			case 2:
+			{
+				oRes = oRenderer.ScanPageBin(m_pFile, nPageIndex);
+				break;
+			}
+			default:
+				return NULL;
+		}
 
 		BYTE* res = oRes.GetBuffer();
 		oRes.ClearWithoutAttack();

DesktopEditor/doctrenderer/embed/DrawingFileEmbed.cpp

@@ -166,6 +166,48 @@ JSSmart<CJSValue> CDrawingFileEmbed::FreeWasmData(JSSmart<CJSValue> typedArray)
 	return NULL;
 }
 
+JSSmart<CJSValue> CDrawingFileEmbed::SplitPages(JSSmart<CJSValue> arrPageIndexes, JSSmart<CJSValue> data)
+{
+	JSSmart<CJSArray> arrPages = arrPageIndexes->toArray();
+	CJSDataBuffer changes;
+	if (data->isTypedArray())
+		changes = data->toTypedArray()->getData();
+
+	int nCountPages = arrPages->getCount();
+	int* pPages = NULL;
+	if (0 < nCountPages)
+		pPages = new int[nCountPages];
+
+	for (int i = 0; i < nCountPages; i++)
+		pPages[i] = arrPages->get(i)->toInt32();
+
+	JSSmart<CJSValue> res = WasmMemoryToJS(m_pFile->SplitPages(pPages, nCountPages, changes.Data, (LONG)changes.Len));
+	if (pPages)
+		delete [] pPages;
+	return res;
+}
+JSSmart<CJSValue> CDrawingFileEmbed::MergePages(JSSmart<CJSValue> data, JSSmart<CJSValue> nMaxID, JSSmart<CJSValue> sPrefixForm)
+{
+	bool result = false;
+	if (m_pFile)
+	{
+		JSSmart<CJSTypedArray> dataPtr = data->toTypedArray();
+		int maxID = nMaxID->toInt32();
+		std::string prefix = sPrefixForm->toStringA();
+		CJSDataBuffer buffer = dataPtr->getData();
+		result = m_pFile->MergePages(buffer.Data, (LONG)buffer.Len, maxID, prefix, true);
+		if (buffer.IsExternalize)
+			buffer.Free();
+	}
+	return CJSContext::createBool(result);
+}
+JSSmart<CJSValue> CDrawingFileEmbed::UnmergePages()
+{
+	if (m_pFile)
+		return CJSContext::createBool(m_pFile->UnmergePages());
+	return CJSContext::createBool(false);
+}
+
 bool EmbedDrawingFile(JSSmart<NSJSBase::CJSContext>& context, IOfficeDrawingFile* pFile)
 {
 	CJSContext::Embed<CDrawingFileEmbed>(false);

DesktopEditor/doctrenderer/embed/DrawingFileEmbed.h

@@ -51,6 +51,10 @@ public:
 
 	JSSmart<CJSValue> FreeWasmData(JSSmart<CJSValue> typedArray);
 
+	JSSmart<CJSValue> SplitPages(JSSmart<CJSValue> arrPageIndexes, JSSmart<CJSValue> data);
+	JSSmart<CJSValue> MergePages(JSSmart<CJSValue> data, JSSmart<CJSValue> nMaxID, JSSmart<CJSValue> sPrefixForm);
+	JSSmart<CJSValue> UnmergePages();
+
 	DECLARE_EMBED_METHODS
 };
 

DesktopEditor/doctrenderer/embed/GraphicsEmbed.cpp

@@ -160,16 +160,35 @@ void CGraphicsEmbed::SetAppImage(CGraphicsAppImage* appImage)
 
 JSSmart<CJSValue> CGraphicsEmbed::create(JSSmart<CJSValue> Native, JSSmart<CJSValue> width_px, JSSmart<CJSValue> height_px, JSSmart<CJSValue> width_mm, JSSmart<CJSValue> height_mm)
 {
-	NSNativeControl::CNativeControl* pControl = NULL;
 	if (!Native->isNull())
 	{
-		pControl = (NSNativeControl::CNativeControl*)Native->toObject()->getNative()->getObject();
+		JSSmart<CJSObject> pNativeObject = Native->toObject();
+		CJSEmbedObject* pNativeEmbedObject = pNativeObject->getNative();
 
-		if (m_pInternal->m_pAppImage)
+		if (m_pInternal->m_pAppImage && pNativeEmbedObject)
+		{
 			delete m_pInternal->m_pAppImage;
-		m_pInternal->m_pAppImage = new CGraphicsAppImage();
-		m_pInternal->m_pAppImage->SetFontsDirectory(pControl->m_strFontsDirectory);
-		m_pInternal->m_pAppImage->SetImagesDirectory(pControl->m_strImagesDirectory);
+			m_pInternal->m_pAppImage = NULL;
+		}
+
+		if (NULL == m_pInternal->m_pAppImage)
+			m_pInternal->m_pAppImage = new CGraphicsAppImage();
+
+		if (pNativeEmbedObject)
+		{
+			NSNativeControl::CNativeControl* pControl = (NSNativeControl::CNativeControl*)pNativeEmbedObject->getObject();
+			m_pInternal->m_pAppImage->SetFontsDirectory(pControl->m_strFontsDirectory);
+			m_pInternal->m_pAppImage->SetImagesDirectory(pControl->m_strImagesDirectory);
+		}
+		else
+		{
+			JSSmart<CJSValue> checkResources = pNativeObject->get("isResourcesObject");
+			if (checkResources->isBool() && true == checkResources->toBool())
+			{
+				m_pInternal->m_pAppImage->SetFontsDirectory(pNativeObject->get("fontsDirectory")->toStringW());
+				m_pInternal->m_pAppImage->SetImagesDirectory(pNativeObject->get("imagesDirectory")->toStringW());
+			}
+		}
 	}
 
 	m_pInternal->init(width_px->toDouble(), height_px->toDouble(), width_mm->toDouble(), height_mm->toDouble());
@@ -177,7 +196,9 @@ JSSmart<CJSValue> CGraphicsEmbed::create(JSSmart<CJSValue> Native, JSSmart<CJSVa
 }
 JSSmart<CJSValue> CGraphicsEmbed::Destroy()
 {
+	// For save image bits, if needed.
 	m_pInternal->Destroy();
+	RELEASEOBJECT(m_pInternal);
 	return NULL;
 }
 JSSmart<CJSValue> CGraphicsEmbed::EndDraw()

DesktopEditor/doctrenderer/embed/NativeBuilderDocumentEmbed.h

@@ -45,7 +45,7 @@ public:
 
 public:
 	CBuilderDocumentEmbed() : m_pBuilder(NULL), m_bIsValid(false) {}
-	~CBuilderDocumentEmbed() { if(m_pBuilder) RELEASEOBJECT(m_pBuilder); }
+	~CBuilderDocumentEmbed() { if(m_pBuilder && !m_isExternalize) RELEASEOBJECT(m_pBuilder); }
 
 	virtual void* getObject() { return (void*)m_pBuilder; }
 	NSDoctRenderer::CDocBuilder_Private* GetPrivate(NSDoctRenderer::CDocBuilder* pBuilder) { return pBuilder->GetPrivate(); }

DesktopEditor/doctrenderer/embed/NativeBuilderEmbed.cpp

@@ -8,7 +8,22 @@ JSSmart<CJSValue> CBuilderEmbed::OpenFile(JSSmart<CJSValue> sPath, JSSmart<CJSVa
 {
 	std::wstring Path = sPath->toStringW();
 	std::wstring Params = sParams->toStringW();
+
+	// Since we now use snapshots, and we can't always determine which editor is needed
+	// (since the code may be BEFORE opening the file). And if the opening came from
+	// builderJS.OpenFile - in this case we skip reopening.
+	NSDoctRenderer::CDocBuilder_Private* pPrivate = GetPrivate();
+	if (pPrivate->m_pWorker->IsSimpleJSInstance())
+		pPrivate->m_bIsOpenedFromSimpleJS = true;
+
 	int ret = m_pBuilder->OpenFile(Path.c_str(), Params.c_str());
+
+	if (pPrivate->m_pWorker->IsSimpleJSInstance())
+	{
+		JSSmart<CJSContext> current = CJSContext::GetCurrent();
+		current->runScript("throw 0;");
+	}
+
 	return CJSContext::createInt(ret);
 }
 
@@ -20,7 +35,21 @@ JSSmart<CJSValue> CBuilderEmbed::CreateFile(JSSmart<CJSValue> type)
 	else
 		nFormat = type->toInt32();
 
+	// Since we now use snapshots, and we can't always determine which editor is needed
+	// (since the code may be BEFORE opening the file). And if the opening came from
+	// builderJS.OpenFile - in this case we skip reopening.
+	NSDoctRenderer::CDocBuilder_Private* pPrivate = GetPrivate();
+	if (pPrivate->m_pWorker->IsSimpleJSInstance())
+		pPrivate->m_bIsOpenedFromSimpleJS = true;
+
 	bool ret = m_pBuilder->CreateFile(nFormat);
+
+	if (pPrivate->m_pWorker->IsSimpleJSInstance())
+	{
+		JSSmart<CJSContext> current = CJSContext::GetCurrent();
+		current->runScript("throw 0;");
+	}
+
 	return CJSContext::createBool(ret);
 }
 
@@ -41,7 +70,7 @@ JSSmart<CJSValue> CBuilderEmbed::SaveFile(JSSmart<CJSValue> type, JSSmart<CJSVal
 
 	std::wstring sPath = path->toStringW();
 	std::wstring sParams = params->toStringW();
-	int ret = m_pBuilder->SaveFile(nFormat, sPath.c_str(), sParams.empty() ? NULL : sParams.c_str());
+	int ret = GetPrivate()->SaveFile(nFormat, sPath.c_str(), sParams.empty() ? NULL : sParams.c_str(), false);
 	return CJSContext::createInt(ret);
 }
 
@@ -59,6 +88,7 @@ JSSmart<CJSValue> CBuilderEmbed::OpenTmpFile(JSSmart<CJSValue> path, JSSmart<CJS
 	JSSmart<CJSObject> oBuilderTmpDoc = CJSContext::createEmbedObject("CBuilderDocumentEmbed");
 	CBuilderDocumentEmbed* pBuilderTmpDocNative = static_cast<CBuilderDocumentEmbed*>(oBuilderTmpDoc->getNative());
 	pBuilderTmpDocNative->m_pBuilder = m_pBuilder;
+	pBuilderTmpDocNative->SetExternalize(true);
 	pBuilderTmpDocNative->_OpenFile(sPath, sParams);
 	return oBuilderTmpDoc->toValue();
 }

DesktopEditor/doctrenderer/embed/NativeBuilderEmbed.h

@@ -47,9 +47,10 @@ public:
 	NSDoctRenderer::CDocBuilder* m_pBuilder;
 
 	CBuilderEmbed() : m_pBuilder(NULL) {}
-	~CBuilderEmbed() { if(m_pBuilder) RELEASEOBJECT(m_pBuilder); }
+	~CBuilderEmbed() { if(m_pBuilder && !m_isExternalize) RELEASEOBJECT(m_pBuilder); }
 
 	virtual void* getObject() { return (void*)m_pBuilder; }
+	NSDoctRenderer::CDocBuilder_Private* GetPrivate() { return m_pBuilder->GetPrivate(); }
 
 public:
 	JSSmart<CJSValue> OpenFile(JSSmart<CJSValue> sPath, JSSmart<CJSValue> sParams);

DesktopEditor/doctrenderer/embed/jsc/jsc_DrawingFileEmbed.mm

@@ -27,6 +27,9 @@
 -(JSValue*) ScanPage : (JSValue*)nPageIndex : (JSValue*)mode;
 -(JSValue*) GetImageBase64 : (JSValue*)rId;
 -(JSValue*) FreeWasmData : (JSValue*)typedArray;
+-(JSValue*) SplitPages : (JSValue*)arrPageIndexes : (JSValue*)data;
+-(JSValue*) MergePages : (JSValue*)data : (JSValue*)nMaxID : (JSValue*)sPrefixForm;
+-(JSValue*) UnmergePages;
 @end
 
 @interface CJSCDrawingFileEmbed : NSObject<IJSCDrawingFileEmbed, JSEmbedObjectProtocol>
@@ -61,6 +64,9 @@ FUNCTION_WRAPPER_JS_0(IsNeedCMap, IsNeedCMap)
 FUNCTION_WRAPPER_JS_2(ScanPage, ScanPage)
 FUNCTION_WRAPPER_JS_1(GetImageBase64, GetImageBase64)
 FUNCTION_WRAPPER_JS_1(FreeWasmData, FreeWasmData)
+FUNCTION_WRAPPER_JS_2(SplitPages, SplitPages)
+FUNCTION_WRAPPER_JS_3(MergePages, MergePages)
+FUNCTION_WRAPPER_JS_0(UnmergePages, UnmergePages)
 @end
 
 class CDrawingFileEmbedAdapter : public CJSEmbedObjectAdapterJSC

DesktopEditor/doctrenderer/embed/v8/v8_DrawingFileEmbed.cpp

@@ -30,6 +30,9 @@ namespace NSDrawingFileEmbed
 	FUNCTION_WRAPPER_V8_2(_ScanPage, ScanPage)
 	FUNCTION_WRAPPER_V8_1(_GetImageBase64, GetImageBase64)
 	FUNCTION_WRAPPER_V8_1(_FreeWasmData, FreeWasmData)
+	FUNCTION_WRAPPER_V8_2(_SplitPages, SplitPages)
+	FUNCTION_WRAPPER_V8_3(_MergePages, MergePages)
+	FUNCTION_WRAPPER_V8_0(_UnmergePages, UnmergePages)
 
 	v8::Handle<v8::ObjectTemplate> CreateTemplate(v8::Isolate* isolate)
 	{
@@ -59,6 +62,9 @@ namespace NSDrawingFileEmbed
 		NSV8Objects::Template_Set(result, "ScanPage",	_ScanPage);
 		NSV8Objects::Template_Set(result, "GetImageBase64",	_GetImageBase64);
 		NSV8Objects::Template_Set(result, "FreeWasmData",	_FreeWasmData);
+		NSV8Objects::Template_Set(result, "SplitPages",	_SplitPages);
+		NSV8Objects::Template_Set(result, "MergePages",	_MergePages);
+		NSV8Objects::Template_Set(result, "UnmergePages",	_UnmergePages);
 
 		return handle_scope.Escape(result);
 	}

DesktopEditor/doctrenderer/graphics.cpp

@@ -42,6 +42,7 @@ namespace NSGraphics
 
 		m_pRenderer = NSGraphics::Create();
 		m_pRenderer->SetFontManager(pManager);
+		RELEASEINTERFACE(pManager);
 
 		int nRasterW = (int)width_px;
 		int nRasterH = (int)height_px;

DesktopEditor/doctrenderer/graphics.h

@@ -115,17 +115,16 @@ namespace NSGraphics
 	class CGraphics
 	{
 	public:
-		CGraphicsAppImage* m_pAppImage;
+		CGraphicsAppImage* m_pAppImage = nullptr;
 		CBgraFrame m_oFrame;
 
 	private:
-		NSGraphics::IGraphicsRenderer* m_pRenderer;
+		NSGraphics::IGraphicsRenderer* m_pRenderer = nullptr;
 		CGrState   m_oGrState;
 
 	public:
 		CGraphics()
 		{
-			m_pAppImage = NULL;
 		}
 		~CGraphics()
 		{

DesktopEditor/doctrenderer/js_internal/js_base.cpp

@@ -31,6 +31,7 @@ namespace NSJSBase {
 	{
 		embed_native_internal = nullptr;
 		m_pAdapter = nullptr;
+		m_isExternalize = false;
 	}
 
 	CJSEmbedObject::~CJSEmbedObject()
@@ -44,6 +45,16 @@ namespace NSJSBase {
 		return nullptr;
 	}
 
+	void CJSEmbedObject::SetExternalize(const bool& isExternalize)
+	{
+		m_isExternalize = isExternalize;
+	}
+
+	bool CJSEmbedObject::GetExternalize()
+	{
+		return m_isExternalize;
+	}
+
 	CJSEmbedObjectAdapterBase* CJSEmbedObject::getAdapter()
 	{
 		return nullptr;

DesktopEditor/doctrenderer/js_internal/js_base.h

@@ -194,10 +194,18 @@ namespace NSJSBase
 		 */
 		virtual CJSEmbedObjectAdapterBase* getAdapter();
 
+		/**
+		 * Use the externalize flag if you are monitoring the object's destruction yourself.
+		 */
+		virtual void SetExternalize(const bool& isExternalize = true);
+		virtual bool GetExternalize();
+
 	protected:
 		CJSEmbedObjectPrivateBase* embed_native_internal;
 		CJSEmbedObjectAdapterBase* m_pAdapter;
 
+		bool m_isExternalize;
+
 		friend class CJSEmbedObjectPrivateBase;
 		friend class CJSEmbedObjectPrivate;
 	};
@@ -483,6 +491,12 @@ namespace NSJSBase
 		 */
 		void Exit();
 
+		/**
+		 * Сheck if context is current.
+		 * This method is not safe.
+		 */
+		bool IsEntered();
+
 		/**
 		 * Embeds specified class in JS contexts.
 		 * @tparam T Embedded class name.

DesktopEditor/doctrenderer/js_internal/js_embed.h

@@ -10,6 +10,7 @@
 
 @protocol JSEmbedObjectProtocol
 -(void*) getNative;
+-(void) freeNative;
 @end
 
 #if __has_feature(objc_arc)
@@ -41,6 +42,10 @@
 -(void*) getNative								\
 {                                               \
 	return m_internal;                          \
+}                                               \
+-(void) freeNative                              \
+{                                               \
+	RELEASEOBJECT(m_internal);                  \
 }
 
 namespace NSJSBase

DesktopEditor/doctrenderer/js_internal/jsc/jsc_base.h

@@ -34,6 +34,7 @@ namespace NSJSBase
 
 	// embed
 	id CreateEmbedNativeObject(NSString* name);
+	void FreeNativeObject(id embedded_object);
 }
 
 namespace NSJSBase

DesktopEditor/doctrenderer/js_internal/jsc/jsc_base.mm

@@ -232,10 +232,14 @@ namespace NSJSBase
 		{
 			[m_internal->context evaluateScript:@"function jsc_toBase64(r){for(var o=[\"A\",\"B\",\"C\",\"D\",\"E\",\"F\",\"G\",\"H\",\"I\",\"J\",\"K\",\"L\",\"M\",\"N\",\"O\",\"P\",\"Q\",\"R\",\"S\",\"T\",\"U\",\"V\",\"W\",\"X\",\"Y\",\"Z\",\"a\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\",\"h\",\"i\",\"j\",\"k\",\"l\",\"m\",\"n\",\"o\",\"p\",\"q\",\"r\",\"s\",\"t\",\"u\",\"v\",\"w\",\"x\",\"y\",\"z\",\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\",\"+\",\"/\"],a=r.length,f=4*(a/3>>0),n=f/76>>0,t=19,v=0,e=[],i=\"\",s=0;s<=n;s++){s==n&&(t=f%76/4>>0);for(var u=0;u<t;u++){for(var c=0,h=0;h<3;h++)c|=r[0+v++],c<<=8;i=\"\";for(var A=0;A<4;A++){i+=o[c>>>26&255],c<<=6,c&=4294967295}e.push(i)}}if(n=a%3!=0?a%3+1:0){for(c=0,h=0;h<3;h++)h<a%3&&(c|=r[0+v++]),c<<=8;i=\"\";for(A=0;A<n;A++){i+=o[c>>>26&255],c<<=6}t=0!=n?4-n:0;for(u=0;u<t;u++)i+=\"=\";e.push(i)}return e.join(\"\")}function jsc_fromBase64(r,o){for(var a,f=r.length,n=0,t=new Array(void 0===o?f:o),v=t,e=0,i=0;e<f;){for(var s=0,u=0,c=0;c<4&&!(f<=e);c++){var h=65<=(a=r.charCodeAt(e++))&&a<=90?a-65:97<=a&&a<=122?a-71:48<=a&&a<=57?a+4:43==a?62:47==a?63:-1;-1!=h?(s<<=6,s|=h,u+=6):c--}for(s<<=24-u,i=u>>>3,c=0;c<i;c++)v[n++]=(16711680&s)>>>16,s<<=8}return t}\n"];
 		}
-		// insert CreateEmbedObject() function to global object of this context
+		// insert embed functions to global object of this context
 		m_internal->context[@"CreateEmbedObject"] = ^(NSString* name) {
 			return CreateEmbedNativeObject(name);
 		};
+		m_internal->context[@"FreeEmbedObject"] = ^(id embedded_object) {
+			FreeNativeObject(embedded_object);
+		};
+
 
 		JSValue* global_js = [m_internal->context globalObject];
 		[global_js setValue:global_js forProperty:[[NSString alloc] initWithUTF8String:"window"]];
@@ -246,6 +250,8 @@ namespace NSJSBase
 		{
 			CGlobalContext::GetInstance().UnregisterContextForId(*i);
 		}
+		// remove any exceptions pending to not prevent any JSValue deallocations
+		m_internal->context.exception = nil;
 		m_internal->context = nil;
 	}
 
@@ -374,7 +380,7 @@ namespace NSJSBase
 
 	JSSmart<CJSContext> CJSContext::GetCurrent()
 	{
-		CJSContext* ret = new CJSContext();
+		CJSContext* ret = new CJSContext(false);
 		ret->m_internal->context = NSJSBase::CJSContextPrivate::GetCurrentContext();
 		return ret;
 	}
@@ -439,6 +445,11 @@ namespace NSJSBase
 	{
 	}
 
+	bool CJSContext::IsEntered()
+	{
+		return true;
+	}
+
 	class CJSLocalScopePrivate
 	{
 	public:
@@ -498,6 +509,15 @@ namespace NSJSBase
 		return pEmbedObj;
 	}
 
+	void FreeNativeObject(id embedded_object)
+	{
+		// check if the object was actually embedded and do nothing if it wasn't
+		if ([embedded_object conformsToProtocol:@protocol(JSEmbedObjectProtocol)])
+		{
+			[embedded_object freeNative];
+		}
+	}
+
 	JSSmart<CJSValue> CJSEmbedObjectAdapterJSC::Native2Value(JSValue* value)
 	{
 		return js_value(value);

DesktopEditor/doctrenderer/js_internal/v8/v8_base.cpp

@@ -214,12 +214,41 @@ namespace NSJSBase
 			m_internal->m_contextPersistent.Reset(isolate, v8::Context::New(isolate));
 			// create temporary local handle to context
 			m_internal->m_context = v8::Local<v8::Context>::New(isolate, m_internal->m_contextPersistent);
-			// insert CreateEmbedObject() function to global object of this context
+			// insert embed functions to global object of this context
 			m_internal->InsertToGlobal("CreateEmbedObject", CreateEmbedNativeObject);
+			m_internal->InsertToGlobal("FreeEmbedObject", FreeNativeObject);
 			// clear temporary local handle
 			m_internal->m_context.Clear();
 		}
 	}
+
+	class WeakHandleVisitor : public v8::PersistentHandleVisitor
+	{
+	private:
+		WeakHandleVisitor() = default;
+
+	public:
+		void VisitPersistentHandle(v8::Persistent<v8::Value>* value, uint16_t class_id) override
+		{
+			if (class_id == CJSEmbedObjectPrivate::kWeakHandleId)
+			{
+				v8::Isolate* isolate = v8::Isolate::GetCurrent();
+				v8::HandleScope scope(isolate);
+				v8::Local<v8::Object> handle = value->Get(isolate).As<v8::Object>();
+				v8::Local<v8::External> field = v8::Local<v8::External>::Cast(handle->GetInternalField(0));
+				CJSEmbedObject* native = static_cast<CJSEmbedObject*>(field->Value());
+				delete native;
+			}
+		}
+
+	public:
+		static WeakHandleVisitor* getInstance()
+		{
+			static WeakHandleVisitor visitor;
+			return &visitor;
+		}
+	};
+
 	void CJSContext::Dispose()
 	{
 #ifdef V8_INSPECTOR
@@ -228,7 +257,13 @@ namespace NSJSBase
 #endif
 
 		m_internal->m_contextPersistent.Reset();
-		m_internal->m_isolate->Dispose();
+		// destroy native object in the weak handles before isolate disposal
+		v8::Isolate* isolate = m_internal->m_isolate;
+		{
+			v8::Isolate::Scope scope(isolate);
+			isolate->VisitHandlesWithClassIds(WeakHandleVisitor::getInstance());
+		}
+		isolate->Dispose();
 		m_internal->m_isolate = NULL;
 	}
 
@@ -255,6 +290,8 @@ namespace NSJSBase
 		m_internal->m_context = v8::Local<v8::Context>::New(isolate, m_internal->m_contextPersistent);
 		if (!m_internal->m_context.IsEmpty())
 			m_internal->m_context->Enter();
+
+		m_internal->m_entered = true;
 	}
 
 	void CJSContext::Exit()
@@ -271,6 +308,13 @@ namespace NSJSBase
 		else
 			m_internal->m_context = m_internal->m_isolate->GetCurrentContext();
 		m_internal->m_isolate->Exit();
+
+		m_internal->m_entered = false;
+	}
+
+	bool CJSContext::IsEntered()
+	{
+		return m_internal->m_entered;
 	}
 
 	CJSValue* CJSContext::createUndefined()
@@ -646,4 +690,22 @@ namespace NSJSBase
 		NSJSBase::CJSEmbedObjectPrivate::CreateWeaker(obj);
 		args.GetReturnValue().Set(obj);
 	}
+
+	void FreeNativeObject(const v8::FunctionCallbackInfo<v8::Value>& args)
+	{
+		v8::Isolate* isolate = args.GetIsolate();
+		v8::HandleScope scope(isolate);
+
+		if (args.Length() != 1)
+		{
+			args.GetReturnValue().Set(v8::Undefined(isolate));
+			return;
+		}
+
+		v8::Local<v8::Object> obj = args[0].As<v8::Object>();
+		v8::Local<v8::External> field = v8::Local<v8::External>::Cast(obj->GetInternalField(0));
+		CJSEmbedObject* native = static_cast<CJSEmbedObject*>(field->Value());
+		delete native;
+		// weak persistent handle will be cleared and removed in CJSEmbedObjectPrivate destructor
+	}
 }

DesktopEditor/doctrenderer/js_internal/v8/v8_base.h

@@ -857,12 +857,14 @@ namespace NSJSBase
 		v8::Local<v8::Context>			m_context;
 
 		v8::StartupData m_startup_data;
+		bool m_entered;
 
 	public:
 		CJSContextPrivate() : m_isolate(NULL)
 		{
 			m_startup_data.data = NULL;
 			m_startup_data.raw_size = 0;
+			m_entered = false;
 		}
 
 		void InsertToGlobal(const std::string& name, v8::FunctionCallback creator)
@@ -881,6 +883,7 @@ namespace NSJSBase
 
 	// embed
 	void CreateEmbedNativeObject(const v8::FunctionCallbackInfo<v8::Value>& args);
+	void FreeNativeObject(const v8::FunctionCallbackInfo<v8::Value>& args);
 
 	class CJSEmbedObjectAdapterV8Template : public CJSEmbedObjectAdapterBase
 	{
@@ -898,6 +901,8 @@ namespace NSJSBase
 	{
 	public:
 		v8::Persistent<v8::Object> handle;
+		// contstant id for all weak native handles
+		static const uint16_t kWeakHandleId = 1;
 
 		CJSEmbedObjectPrivate(v8::Local<v8::Object> obj)
 		{
@@ -916,6 +921,8 @@ namespace NSJSBase
 
 			handle.Reset(CV8Worker::GetCurrent(), obj);
 			handle.SetWeak(pEmbedObject, EmbedObjectWeakCallback, v8::WeakCallbackType::kParameter);
+			// set class_id for being able to iterate over all these handles to destroy them on isolate disposal
+			handle.SetWrapperClassId(kWeakHandleId);
 
 			pEmbedObject->embed_native_internal = this;
 		}
@@ -929,8 +936,6 @@ namespace NSJSBase
 
 		static void EmbedObjectWeakCallback(const v8::WeakCallbackInfo<CJSEmbedObject>& data)
 		{
-			v8::Isolate* isolate = data.GetIsolate();
-			v8::HandleScope scope(isolate);
 			CJSEmbedObject* wrap = data.GetParameter();
 			((CJSEmbedObjectPrivate*)wrap->embed_native_internal)->handle.Reset();
 			delete wrap;

DesktopEditor/doctrenderer/test/embed/external/Embed.cpp

@@ -1,4 +1,15 @@
 #include "Embed.h"
+#include <iostream>
+
+CTestEmbed::CTestEmbed()
+{
+	std::cout << "debug: CTestEmbed constructed" << std::endl;
+}
+
+CTestEmbed::~CTestEmbed()
+{
+	std::cout << "debug: CTestEmbed destroyed" << std::endl;
+}
 
 #ifdef ENABLE_SUM_DEL
 JSSmart<CJSValue> CTestEmbed::FunctionSum(JSSmart<CJSValue> param1, JSSmart<CJSValue> param2)

DesktopEditor/doctrenderer/test/embed/external/Embed.h

@@ -1,5 +1,5 @@
-#ifndef _BUILD_NATIVE_HASH_EMBED_H_
-#define _BUILD_NATIVE_HASH_EMBED_H_
+#ifndef CTESTEMBED_H_
+#define CTESTEMBED_H_
 
 #include "js_internal/js_base.h"
 
@@ -10,13 +10,8 @@ using namespace NSJSBase;
 class CTestEmbed : public CJSEmbedObject
 {
 public:
-	CTestEmbed()
-	{
-	}
-
-	~CTestEmbed()
-	{
-	}
+	CTestEmbed();
+	~CTestEmbed();
 
 	virtual void* getObject() override { return NULL; }
 
@@ -33,4 +28,4 @@ public:
 	DECLARE_EMBED_METHODS
 };
 
-#endif // _BUILD_NATIVE_HASH_EMBED_H_
+#endif // CTESTEMBED_H_

DesktopEditor/doctrenderer/test/embed/external/main.cpp

@@ -1,278 +1,14 @@
-/*
- * (c) Copyright Ascensio System SIA 2010-2019
- *
- * 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-12 Ernesta Birznieka-Upisha
- * 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 "test_functions.h"
 
-#include <iostream>
-
-#include "embed/Default.h"
-#include "js_internal/js_base.h"
-#include "Embed.h"
-
-using namespace NSJSBase;
-int main(int argc, char *argv[])
+int main()
 {
-#if 0
-	// Primitives example
+	// TODO: test
 
-	JSSmart<CJSContext> oContext1 = new CJSContext(false);
-	oContext1->Initialize();
-
-	JSSmart<CJSContext> oContext2 = new CJSContext;
-//	oContext2->Initialize();
-
-	// Work with first context
-	oContext1->Enter();
-
-	{
-		CJSContextScope scope(oContext1);
-		CJSLocalScope local_scope;
-		JSSmart<CJSValue> oResLocal = oContext1->runScript("function f() { return 'Local scope test'; }; f();");
-		std::cout << oResLocal->toStringA() << std::endl;
-	}
-	JSSmart<CJSObject> oGlobal1 = oContext1->GetGlobal();
-	JSSmart<CJSValue> oVar2 = oContext1->createString("Hel");
-	oGlobal1->set("v1", oVar2.GetPointer());
-	oContext1->runScript("var res = v1 + 'lo'");
-
-	oContext1->Exit();
-
-	// Work with second context with CJSContextScope usage
-	{
-		CJSContextScope scope(oContext2);
-
-		JSSmart<CJSObject> oGlobal2 = oContext2->GetGlobal();
-		JSSmart<CJSValue> oVar4 = oContext2->createString("Wor");
-		oGlobal2->set("v1", oVar4.GetPointer());
-		oContext2->runScript("var res = v1 + 'ld!'");
-	}
-
-	// Print result from first context
-	oContext1->Enter();
-
-	JSSmart<CJSValue> oRes1 = oContext1->runScript("function f() { return res; }; f();");
-	std::string strRes1 = oRes1->toStringA();
-	std::cout << strRes1 << std::endl;
-
-	// Print second variable
-	oContext2->Enter();
-
-	JSSmart<CJSValue> oRes2 = oContext1->runScript("function f() { return res; }; f();");
-	std::string strRes2 = oRes2->toStringA();
-	std::cout << strRes2 << std::endl;
-
-	oContext2->Exit();
-	oContext1->Exit();
-
-//	oContext1->Dispose();
-	oContext2->Dispose();
-
-#endif
-
-#if 0
-	// External embed example
-
-	JSSmart<CJSContext> oContext1 = new CJSContext();
-
-	// Embedding
-	CJSContextScope scope(oContext1);
-	CJSContext::Embed<CTestEmbed>();
-
-	JSSmart<CJSValue> oResTestEmbed1 = oContext1->runScript("(function() { var value = CreateEmbedObject('CTestEmbed'); return value.FunctionSum(10, 5); })();");
-	std::cout << "FunctionSum(10, 5) = " << oResTestEmbed1->toInt32() << std::endl;
-
-	JSSmart<CJSValue> oResTestEmbed2 = oContext1->runScript("(function() { var value = CreateEmbedObject('CTestEmbed'); return value.FunctionSquare(4); })();");
-	std::cout << "FunctionSquare(4) = " << oResTestEmbed2->toInt32() << std::endl;
-
-	JSSmart<CJSValue> oResTestEmbed3 = oContext1->runScript("(function() { var value = CreateEmbedObject('CTestEmbed'); return value.FunctionDel(30, 3); })();");
-	std::cout << "FunctionDel(30, 3) = " << oResTestEmbed3->toInt32() << std::endl;
-
-	JSSmart<CJSValue> oResTestEmbed4 = oContext1->runScript("(function() { var value = CreateEmbedObject('CTestEmbed'); return value.FunctionGet(); })();");
-	std::cout << "FunctionGet() = " << oResTestEmbed4->toInt32() << std::endl;
-
-#endif
-
-#if 0
-	// CZipEmbed example
-
-	JSSmart<CJSContext> oContext1 = new CJSContext();
-	JSSmart<CJSContext> oContext2 = new CJSContext();
-
-	// Work with first context
-	oContext1->Enter();
-	CreateDefaults();
-	JSSmart<CJSValue> oRes1 = oContext1->runScript(
-		"var oZip = CreateEmbedObject('CZipEmbed');\n"
-		"var files = oZip.open('" CURR_DIR "');\n"
-		"oZip.close();");
-	oContext1->Exit();
-
-	// Work with second context
-	{
-		CJSContextScope scope(oContext2);
-//		CreateDefaults();
-		JSSmart<CJSValue> oRes2 = oContext2->runScript(
-			"var oZip = CreateEmbedObject('CZipEmbed');\n"
-			"var files = oZip.open('" CURR_DIR "/../embed');\n"
-			"oZip.close();");
-	}
-
-	// Print first result
-	oContext1->Enter();
-	JSSmart<CJSObject> oGlobal1 = oContext1->GetGlobal();
-	JSSmart<CJSArray> oFiles1 = oGlobal1->get("files")->toArray();
-	std::cout << "\nRESULT FROM CONTEXT 1:\n";
-	for (int i = 0; i < oFiles1->getCount(); i++)
-	{
-		std::cout << oFiles1->get(i)->toStringA() << std::endl;
-	}
-
-	// Print second result
-	oContext2->Enter();
-	JSSmart<CJSObject> oGlobal2 = oContext2->GetGlobal();
-	JSSmart<CJSArray> oFiles2 = oGlobal2->get("files")->toArray();
-	std::cout << "\nRESULT FROM CONTEXT 2:\n";
-	for (int i = 0; i < oFiles2->getCount(); i++)
-	{
-		std::cout << oFiles2->get(i)->toStringA() << std::endl;
-	}
-	oContext2->Exit();
-	oContext1->Exit();
-
-#endif
-
-#if 0
-	// CHashEmbed example
-
-	JSSmart<CJSContext> oContext1 = new CJSContext();
-
-	// Call hash() on first context
-	CJSContextScope scope(oContext1);
-	CreateDefaults();
-	JSSmart<CJSValue> oRes1 = oContext1->runScript(
-		"var oHash = CreateEmbedObject('CHashEmbed');\n"
-		"var str = 'test';\n"
-		"var hash = oHash.hash(str, str.length, 0);");
-
-	// Print first result
-	JSSmart<CJSObject> oGlobal1 = oContext1->GetGlobal();
-	JSSmart<CJSTypedArray> oHash = oGlobal1->get("hash")->toTypedArray();
-	std::cout << "\nRESULTED HASH:\n";
-	for (int i = 0; i < oHash->getCount(); i++)
-	{
-		std::cout << std::hex << static_cast<unsigned>(oHash->getData().Data[i]);
-	}
-	std::cout << std::endl;
-
-	// Call hash2() on first context
-	JSSmart<CJSValue> oRes2 = oContext1->runScript(
-		"var str2 = 'test';\n"
-		"var hash2 = oHash.hash2(str2, 'yrGivlyCImiWnryRee1OJw==', 100000, 7);");
-
-	// Print first result
-	JSSmart<CJSTypedArray> oHash2 = oGlobal1->get("hash2")->toTypedArray();
-	std::cout << "\nRESULTED HASH2:\n";
-	for (int i = 0; i < oHash2->getCount(); i++)
-	{
-		std::cout << std::hex << static_cast<unsigned>(oHash2->getData().Data[i]);
-	}
-	std::cout << std::endl;
-
-#endif
-
-#if 1
-	// Mixed embed example
-
-	JSSmart<CJSContext> oContext1 = new CJSContext();
-
-	// External CTestEmbed
-	CJSContextScope scope(oContext1);
-	CJSContext::Embed<CTestEmbed>(false);
-
-	JSSmart<CJSValue> oResTestEmbed1 = oContext1->runScript("(function() { var value = CreateEmbedObject('CTestEmbed'); return value.FunctionSum(10, 5); })();");
-	if (oResTestEmbed1->isNumber())
-		std::cout << "FunctionSum(10, 5) = " << oResTestEmbed1->toInt32() << std::endl;
-
-	JSSmart<CJSObject> oTestEmbed = CJSContext::createEmbedObject("CTestEmbed");
-
-//	JSSmart<CJSValue> oResTestEmbed2 = oContext1->runScript("(function() { var value = CreateEmbedObject('CTestEmbed'); return value.FunctionSquare(4); })();");
-	JSSmart<CJSValue> args2[1];
-	args2[0] = CJSContext::createInt(4);
-	JSSmart<CJSValue> oResTestEmbed2 = oTestEmbed->call_func("FunctionSquare", 1, args2);
-	if (oResTestEmbed2->isNumber())
-		std::cout << "FunctionSquare(4) = " << oResTestEmbed2->toInt32() << std::endl;
-
-//	JSSmart<CJSValue> oResTestEmbed3 = oContext1->runScript("(function() { var value = CreateEmbedObject('CTestEmbed'); return value.FunctionDel(30, 3); })();");
-	JSSmart<CJSValue> args3[2];
-	args3[0] = CJSContext::createInt(30);
-	args3[1] = CJSContext::createInt(3);
-	JSSmart<CJSValue> oResTestEmbed3 = oTestEmbed->call_func("FunctionDel", 2, args3);
-	if (oResTestEmbed3->isNumber())
-		std::cout << "FunctionDel(30, 3) = " << oResTestEmbed3->toInt32() << std::endl;
-
-	JSSmart<CJSValue> oResTestEmbed4 = oContext1->runScript("(function() { var value = CreateEmbedObject('CTestEmbed'); return value.FunctionGet(); })();");
-	if (oResTestEmbed4->isNumber())
-		std::cout << "FunctionGet() = " << oResTestEmbed4->toInt32() << std::endl;
-
-	// Internal CHashEmbed
-	CreateDefaults();
-	oContext1->runScript(
-		"var oHash = CreateEmbedObject('CHashEmbed');\n"
-		"var str = 'test';\n"
-		"var hash = oHash.hash(str, str.length, 0);");
-
-	// Print hash
-	JSSmart<CJSObject> oGlobal = oContext1->GetGlobal();
-	JSSmart<CJSTypedArray> oHash = oGlobal->get("hash")->toTypedArray();
-	std::cout << "\nRESULTED HASH:\n";
-	for (int i = 0; i < oHash->getCount(); i++)
-	{
-		std::cout << std::hex << static_cast<unsigned>(oHash->getData().Data[i]);
-	}
-	std::cout << std::endl;
-
-	// Internal CZipEmbed
-	oContext1->runScript(
-		"var oZip = CreateEmbedObject('CZipEmbed');\n"
-		"var files = oZip.open('" CURR_DIR "');\n"
-		"oZip.close();");
-
-	// Print files
-	JSSmart<CJSArray> oFiles1 = oGlobal->get("files")->toArray();
-	std::cout << "\nFILES IN CURRENT DIRECTORY:\n";
-	for (int i = 0; i < oFiles1->getCount(); i++)
-	{
-		std::cout << oFiles1->get(i)->toStringA() << std::endl;
-	}
-
-#endif
+	// testMultipleContexts();
+	testEmbedExternal();
+	// testEmbedInternal();
+	// testHashEmbed();
+	// testEmbedMixed();
 
 	return 0;
 }

DesktopEditor/doctrenderer/test/embed/external/main.mm

@@ -0,0 +1,14 @@
+#include "test_functions.h"
+
+int main()
+{
+	// all test functions should be called inside the `@autoreleasepool` block!
+	@autoreleasepool
+	{
+		testEmbedExternal();
+		// testHashEmbed();
+		// testEmbedMixed();
+	}
+
+	return 0;
+}

DesktopEditor/doctrenderer/test/embed/external/test.pro

@@ -29,10 +29,18 @@ core_linux {
     LIBS += -ldl
 }
 
-SOURCES += main.cpp \
-    Embed.cpp
-
 HEADERS += \
-    Embed.h
+	Embed.h \
+	test_functions.h
+
+SOURCES += \
+	Embed.cpp \
+	test_functions.cpp
+
+use_javascript_core {
+	OBJECTIVE_SOURCES += main.mm
+} else {
+	SOURCES += main.cpp
+}
 
 ADD_FILES_FOR_EMBEDDED_CLASS_HEADER(Embed.h)

DesktopEditor/doctrenderer/test/embed/external/test_functions.cpp

@@ -0,0 +1,286 @@
+#include "test_functions.h"
+
+#include <iostream>
+
+#include "embed/Default.h"
+#include "js_internal/js_base.h"
+#include "Embed.h"
+
+using namespace NSJSBase;
+
+void testMultipleContexts()
+{
+	// passing `false` when creating CJSContext means that we need to initialize it manually
+	JSSmart<CJSContext> context1 = new CJSContext(false);
+	context1->Initialize();
+
+	// while creating CJSContext without any arguments will create initialized CJSContext
+	JSSmart<CJSContext> context2 = new CJSContext;
+	// we don't need it:
+	// oContext2->Initialize();
+
+	// entering the first context
+	context1->Enter();
+	{
+		// entering the first context the second time in scope creation  - it's allowed and the scopes stack correctly
+		CJSContextScope scope(context1);
+		// allocate new local variables inside a custom local scope instead of
+		//  the one that is provided by CJSContextScope by default
+		CJSLocalScope local_scope;
+		JSSmart<CJSValue> res_local = context1->runScript("(function() { return 'Local scope test'; })();");
+		std::cout << res_local->toStringA() << std::endl;
+		// the first context is going to be exited at the end of the scope
+	}
+	// at this moment we are still inside the first context, since we have entered it twices
+	JSSmart<CJSObject> global1 = context1->GetGlobal();
+	JSSmart<CJSValue> var = context1->createString("Hel");
+	global1->set("v1", var);
+	// here `res` is set to be "Hello"
+	context1->runScript("var res = v1 + 'lo'");
+	// exit from the first context
+	context1->Exit();
+
+	// now we are going to work with the second context
+	{
+		// enter the second context via context scope
+		CJSContextScope scope(context2);
+
+		JSSmart<CJSObject> global2 = context2->GetGlobal();
+		JSSmart<CJSValue> var = context2->createString("Wor");
+		global2->set("v1", var);
+		// `res` is "World!"
+		context2->runScript("var res = v1 + 'ld!'");
+		// the second context is going to be exited at the end of the scope
+	}
+
+	// enter the first context
+	context1->Enter();
+	// print `res` variable from the first context
+	JSSmart<CJSValue> res1 = context1->runScript("(function() { return res; })();");
+	std::string str_res1 = res1->toStringA();
+	std::cout << str_res1 << ", ";
+	// make new variable `v2` in first context
+	// important to note, that accessing previous `global1` object is undefined behaviour and can lead to crashes!
+	// that is because when we exited from the first context, every local handle inside CJSValue and CJSObject was invalidated
+	global1 = context1->GetGlobal();
+	global1->set("v2", CJSContext::createInt(42));
+
+	// enter from the second context (notice, we haven't exited the first context before)
+	context2->Enter();
+	// print `res` variable from the second context
+	JSSmart<CJSValue> res2 = context1->runScript("(function() { return res; })();");
+	std::string str_res2 = res2->toStringA();
+	std::cout << str_res2 << std::endl;
+
+	// exit from the second context
+	context2->Exit();
+
+	// at this moment we are still in the first context
+	// we can validate that accessing `v2` variable, which exists only in the first context
+	global1 = context1->GetGlobal();
+	std::cout << global1->get("v2")->toInt32() << std::endl;
+	// exit from the first context
+	context1->Exit();
+
+	// manual disposing is not necessary, since it's going to be called in CJSContext's destructor anyway
+	// so we don't need to explicitly write:
+	// oContext1->Dispose();
+
+	// but still nothing wrong will happen if we do:
+	context2->Dispose();
+}
+
+void testEmbedExternal()
+{
+	JSSmart<CJSContext> context = new CJSContext();
+
+	// Embedding
+	CJSContextScope scope(context);
+	CJSContext::Embed<CTestEmbed>();
+
+	JSSmart<CJSValue> res1 = context->runScript("(function() { let value = CreateEmbedObject('CTestEmbed'); let ret = value.FunctionSum(10, 5); FreeEmbedObject(value); return ret; })();");
+	std::cout << "FunctionSum(10, 5) = " << res1->toInt32() << std::endl;
+
+	JSSmart<CJSValue> res2 = context->runScript("(function() { let value = CreateEmbedObject('CTestEmbed'); let ret = value.FunctionSquare(4); FreeEmbedObject(value); return ret; })();");
+	std::cout << "FunctionSquare(4) = " << res2->toInt32() << std::endl;
+
+	JSSmart<CJSValue> res3 = context->runScript("(function() { let value = CreateEmbedObject('CTestEmbed'); let ret = value.FunctionDel(30, 3); FreeEmbedObject(value); return ret; })();");
+	std::cout << "FunctionDel(30, 3) = " << res3->toInt32() << std::endl;
+
+	JSSmart<CJSValue> res4 = context->runScript("(function() { let value = CreateEmbedObject('CTestEmbed'); let ret = value.FunctionGet(); FreeEmbedObject(value); return ret; })();");
+	std::cout << "FunctionGet() = " << res4->toInt32() << std::endl;
+}
+
+void testEmbedInternal()
+{
+	// create both contexts
+	JSSmart<CJSContext> context1 = new CJSContext();
+	JSSmart<CJSContext> context2 = new CJSContext();
+
+	// work with the first context
+	context1->Enter();
+	// create embedding info for internally embedded objects (CZipEmbed is the one of them)
+	CreateDefaults();
+	context1->runScript(
+		"var oZip = CreateEmbedObject('CZipEmbed');\n"
+		"var files = oZip.open('" CURR_DIR "');\n"
+		"oZip.close();"
+	);
+	context1->Exit();
+
+	// work with the second context via context scope
+	{
+		CJSContextScope scope(context2);
+		// function CJSContext::Embed() is context-independent, so we don't actually need to call it in another context
+		// CreateDefaults();
+		context2->runScript(
+			"var oZip = CreateEmbedObject('CZipEmbed');\n"
+			"var files = oZip.open('" CURR_DIR "/../../../embed');\n"
+			"oZip.close();"
+		);
+	}
+
+	// print the files from the first context
+	context1->Enter();
+	JSSmart<CJSObject> global1 = context1->GetGlobal();
+	JSSmart<CJSArray> file_list1 = global1->get("files")->toArray();
+	std::cout << "\nRESULT FROM CONTEXT 1:\n";
+	for (int i = 0; i < file_list1->getCount(); i++)
+	{
+		std::cout << file_list1->get(i)->toStringA() << std::endl;
+	}
+
+	// print the files from the second result (note, we haven't exited the first context before)
+	context2->Enter();
+	JSSmart<CJSObject> global2 = context2->GetGlobal();
+	JSSmart<CJSArray> file_list2 = global2->get("files")->toArray();
+	std::cout << "\nRESULT FROM CONTEXT 2:\n";
+	for (int i = 0; i < file_list2->getCount(); i++)
+	{
+		std::cout << file_list2->get(i)->toStringA() << std::endl;
+	}
+
+	// exit the contexts in reverse order
+	context2->Exit();
+	context1->Exit();
+}
+
+void testHashEmbed()
+{
+	JSSmart<CJSContext> context = new CJSContext();
+
+	// test hash()
+	CJSContextScope scope(context);
+	CreateDefaults();
+	context->runScript(
+		"var oHash = CreateEmbedObject('CHashEmbed');\n"
+		"var str = 'test';\n"
+		"var hash = oHash.hash(str, str.length, 0);"
+	);
+
+	JSSmart<CJSObject> global = context->GetGlobal();
+	JSSmart<CJSTypedArray> res_hash = global->get("hash")->toTypedArray();
+	std::cout << "\nRESULTED HASH:\n";
+	for (int i = 0; i < res_hash->getCount(); i++)
+	{
+		std::cout << std::hex << static_cast<unsigned>(res_hash->getData().Data[i]);
+	}
+	std::cout << std::endl;
+
+	// test hash2()
+	context->runScript(
+		"var str2 = 'test';\n"
+		"var hash2 = oHash.hash2(str2, 'yrGivlyCImiWnryRee1OJw==', 100000, 7);"
+	);
+
+	JSSmart<CJSTypedArray> res_hash2 = global->get("hash2")->toTypedArray();
+	std::cout << "\nRESULTED HASH2:\n";
+	for (int i = 0; i < res_hash2->getCount(); i++)
+	{
+		std::cout << std::hex << static_cast<unsigned>(res_hash2->getData().Data[i]);
+	}
+	std::cout << std::endl;
+}
+
+void testEmbedMixed()
+{
+	JSSmart<CJSContext> context = new CJSContext();
+	CJSContextScope scope(context);
+
+
+	// --- test external embedding with CTestEmbed ---
+	// embed with `false` - means we are not able to create the object directly from JavaScript.
+	CJSContext::Embed<CTestEmbed>(false);
+
+	// example of incorrect usage:
+	JSSmart<CJSValue> res1 = context->runScript("(function() { var value = CreateEmbedObject('CTestEmbed'); return value.FunctionSum(10, 5); })();");
+	if (res1->isNumber())
+	{
+		// this wouldn't print anything, since `res1` not a number - embedded object was not created in JS and exception was thrown.
+		std::cout << "FunctionSum(10, 5) = " << res1->toInt32() << std::endl;
+	}
+
+	// example of correct usage:
+	JSSmart<CJSObject> embedded_object = CJSContext::createEmbedObject("CTestEmbed");
+	JSSmart<CJSValue> args2[1];
+	args2[0] = CJSContext::createInt(4);
+	JSSmart<CJSValue> res2 = embedded_object->call_func("FunctionSquare", 1, args2);
+	if (res2->isNumber())
+	{
+		// should print: "FunctionSquare(4) = 16"
+		std::cout << "FunctionSquare(4) = " << res2->toInt32() << std::endl;
+	}
+
+	// another example of correct usage:
+	JSSmart<CJSValue> args3[2];
+	args3[0] = CJSContext::createInt(30);
+	args3[1] = CJSContext::createInt(3);
+	JSSmart<CJSValue> oResTestEmbed3 = embedded_object->call_func("FunctionDel", 2, args3);
+	if (oResTestEmbed3->isNumber())
+	{
+		// should print: "FunctionDel(30, 3) = 10"
+		std::cout << "FunctionDel(30, 3) = " << oResTestEmbed3->toInt32() << std::endl;
+	}
+
+	// another example of incorrect usage:
+	JSSmart<CJSValue> oResTestEmbed4 = context->runScript("(function() { var value = CreateEmbedObject('CTestEmbed'); return value.FunctionGet(); })();");
+	if (oResTestEmbed4->isNumber())
+	{
+		// again, this won't be executed and nothing will be printed
+		std::cout << "FunctionGet() = " << oResTestEmbed4->toInt32() << std::endl;
+	}
+
+
+	// --- test internal embedding with CHashEmbed ---
+	CreateDefaults();
+	context->runScript(
+		"var oHash = CreateEmbedObject('CHashEmbed');\n"
+		"var str = 'test';\n"
+		"var hash = oHash.hash(str, str.length, 0);"
+	);
+	// print hash
+	JSSmart<CJSObject> global = context->GetGlobal();
+	JSSmart<CJSTypedArray> hash = global->get("hash")->toTypedArray();
+	std::cout << "\nRESULTED HASH:\n";
+	for (int i = 0; i < hash->getCount(); i++)
+	{
+		std::cout << std::hex << static_cast<unsigned>(hash->getData().Data[i]);
+	}
+	std::cout << std::endl;
+
+
+	// --- test internal embedding with CZipEmbed ---
+	context->runScript(
+		"var oZip = CreateEmbedObject('CZipEmbed');\n"
+		"var files = oZip.open('" CURR_DIR "');\n"
+		"oZip.close();"
+	);
+
+	// print files
+	JSSmart<CJSArray> file_list = global->get("files")->toArray();
+	std::cout << "\nFILES IN CURRENT DIRECTORY:\n";
+	for (int i = 0; i < file_list->getCount(); i++)
+	{
+		std::cout << file_list->get(i)->toStringA() << std::endl;
+	}
+}

DesktopEditor/doctrenderer/test/embed/external/test_functions.h

@@ -0,0 +1,34 @@
+#ifndef TEST_FUNCTIONS_H_
+#define TEST_FUNCTIONS_H_
+
+
+/**
+ * NOTE: V8 ONLY!
+ * The function tests the work of two CJSContexts in one thread.
+ * Current working context is managed with Enter() and Exit() functions, or with CJSContextScope.
+ */
+void testMultipleContexts();
+
+/**
+ * The function tests external embedding functionality by embedding CTestEmbed class.
+ */
+void testEmbedExternal();
+
+/**
+ * NOTE: V8 ONLY!
+ * The function tests internal embedding functionality by using CZipEmbed class.
+ * It also shows how embedding works for two CJSContext in the same thread (similar to testMultipleContexts()).
+ */
+void testEmbedInternal();
+
+/**
+ * The function tests CHashEmbed class that is embedded internally.
+ */
+void testHashEmbed();
+
+/**
+ * The function tests both internal and external embedding in a more complicated way.
+ */
+void testEmbedMixed();
+
+#endif // TEST_FUNCTIONS_H_

DesktopEditor/fontengine/ApplicationFonts.cpp

@@ -1853,6 +1853,16 @@ std::vector<std::wstring> CApplicationFonts::GetSetupFontFiles(const bool& bIsUs
 #if defined(_MAC) && !defined(_IOS)
 	std::vector<std::wstring> _array = NSDirectory::GetFiles(L"/Library/Fonts", true);
 	NSDirectory::GetFiles2(L"/System/Library/Fonts", _array, true);
+
+	std::set<std::wstring> installedList = GetInstalledFontsMac();
+	for (const auto& sysPath : installedList) {
+		if (0 == sysPath.find(L"/System/Library/Fonts/"))
+			continue;
+		if (0 == sysPath.find(L"/Library/Fonts/"))
+			continue;
+		_array.push_back(sysPath);
+	}
+
 	return _array;
 #endif
 
@@ -1958,6 +1968,10 @@ namespace NSFonts
 		if (FT_Open_Face(m_internal->m_library, &oOpenArgs, nFaceIndex, &pFace))
 			return;
 
+		bool bIsASC = false;
+		if (pFace->family_name && (0 == strcmp(pFace->family_name, "ASCW3")))
+			bIsASC = true;
+
 		for (int nCharMap = 0; nCharMap < pFace->num_charmaps; nCharMap++)
 		{
 			FT_Set_Charmap(pFace, pFace->charmaps[nCharMap]);
@@ -1967,7 +1981,8 @@ namespace NSFonts
 
 			while (indexG)
 			{
-				pChecker->Check((int)character, indexG);
+				if (!bIsASC || (character < 35 || character > 255))
+					pChecker->Check((int)character, indexG);
 				character = FT_Get_Next_Char(pFace, character, &indexG);
 			}
 		}

DesktopEditor/fontengine/ApplicationFonts.h

@@ -38,6 +38,7 @@
 #include <vector>
 #include <list>
 #include "FontManager.h"
+#include <set>
 
 namespace NSFonts
 {
@@ -354,6 +355,10 @@ public:
 	void InitFromReg();
 #endif
 
+#if defined(_MAC) && !defined(_IOS)
+	std::set<std::wstring> GetInstalledFontsMac();
+#endif
+
 	NSFonts::IFontManager* GenerateFontManager();
 
 	std::wstring GetFontBySymbol(int symbol);

DesktopEditor/fontengine/ApplicationFontsWorker.cpp

@@ -877,6 +877,11 @@ public:
 				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"PingFang SC", 36));
 				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"PingFang TC", 37));
 				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"PingFang HK", 38));
+
+				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Heiti SC", 39));
+				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Heiti TC", 40));
+				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Songti SC", 41));
+				mapFontsPriorityStandard.insert(std::pair<std::wstring, int>(L"Songti TC", 42));
 #endif
 
 				NSFonts::CApplicationFontsSymbols oApplicationChecker;
@@ -1604,6 +1609,14 @@ NSFonts::IApplicationFonts* CApplicationFontsWorker::Check()
 	if (m_sDirectory.empty())
 		return NULL;
 
+	for (std::vector<std::wstring>::iterator i = m_arAdditionalFolders.begin(); i != m_arAdditionalFolders.end(); i++)
+	{
+		if (0 == i->find(L"./"))
+			*i = NSFile::GetProcessDirectory() + L"/" + i->substr(2);
+		else if (0 == i->find(L"../"))
+			*i = NSFile::GetProcessDirectory() + L"/" + *i;
+	}
+
 	std::wstring strAllFontsJSPath      = m_sDirectory + L"/AllFonts.js";
 	std::wstring strFontsSelectionBin   = m_sDirectory + L"/font_selection.bin";
 

DesktopEditor/fontengine/ApplicationFontsWorker.h

@@ -36,7 +36,7 @@
 #include <vector>
 #include "../graphics/pro/Fonts.h"
 
-#define ONLYOFFICE_FONTS_VERSION     12
+#define ONLYOFFICE_FONTS_VERSION     14
 #define ONLYOFFICE_ALL_FONTS_VERSION 2
 
 class CApplicationFontsWorkerBreaker

DesktopEditor/fontengine/ApplicationFonts_mac.mm

@@ -29,39 +29,36 @@
  * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
  *
  */
-#pragma once
-#ifndef PPTX_PRESENTATION_SLDSZ_INCLUDE_H_
-#define PPTX_PRESENTATION_SLDSZ_INCLUDE_H_
+#include "ApplicationFonts.h"
+#include "../common/File.h"
+#import <Foundation/Foundation.h>
+#import <CoreText/CoreText.h>
 
-#include "./../WrapperWritingElement.h"
-#include "./../Limit/SlideSize.h"
-
-namespace PPTX
+std::set<std::wstring> CApplicationFonts::GetInstalledFontsMac()
 {
-	namespace nsPresentation
+	std::set<std::wstring> paths;
+
+	CFArrayRef fontURLs = CTFontManagerCopyAvailableFontURLs();
+	if (!fontURLs)
+		return paths;
+
+	NSStringEncoding encode = CFStringConvertEncodingToNSStringEncoding (kCFStringEncodingUTF32LE);
+
+	CFIndex count = CFArrayGetCount(fontURLs);
+	for (CFIndex i = 0; i < count; ++i)
 	{
-		class SldSz : public WrapperWritingElement
-		{
-		public:
-			PPTX_LOGIC_BASE(SldSz)
+		CFURLRef url = (CFURLRef)CFArrayGetValueAtIndex(fontURLs, i);
+		if (!url)
+			continue;
 
-		public:
-			virtual void fromXML(XmlUtils::CXmlNode& node);
-			virtual std::wstring toXML() const;
+		NSString* nsPath = [(__bridge NSURL *)url path];
+		if (!nsPath)
+			continue;
 
-			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const;
-			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const;
+		NSData* pSData = [nsPath dataUsingEncoding: encode];
+		paths.emplace(std::wstring((wchar_t*)[pSData bytes], [pSData length] / sizeof (wchar_t)));
+	}
 
-		public:
-			int cx;
-			int cy;
-			nullable_limit<Limit::SlideSize> type;
-
-		protected:
-			virtual void FillParentPointersForChilds();
-			void Normalize();
-		};
-	} // namespace nsPresentation
-} // namespace PPTX
-
-#endif // PPTX_PRESENTATION_SLDSZ_INCLUDE_H_
+	CFRelease(fontURLs);
+	return paths;
+}

DesktopEditor/fontengine/TextShaper.cpp

@@ -451,7 +451,7 @@ namespace NSShaper
 		CheckUnicodeFaceName(face, family_name, family_name_len);
 
 		unsigned int nLen1 = (unsigned int)family_name_len;
-		unsigned int nLen2 = (unsigned int)strlen(face->style_name);
+		unsigned int nLen2 = (unsigned int)((face->style_name != NULL) ? strlen(face->style_name) : 0);
 
 		unsigned int nLen = 28 + nLen1 + 1 + nLen2 + 1 + 1 + (int)face->num_fixed_sizes;
 
@@ -693,6 +693,13 @@ namespace NSShaper
 			g_userfeatures_init = true;
 		}
 
+		// Turn on ligatures on arabic script
+		if (nScript == HB_SCRIPT_ARABIC ||
+			nScript == HB_SCRIPT_SYRIAC)
+		{
+			nFeatures |= 1;
+		}
+
 		// font
 		hb_font_t* pFont;
 		if (NULL == font)

DesktopEditor/fontengine/TextShaper_p.h

@@ -94,11 +94,14 @@ void CheckUnicodeFaceName(FT_Face pFace, int*& UName, unsigned int& ULen)
 	bool isBadASCII = false;
 
 	unsigned int face_name_len = 0;
-	while ('\0' != face_name[face_name_len])
+	if (NULL != face_name)
 	{
-		if ('?' == face_name[face_name_len])
-			isBadASCII = true;
-		++face_name_len;
+		while ('\0' != face_name[face_name_len])
+		{
+			if ('?' == face_name[face_name_len])
+				isBadASCII = true;
+			++face_name_len;
+		}
 	}
 
 	if (face_name_len > 6 &&

DesktopEditor/fontengine/js/cpp/text.cpp

@@ -594,6 +594,13 @@ WASM_EXPORT unsigned char* ASC_HB_ShapeText(FT_Face pFace, hb_font_t* pFont, cha
 		g_userfeatures_init = true;
 	}
 
+	// Turn on ligatures on arabic script
+	if (nScript == HB_SCRIPT_ARABIC ||
+		nScript == HB_SCRIPT_SYRIAC)
+	{
+		nFeatures |= 1;
+	}
+
 	// font
 	if (NULL == pFont)
 	{

DesktopEditor/fontengine/js/libfont.json

@@ -83,6 +83,7 @@
 		"./../../graphics/pro/js/wasm/src/lib",
 
 		"./../../../Common/3dParty/harfbuzz/harfbuzz/src",
+		"./../../../Common/3dParty/brotli/brotli/c/include",
 		
 		"./../../../OfficeUtils/src",
 		"./../../../OfficeUtils/src/zlib-1.2.11",
@@ -113,6 +114,8 @@
 		"BUILD_ZLIB_AS_SOURCES",
 		"IMAGE_CHECKER_DISABLE_XML",
 
+		"FT_CONFIG_OPTION_USE_BROTLI",
+
 		"BUILDING_WASM_MODULE"
 	],
 	"compile_files_array": [
@@ -260,10 +263,13 @@
 		"folder": "../../../OfficeUtils/js",
 		"files": ["../src/ZipBuffer.cpp", "wasm/src/base.cpp", "../src/zlib_addon.c"]
 	},
-
 	{
 		"folder": "../../",
-		"files": ["graphics/Image.cpp", "raster/BgraFrame.cpp", "raster/ImageFileFormatChecker.cpp"]
+		"files": ["graphics/Image.cpp", "raster/BgraFrame.cpp", "raster/ImageFileFormatChecker.cpp", "graphics/Matrix.cpp"]
+	},
+	{
+		"folder": "../../agg-2.4/src/",
+		"files": ["agg_trans_affine.cpp"]
 	},
 	{
 		"folder": "../../raster/",
@@ -346,6 +352,26 @@
 	{
 		"folder": "./../../../Common/3dParty/hyphen/js/src",
 		"files": ["hyphen.cpp"]
+	},
+	{
+		"folder": "./../../../Common/3dParty/brotli/brotli/c/common",
+		"files": [
+			"constants.c",
+			"context.c",
+			"dictionary.c",
+			"platform.c",
+			"shared_dictionary.c",
+			"transform.c"
+		]
+	},
+	{
+		"folder": "./../../../Common/3dParty/brotli/brotli/c/dec",
+		"files": [
+			"bit_reader.c",
+			"decode.c",
+			"huffman.c",
+			"state.c"
+		]
 	}
 	]
 }