Add test for heif

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

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

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

@@ -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;
@@ -521,7 +530,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,26 @@ namespace NSCSS
 		return m_pInternal->GetDpi();
 	}
 
+	void CCssCalculator::ClearPageData()
+	{
+		m_pInternal->ClearPageData();
+	}
+
+	void CCssCalculator::ClearEmbeddedStyles()
+	{
+		m_pInternal->ClearEmbeddedStyles();
+	}
+
+	void CCssCalculator::ClearAllowedStyleFiles()
+	{
+		m_pInternal->ClearAllowedStyleFiles();
+	}
+
+	void CCssCalculator::ClearStylesFromFile(const std::wstring& wsFilePath)
+	{
+		m_pInternal->ClearStylesFromFile(wsFilePath);
+	}
+
 	void CCssCalculator::Clear()
 	{
 		m_pInternal->Clear();

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,10 @@ namespace NSCSS
 		std::wstring GetEncoding()   const;
 		unsigned short int GetDpi()  const;
 
+		void ClearPageData();
+		void ClearEmbeddedStyles();
+		void ClearAllowedStyleFiles();
+		void ClearStylesFromFile(const std::wstring& wsFilePath);
 		void Clear();
 	};
 }

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

@@ -2,15 +2,10 @@
 
 #include <string>
 #include <vector>
-#include <fstream>
-#include <cmath>
 #include <algorithm>
-#include <iostream>
 #include <numeric>
 
 #include "../../katana-parser/src/selector.h"
-#include "../../../../../UnicodeConverter/UnicodeConverter.h"
-#include "ConstValues.h"
 #include "../../../../../DesktopEditor/common/File.h"
 #include "StaticFunctions.h"
 
@@ -41,58 +36,120 @@ bool operator<(const std::vector<NSCSS::CNode> &arLeftSelectors, const std::vect
 
 namespace NSCSS
 {
-	CCssCalculator_Private::CCssCalculator_Private() : m_nDpi(96), m_nCountNodes(0), m_sEncoding(L"UTF-8"){}
+	CStyleStorage::CStyleStorage()
+	{}
 
-	CCssCalculator_Private::~CCssCalculator_Private()
+	CStyleStorage::~CStyleStorage()
 	{
-		m_arFiles.clear();
-
-		for (std::map<std::wstring, CElement*>::iterator oIter = m_mData.begin(); oIter != m_mData.end(); ++oIter)
-			if (oIter->second != NULL)
-				delete oIter->second;
-
-		m_mData.clear();
+		Clear();
 	}
 
-	inline void CCssCalculator_Private::GetOutputData(KatanaOutput *oOutput)
+	void CStyleStorage::Clear()
 	{
-		if ( NULL == oOutput )
-			return;
+		for (TStyleFileData* pStyleFileData : m_arStyleFiles)
+		{
+			if (nullptr == pStyleFileData)
+				continue;
 
-		switch (oOutput->mode) {
-			case KatanaParserModeStylesheet:
-				GetStylesheet(oOutput->stylesheet);
-				break;
-			case KatanaParserModeRule:
-				GetRule(oOutput->rule);
-				break;
-			case KatanaParserModeKeyframeRule:
-			case KatanaParserModeKeyframeKeyList:
-			case KatanaParserModeMediaList:
-			case KatanaParserModeValue:
-			case KatanaParserModeSelector:
-			case KatanaParserModeDeclarationList:
-				break;
+			for (std::map<std::wstring, CElement*>::iterator oIter = pStyleFileData->m_mStyleData.begin(); oIter != pStyleFileData->m_mStyleData.end(); ++oIter)
+				if (oIter->second != nullptr)
+					delete oIter->second;
+
+			delete pStyleFileData;
 		}
 
+		m_arStyleFiles.clear();
+		m_arEmptyStyleFiles.clear();
+
+		ClearEmbeddedStyles();
+		ClearAllowedStyleFiles();
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		ClearPageData();
+		#endif
+	}
+
+	void CStyleStorage::AddStyles(const std::string& sStyle)
+	{
+		if (sStyle.empty())
+			return;
+
+		KatanaOutput *output = katana_parse(sStyle.c_str(), sStyle.length(), KatanaParserModeStylesheet);
+		this->GetOutputData(output, m_mEmbeddedStyleData);
+		katana_destroy_output(output);
+	}
+
+	void CStyleStorage::AddStyles(const std::wstring& wsStyle)
+	{
+		if (wsStyle.empty())
+			return;
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		std::wregex oRegex(L"@page\\s*([^{]*)(\\{[^}]*\\})");
+		std::wsmatch oMatch;
+		std::wstring::const_iterator oSearchStart(wsStyle.cbegin());
+
+		while (std::regex_search(oSearchStart, wsStyle.cend(), oMatch, oRegex))
+		{
+			AddPageData(oMatch[1].str(), oMatch[2].str());
+			oSearchStart = oMatch.suffix().first;
+		}
+		#endif
+
+		AddStyles(U_TO_UTF8(wsStyle));
+	}
+
+	void CStyleStorage::AddStylesFromFile(const std::wstring& wsFileName)
+	{
+		std::set<std::wstring>::const_iterator itEmptyFileFound = m_arEmptyStyleFiles.find(wsFileName);
+
+		if (m_arEmptyStyleFiles.cend() != itEmptyFileFound)
+			return;
+
+		std::vector<TStyleFileData*>::const_iterator itFound = std::find_if(m_arStyleFiles.cbegin(), m_arStyleFiles.cend(),
+		                                                                    [wsFileName](const TStyleFileData* pStyleFileData)
+		                                                                    { return wsFileName == pStyleFileData->m_wsStyleFilepath; });
+
+		m_arAllowedStyleFiles.insert(wsFileName);
+
+		if (m_arStyleFiles.cend() != itFound)
+			return;
+
+		TStyleFileData *pStyleFileData = new TStyleFileData();
+
+		pStyleFileData->m_wsStyleFilepath = wsFileName;
+
+		AddStyles(NS_STATIC_FUNCTIONS::GetContentAsUTF8(wsFileName), pStyleFileData->m_mStyleData);
+
+		if (!pStyleFileData->m_mStyleData.empty())
+			m_arStyleFiles.push_back(pStyleFileData);
+		else
+		{
+			m_arEmptyStyleFiles.insert(wsFileName);
+			delete pStyleFileData;
+		}
+	}
+
+	void CStyleStorage::ClearStylesFromFile(const std::wstring& wsFileName)
+	{
+		std::vector<TStyleFileData*>::const_iterator itFound = std::find_if(m_arStyleFiles.cbegin(), m_arStyleFiles.cend(),
+																			[wsFileName](const TStyleFileData* pStyleFileData)
+																			{ return wsFileName == pStyleFileData->m_wsStyleFilepath; });
+
+		if (m_arStyleFiles.cend() != itFound)
+		{
+			m_arStyleFiles.erase(itFound);
+			delete *itFound;
+		}
 	}
 
 	#ifdef CSS_CALCULATOR_WITH_XHTML
-	std::map<std::wstring, std::wstring> CCssCalculator_Private::GetPageData(const std::wstring &wsPageName)
+	void CStyleStorage::AddPageData(const std::wstring& wsPageName, const std::wstring& wsStyles)
 	{
-		if (m_arPageDatas.empty())
-			return {};
-
-		for (const TPageData& oPageData : m_arPageDatas)
-		{
-			if (std::find(oPageData.m_wsNames.begin(), oPageData.m_wsNames.end(), wsPageName) != oPageData.m_wsNames.end())
-				return oPageData.m_mData;
-		}
-
-		return {};
+		m_arPageDatas.push_back({NS_STATIC_FUNCTIONS::GetWordsW(wsPageName), NS_STATIC_FUNCTIONS::GetRules(wsStyles)});
 	}
-	
-	void CCssCalculator_Private::SetPageData(NSProperties::CPage &oPage, const std::map<std::wstring, std::wstring> &mData, unsigned int unLevel, bool bHardMode)
+
+	void CStyleStorage::SetPageData(NSProperties::CPage& oPage, const std::map<std::wstring, std::wstring>& mData, unsigned int unLevel, bool bHardMode)
 	{
 		for (const std::pair<std::wstring, std::wstring> &oData : mData)
 		{
@@ -107,149 +164,84 @@ namespace NSCSS
 		}
 	}
 
-	std::vector<std::wstring> CCssCalculator_Private::CalculateAllNodes(const std::vector<CNode> &arSelectors)
+	std::map<std::wstring, std::wstring> CStyleStorage::GetPageData(const std::wstring& wsPageName)
 	{
-		std::vector<std::wstring> arNodes;
-		
-		for (std::vector<CNode>::const_reverse_iterator oNode = arSelectors.rbegin(); oNode != arSelectors.rend(); ++oNode)
-		{
-			if (!oNode->m_wsName.empty())
-				arNodes.push_back(oNode->m_wsName);
-
-			if (!oNode->m_wsClass.empty())
-			{
-				if (oNode->m_wsClass.find(L' ') != std::wstring::npos)
-				{
-					std::vector<std::wstring> arClasses = NS_STATIC_FUNCTIONS::GetWordsW(oNode->m_wsClass, false, L" ");
-
-					arNodes.push_back(std::accumulate(arClasses.begin(), arClasses.end(), std::wstring(),
-													  [](std::wstring sRes, const std::wstring& sClass)
-														{return sRes += L'.' + sClass + L' ';}));
-				}
-				else
-					arNodes.push_back(L'.' + oNode->m_wsClass);
-			}
-
-			if (!oNode->m_wsId.empty())
-				arNodes.push_back(L'#' + oNode->m_wsId);
-		}
-
-		return arNodes;
-	}
-
-	void CCssCalculator_Private::FindPrevAndKindElements(const CElement *pElement, const std::vector<std::wstring> &arNextNodes, std::vector<CElement*>& arFindedElements, const std::wstring &wsName, const std::vector<std::wstring> &arClasses)
-	{
-		if (arNextNodes.empty())
-			return;
-
-		const std::vector<CElement*> arTempPrev = pElement->GetPrevElements(arNextNodes.crbegin() + 1, arNextNodes.crend());
-		const std::vector<CElement*> arTempKins = pElement->GetNextOfKin(wsName, arClasses);
-
-		if (!arTempPrev.empty())
-			arFindedElements.insert(arFindedElements.end(), arTempPrev.begin(), arTempPrev.end());
-
-		if (!arTempKins.empty())
-			arFindedElements.insert(arFindedElements.end(), arTempKins.begin(), arTempKins.end());
-	}
-
-	std::vector<CElement*> CCssCalculator_Private::FindElements(std::vector<std::wstring> &arNodes, std::vector<std::wstring> &arNextNodes)
-	{
-		if (arNodes.empty())
+		if (m_arPageDatas.empty())
 			return {};
 
-		std::vector<CElement*> arFindedElements;
-
-		std::wstring wsName, wsId;
-		std::vector<std::wstring> arClasses;
-
-		if (!arNodes.empty() && arNodes.back()[0] == L'#')
+		for (const TPageData& oPageData : m_arPageDatas)
 		{
-			wsId = arNodes.back();
-			arNodes.pop_back();
-			arNextNodes.push_back(wsId);
+			if (std::find(oPageData.m_wsNames.begin(), oPageData.m_wsNames.end(), wsPageName) != oPageData.m_wsNames.end())
+				return oPageData.m_mData;
 		}
 
-		if (!arNodes.empty() && arNodes.back()[0] == L'.')
-		{
-			arClasses = NS_STATIC_FUNCTIONS::GetWordsW(arNodes.back(), false, L" ");
-			arNextNodes.push_back(arNodes.back());
-			arNodes.pop_back();
-		}
+		return {};
+	}
 
-		if (!arNodes.empty())
-		{
-			wsName = arNodes.back();
-			arNodes.pop_back();
-			arNextNodes.push_back(wsName);
-		}
-
-		const std::map<std::wstring, CElement*>::const_iterator oFindName = m_mData.find(wsName);
-		std::map<std::wstring, CElement*>::const_iterator oFindId;
-
-		if (!wsId.empty())
-		{
-			oFindId = m_mData.find(wsId);
-
-			if (m_mData.cend() != oFindId)
-			{
-				if (!oFindId->second->Empty())
-					arFindedElements.push_back(oFindId->second);
-
-				FindPrevAndKindElements(oFindId->second, arNextNodes, arFindedElements, wsName);
-			}
-		}
-
-		if (!arClasses.empty())
-		{
-			for (std::vector<std::wstring>::const_reverse_iterator iClass = arClasses.rbegin(); iClass != arClasses.rend(); ++iClass)
-			{
-				const std::map<std::wstring, CElement*>::const_iterator oFindClass = m_mData.find(*iClass);
-				if (oFindClass != m_mData.cend())
-				{
-					if (!oFindClass->second->Empty())
-						arFindedElements.push_back(oFindClass->second);
-
-					FindPrevAndKindElements(oFindClass->second, arNextNodes, arFindedElements, wsName);
-				}
-			}
-		}
-
-		if (oFindName != m_mData.cend())
-		{
-			if (!oFindName->second->Empty())
-				arFindedElements.push_back(oFindName->second);
-
-			FindPrevAndKindElements(oFindName->second, arNextNodes, arFindedElements, wsName, arClasses);
-		}
-
-		if (arFindedElements.size() > 1)
-		{
-			std::sort(arFindedElements.rbegin(), arFindedElements.rend(),
-			          [](CElement* oFirstElement, CElement* oSecondElement)
-			          {
-			        	  return oFirstElement->GetWeight() > oSecondElement->GetWeight();
-			          });
-		}
-
-		return arFindedElements;
+	void CStyleStorage::ClearPageData()
+	{
+		m_arPageDatas.clear();
 	}
 	#endif
 
-	void CCssCalculator_Private::AddPageData(const std::wstring &wsPageNames, const std::wstring &wsStyles)
+	const CElement* CStyleStorage::FindElement(const std::wstring& wsSelector)
 	{
-		m_arPageDatas.push_back({NS_STATIC_FUNCTIONS::GetWordsW(wsPageNames), NS_STATIC_FUNCTIONS::GetRules(wsStyles)});
+		if (wsSelector.empty())
+			return nullptr;
+
+		const CElement* pFoundElement = FindSelectorFromStyleData(wsSelector, m_mEmbeddedStyleData);
+
+		if (nullptr != pFoundElement)
+			return pFoundElement;
+
+		for (std::vector<TStyleFileData*>::const_reverse_iterator itIter = m_arStyleFiles.crbegin(); itIter < m_arStyleFiles.crend(); ++itIter)
+		{
+			if (m_arAllowedStyleFiles.cend() == std::find(m_arAllowedStyleFiles.cbegin(), m_arAllowedStyleFiles.cend(), (*itIter)->m_wsStyleFilepath))
+				continue;
+
+			pFoundElement = FindSelectorFromStyleData(wsSelector, (*itIter)->m_mStyleData);
+
+			if (nullptr != pFoundElement)
+				return pFoundElement;
+		}
+
+		return nullptr;
 	}
-	
-	inline void CCssCalculator_Private::GetStylesheet(const KatanaStylesheet *oStylesheet)
+
+	void CStyleStorage::AddStyles(const std::string& sStyle, std::map<std::wstring, CElement*>& mStyleData)
+	{
+		if (sStyle.empty())
+			return;
+
+		KatanaOutput *output = katana_parse(sStyle.c_str(), sStyle.length(), KatanaParserModeStylesheet);
+		this->GetOutputData(output, mStyleData);
+		katana_destroy_output(output);
+	}
+
+	void CStyleStorage::ClearEmbeddedStyles()
+	{
+		for (std::map<std::wstring, CElement*>::iterator oIter = m_mEmbeddedStyleData.begin(); oIter != m_mEmbeddedStyleData.end(); ++oIter)
+			if (oIter->second != nullptr)
+				delete oIter->second;
+
+		m_mEmbeddedStyleData.clear();
+	}
+
+	void CStyleStorage::ClearAllowedStyleFiles()
+	{
+		m_arAllowedStyleFiles.clear();
+	}
+
+	void CStyleStorage::GetStylesheet(const KatanaStylesheet* oStylesheet, std::map<std::wstring, CElement*>& mStyleData)
 	{
 		for (size_t i = 0; i < oStylesheet->imports.length; ++i)
-			GetRule((KatanaRule*)oStylesheet->imports.data[i]);
+			GetRule((KatanaRule*)oStylesheet->imports.data[i], mStyleData);
 
 		for (size_t i = 0; i < oStylesheet->rules.length; ++i)
-			GetRule((KatanaRule*)oStylesheet->rules.data[i]);
+			GetRule((KatanaRule*)oStylesheet->rules.data[i], mStyleData);
 	}
 
-	inline void CCssCalculator_Private::GetRule(const KatanaRule *oRule)
+	void CStyleStorage::GetRule(const KatanaRule* oRule, std::map<std::wstring, CElement*>& mStyleData)
 	{
 		if ( NULL == oRule )
 			return;
@@ -257,7 +249,7 @@ namespace NSCSS
 		switch (oRule->type) {
 			case KatanaRuleStyle:
 			{
-				GetStyleRule((KatanaStyleRule*)oRule);
+				GetStyleRule((KatanaStyleRule*)oRule, mStyleData);
 				break;
 			}
 			default:
@@ -265,7 +257,7 @@ namespace NSCSS
 		}
 	}
 
-	inline void CCssCalculator_Private::GetStyleRule(const KatanaStyleRule *oRule)
+	void CStyleStorage::GetStyleRule(const KatanaStyleRule* oRule, std::map<std::wstring, CElement*>& mStyleData)
 	{
 		if (oRule->declarations->length == 0)
 			return;
@@ -281,7 +273,7 @@ namespace NSCSS
 
 			for (std::vector<std::wstring>::reverse_iterator oWord = arWords.rbegin(); oWord != arWords.rend(); ++oWord)
 			{
-				    const size_t posPoint = oWord->find(L'.');
+					const size_t posPoint = oWord->find(L'.');
 					const size_t posLattice = oWord->find(L'#');
 
 					const std::wstring sName = (posPoint != std::wstring::npos) ? oWord->substr(0, posPoint) : (posLattice != std::wstring::npos) ? oWord->substr(0, posLattice) : *oWord;
@@ -297,8 +289,8 @@ namespace NSCSS
 					{
 						if (NULL == oFirstElement && bCreateFirst)
 						{
-							const std::map<std::wstring, CElement*>::const_iterator& oFindId = m_mData.find(sId);
-							if (oFindId != m_mData.end())
+							const std::map<std::wstring, CElement*>::const_iterator& oFindId = mStyleData.find(sId);
+							if (oFindId != mStyleData.end())
 							{
 								oIdElement = oFindId->second;
 								bCreateFirst = false;
@@ -326,8 +318,8 @@ namespace NSCSS
 					{
 						if (NULL == oFirstElement && bCreateFirst)
 						{
-							const std::map<std::wstring, CElement*>::const_iterator& oFindClass = m_mData.find(sClass);
-							if (oFindClass != m_mData.end())
+							const std::map<std::wstring, CElement*>::const_iterator& oFindClass = mStyleData.find(sClass);
+							if (oFindClass != mStyleData.end())
 							{
 								oClassElement = oFindClass->second;
 								bCreateFirst = false;
@@ -359,8 +351,8 @@ namespace NSCSS
 					{
 						if (NULL == oFirstElement && bCreateFirst)
 						{
-							const std::map<std::wstring, CElement*>::const_iterator& oFindName = m_mData.find(sName);
-							if (oFindName != m_mData.end())
+							const std::map<std::wstring, CElement*>::const_iterator& oFindName = mStyleData.find(sName);
+							if (oFindName != mStyleData.end())
 							{
 								oNameElement = oFindName->second;
 								bCreateFirst = false;
@@ -392,11 +384,16 @@ namespace NSCSS
 				oLastElement->AddProperties(mStyle);
 
 			if (NULL != oFirstElement)
-				m_mData[oFirstElement->GetSelector()] = oFirstElement;
+				mStyleData[oFirstElement->GetSelector()] = oFirstElement;
 		}
 	}
 
-	inline std::vector<std::wstring> CCssCalculator_Private::GetSelectorList(const KatanaArray* oSelectors) const
+	std::wstring CStyleStorage::GetValueList(const KatanaArray* oValues)
+	{
+		return StringifyValueList(oValues);
+	}
+
+	std::vector<std::wstring> CStyleStorage::GetSelectorList(const KatanaArray* oSelectors) const
 	{
 		if (oSelectors->length == 0)
 			return std::vector<std::wstring>();
@@ -409,7 +406,7 @@ namespace NSCSS
 		return arSelectors;
 	}
 
-	inline std::wstring CCssCalculator_Private::GetSelector(const KatanaSelector *oSelector) const
+	std::wstring CStyleStorage::GetSelector(const KatanaSelector* oSelector) const
 	{
 		KatanaParser oParser;
 		oParser.options = &kKatanaDefaultOptions;
@@ -428,7 +425,7 @@ namespace NSCSS
 		return wsText;
 	}
 
-	inline std::map<std::wstring, std::wstring> CCssCalculator_Private::GetDeclarationList(const KatanaArray* oDeclarations) const
+	std::map<std::wstring, std::wstring> CStyleStorage::GetDeclarationList(const KatanaArray* oDeclarations) const
 	{
 		if(oDeclarations->length == 0)
 			return std::map<std::wstring, std::wstring>();
@@ -441,7 +438,7 @@ namespace NSCSS
 		return arDeclarations;
 	}
 
-	inline std::pair<std::wstring, std::wstring> CCssCalculator_Private::GetDeclaration(const KatanaDeclaration* oDecl) const
+	std::pair<std::wstring, std::wstring> CStyleStorage::GetDeclaration(const KatanaDeclaration* oDecl) const
 	{
 		std::wstring sValueList = StringifyValueList(oDecl->values);
 
@@ -451,25 +448,45 @@ namespace NSCSS
 		return std::make_pair(UTF8_TO_U(std::string(oDecl->property)), sValueList);
 	}
 
-	inline std::wstring CCssCalculator_Private::GetValueList(const KatanaArray *oValues)
+	void CStyleStorage::GetOutputData(KatanaOutput* oOutput, std::map<std::wstring, CElement*>& mStyleData)
 	{
-		return StringifyValueList(oValues);
+		if ( NULL == oOutput )
+			return;
+
+		switch (oOutput->mode) {
+			case KatanaParserModeStylesheet:
+				GetStylesheet(oOutput->stylesheet, mStyleData);
+				break;
+			case KatanaParserModeRule:
+				GetRule(oOutput->rule, mStyleData);
+				break;
+			case KatanaParserModeKeyframeRule:
+			case KatanaParserModeKeyframeKeyList:
+			case KatanaParserModeMediaList:
+			case KatanaParserModeValue:
+			case KatanaParserModeSelector:
+			case KatanaParserModeDeclarationList:
+				break;
+		}
 	}
 
+	const CElement* CStyleStorage::FindSelectorFromStyleData(const std::wstring& wsSelector, const std::map<std::wstring, CElement*>& mStyleData)
+	{
+		std::map<std::wstring, CElement*>::const_iterator itFound = mStyleData.find(wsSelector);
+
+		if (mStyleData.cend() != itFound)
+			return itFound->second;
+
+		return nullptr;
+	}
+
+	CCssCalculator_Private::CCssCalculator_Private() : m_nDpi(96), m_nCountNodes(0), m_sEncoding(L"UTF-8"){}
+
+	CCssCalculator_Private::~CCssCalculator_Private()
+	{}
+
 	#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)
+	bool CCssCalculator_Private::CalculateCompiledStyle(std::vector<CNode>& arSelectors)
 	{
 		if (arSelectors.empty())
 			return false;
@@ -478,58 +495,214 @@ namespace NSCSS
 
 		if (oItem != m_mUsedStyles.end())
 		{
-			oStyle = oItem->second;
+			arSelectors.back().SetCompiledStyle(new CCompiledStyle(oItem->second));
 			return true;
 		}
 
-		oStyle.SetDpi(m_nDpi);
+		arSelectors.back().m_pCompiledStyle->SetDpi(m_nDpi);
+		unsigned int unStart = 0;
 
-		std::vector<std::wstring> arNodes = CalculateAllNodes(arSelectors);
+		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 < arSelectors.size(); ++i)
+
+		for (size_t i = 0; i < unStart; ++i)
 		{
-			oStyle.AddParent(arSelectors[i].m_wsName);
+			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)
 			{
-				oStyle.m_oBackground.Clear();
-				oStyle.m_oBorder.Clear();
+				arSelectors[i].m_pCompiledStyle->m_oBackground.Clear();
+				arSelectors[i].m_pCompiledStyle->m_oBorder.Clear();
 			}
 
-			CCompiledStyle oTempStyle;
-
-			oTempStyle.AddStyle(arSelectors[i].m_mAttributes, i + 1);
+			arSelectors[i].m_pCompiledStyle->AddStyle(arSelectors[i].m_mAttributes, i + 1);
 
 			for (const CElement* oElement : FindElements(arNodes, arPrevNodes))
-				oTempStyle.AddStyle(oElement->GetStyle(), i + 1);
+				arSelectors[i].m_pCompiledStyle->AddStyle(oElement->GetStyle(), i + 1);
 
 			if (!arSelectors[i].m_wsStyle.empty())
-				oTempStyle.AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
-
-			oStyle += oTempStyle;
+				arSelectors[i].m_pCompiledStyle->AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
 
 			// Скидываем некоторые внешние стили, которые внутри таблицы переопределяются
 			if (bInTable && i < arSelectors.size() - 1)
 			{
-				oStyle.m_oFont.GetLineHeight().Clear();
-				oStyle.m_oPadding.Clear();
-				oStyle.m_oMargin.Clear();
+				arSelectors[i].m_pCompiledStyle->m_oFont.GetLineHeight().Clear();
+				arSelectors[i].m_pCompiledStyle->m_oPadding.Clear();
+				arSelectors[i].m_pCompiledStyle->m_oMargin.Clear();
 			}
 		}
 
-		oStyle.SetID(CalculateStyleId(arSelectors.back()));
+		arSelectors.back().m_pCompiledStyle->SetID(CalculateStyleId(arSelectors.back()));
 
-		if (!oStyle.Empty())
-			m_mUsedStyles[arSelectors] = oStyle;
+		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:: пересмотреть данный метод
+		m_oStyleStorage.SetPageData(oPage, mData, unLevel, bHardMode);
+	}
+
+	std::map<std::wstring, std::wstring> CCssCalculator_Private::GetPageData(const std::wstring &wsPageName)
+	{
+		return m_oStyleStorage.GetPageData(wsPageName);
+	}
+
+	void CCssCalculator_Private::ClearPageData()
+	{
+		m_oStyleStorage.ClearPageData();
+	}
+	#endif
+
+	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() - unStart; ++oNode)
+		{
+			if (!oNode->m_wsName.empty())
+				arNodes.push_back(oNode->m_wsName);
+
+			if (!oNode->m_wsClass.empty())
+			{
+				if (oNode->m_wsClass.find(L' ') != std::wstring::npos)
+				{
+					std::vector<std::wstring> arClasses = NS_STATIC_FUNCTIONS::GetWordsW(oNode->m_wsClass, false, L" ");
+
+					arNodes.push_back(std::accumulate(arClasses.begin(), arClasses.end(), std::wstring(),
+													  [](std::wstring sRes, const std::wstring& sClass)
+														{return sRes += L'.' + sClass + L' ';}));
+				}
+				else
+					arNodes.push_back(L'.' + oNode->m_wsClass);
+			}
+
+			if (!oNode->m_wsId.empty())
+				arNodes.push_back(L'#' + oNode->m_wsId);
+		}
+
+		return arNodes;
+	}
+
+	void CCssCalculator_Private::FindPrevAndKindElements(const CElement *pElement, const std::vector<std::wstring> &arNextNodes, std::vector<const CElement*>& arFindedElements, const std::wstring &wsName, const std::vector<std::wstring> &arClasses)
+	{
+		if (arNextNodes.empty())
+			return;
+
+		const std::vector<CElement*> arTempPrev = pElement->GetPrevElements(arNextNodes.crbegin() + 1, arNextNodes.crend());
+		const std::vector<CElement*> arTempKins = pElement->GetNextOfKin(wsName, arClasses);
+
+		if (!arTempPrev.empty())
+			arFindedElements.insert(arFindedElements.end(), arTempPrev.begin(), arTempPrev.end());
+
+		if (!arTempKins.empty())
+			arFindedElements.insert(arFindedElements.end(), arTempKins.begin(), arTempKins.end());
+	}
+
+	std::vector<const CElement*> CCssCalculator_Private::FindElements(std::vector<std::wstring> &arNodes, std::vector<std::wstring> &arNextNodes)
+	{
+		if (arNodes.empty())
+			return {};
+
+		std::vector<const CElement*> arFindedElements;
+
+		std::wstring wsName, wsId;
+		std::vector<std::wstring> arClasses;
+
+		if (!arNodes.empty() && arNodes.back()[0] == L'#')
+		{
+			wsId = arNodes.back();
+			arNodes.pop_back();
+			arNextNodes.push_back(wsId);
+		}
+
+		if (!arNodes.empty() && arNodes.back()[0] == L'.')
+		{
+			arClasses = NS_STATIC_FUNCTIONS::GetWordsW(arNodes.back(), false, L" ");
+			arNextNodes.push_back(arNodes.back());
+			arNodes.pop_back();
+		}
+
+		if (!arNodes.empty())
+		{
+			wsName = arNodes.back();
+			arNodes.pop_back();
+			arNextNodes.push_back(wsName);
+		}
+
+		if (!wsId.empty())
+		{
+			const CElement* pFoundId = m_oStyleStorage.FindElement(wsId);
+
+			if(nullptr != pFoundId)
+			{
+				if (!pFoundId->Empty())
+					arFindedElements.push_back(pFoundId);
+
+				FindPrevAndKindElements(pFoundId, arNextNodes, arFindedElements, wsName);
+			}
+		}
+
+		if (!arClasses.empty())
+		{
+			for (std::vector<std::wstring>::const_reverse_iterator iClass = arClasses.rbegin(); iClass != arClasses.rend(); ++iClass)
+			{
+				const CElement* pFoundClass = m_oStyleStorage.FindElement(*iClass);
+
+				if (nullptr != pFoundClass)
+				{
+					if (!pFoundClass->Empty())
+						arFindedElements.push_back(pFoundClass);
+
+					FindPrevAndKindElements(pFoundClass, arNextNodes, arFindedElements, wsName);
+				}
+			}
+		}
+
+		const CElement* pFoundName = m_oStyleStorage.FindElement(wsName);
+
+		if (nullptr != pFoundName)
+		{
+			if (!pFoundName->Empty())
+				arFindedElements.push_back(pFoundName);
+
+			FindPrevAndKindElements(pFoundName, arNextNodes, arFindedElements, wsName, arClasses);
+		}
+
+		if (arFindedElements.size() > 1)
+		{
+			std::sort(arFindedElements.rbegin(), arFindedElements.rend(),
+			          [](const CElement* oFirstElement, const CElement* oSecondElement)
+			          { return oFirstElement->GetWeight() > oSecondElement->GetWeight(); });
+		}
+
+		return arFindedElements;
+	}
+
+	#ifdef CSS_CALCULATOR_WITH_XHTML
 	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);
@@ -566,42 +739,20 @@ namespace NSCSS
 		return true;
 	}
 	#endif
-	void CCssCalculator_Private::AddStyles(const std::string &sStyle)
-	{
-		if (sStyle.empty())
-			return;
 
-		KatanaOutput *output = katana_parse(sStyle.c_str(), sStyle.length(), KatanaParserModeStylesheet);
-		this->GetOutputData(output);
-		katana_destroy_output(output);
+	void CCssCalculator_Private::AddStyles(const std::string& sStyle)
+	{
+		m_oStyleStorage.AddStyles(sStyle);
 	}
 
-	void CCssCalculator_Private::AddStyles(const std::wstring &wsStyle)
+	void CCssCalculator_Private::AddStyles(const std::wstring& wsStyle)
 	{
-		if (wsStyle.empty())
-			return;
-
-		std::wregex oRegex(L"@page\\s*([^{]*)(\\{[^}]*\\})");
-		std::wsmatch oMatch;
-		std::wstring::const_iterator oSearchStart(wsStyle.cbegin());
-		
-		while (std::regex_search(oSearchStart, wsStyle.cend(), oMatch, oRegex))
-		{
-			AddPageData(oMatch[1].str(), oMatch[2].str());
-			oSearchStart = oMatch.suffix().first;
-		}
-
-		AddStyles(U_TO_UTF8(wsStyle));
+		m_oStyleStorage.AddStyles(wsStyle);
 	}
 
 	void CCssCalculator_Private::AddStylesFromFile(const std::wstring& wsFileName)
 	{
-		if (std::find(m_arFiles.begin(), m_arFiles.end(), wsFileName) != m_arFiles.end())
-			return;
-
-		m_arFiles.push_back(wsFileName);
-
-		AddStyles(NS_STATIC_FUNCTIONS::GetContentAsUTF8(wsFileName));
+		m_oStyleStorage.AddStylesFromFile(wsFileName);
 	}
 
 	void CCssCalculator_Private::SetDpi(unsigned short int nValue)
@@ -614,9 +765,23 @@ namespace NSCSS
 		return m_nDpi;
 	}
 
-	const std::map<std::wstring, CElement *> *CCssCalculator_Private::GetData() const
+	void CCssCalculator_Private::ClearEmbeddedStyles()
 	{
-		return &m_mData;
+		m_oStyleStorage.ClearEmbeddedStyles();
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		m_mUsedStyles.clear();
+		#endif
+	}
+
+	void CCssCalculator_Private::ClearAllowedStyleFiles()
+	{
+		m_oStyleStorage.ClearAllowedStyleFiles();
+	}
+
+	void CCssCalculator_Private::ClearStylesFromFile(const std::wstring& wsFilePath)
+	{
+		m_oStyleStorage.ClearStylesFromFile(wsFilePath);
 	}
 
 	std::wstring CCssCalculator_Private::GetEncoding() const
@@ -629,10 +794,21 @@ namespace NSCSS
 		m_sEncoding     = L"UTF-8";
 		m_nDpi          = 96;
 
-		m_mData.clear();
-		m_arFiles.clear();
+		m_oStyleStorage.Clear();
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		m_mUsedStyles.clear();
+		#endif
+	}
+
+	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;
 	}
 }
+
 inline static std::wstring StringifyValueList(const KatanaArray* oValues)
 {
 	if (NULL == oValues)
@@ -735,7 +911,7 @@ inline static std::wstring StringifyValue(const KatanaValue* oValue)
 
 inline static bool IsTableElement(const std::wstring& wsNameTag)
 {
-	return  L"td" == wsNameTag || L"tr" == wsNameTag || L"table" == 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

@@ -3,11 +3,9 @@
 
 #include <vector>
 #include <map>
-#include <list>
-#include <functional>
+#include <set>
 #include "CElement.h"
-#include "ConstValues.h"
-#include "CUnitMeasureConverter.h"
+#include "StyleProperties.h"
 #include "../../katana-parser/src/katana.h"
 
 #ifdef CSS_CALCULATOR_WITH_XHTML
@@ -16,15 +14,43 @@
 
 namespace NSCSS
 {
-	class CCssCalculator_Private
+	class CStyleStorage
 	{
-		unsigned short int m_nDpi;
-		unsigned short int m_nCountNodes;
+	public:
+		CStyleStorage();
+		~CStyleStorage();
 
-		std::list<std::wstring> m_arFiles;
+		void Clear();
 
-		std::map<std::wstring, CElement*> m_mData;
+		void AddStyles(const std::string& sStyle);
+		void AddStyles(const std::wstring& wsStyle);
+		void AddStylesFromFile(const std::wstring& wsFileName);
 
+		void ClearEmbeddedStyles();
+		void ClearAllowedStyleFiles();
+		void ClearStylesFromFile(const std::wstring& wsFileName);
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		void AddPageData(const std::wstring& wsPageName, const std::wstring& wsStyles);
+		void SetPageData(NSProperties::CPage& oPage, const std::map<std::wstring, std::wstring>& mData, unsigned int unLevel, bool bHardMode = false);
+		std::map<std::wstring, std::wstring> GetPageData(const std::wstring& wsPageName);
+		void ClearPageData();
+		#endif
+
+		const CElement* FindElement(const std::wstring& wsSelector);
+	private:
+		typedef struct
+		{
+			std::wstring m_wsStyleFilepath;
+			std::map<std::wstring, CElement*> m_mStyleData;
+		} TStyleFileData;
+
+		std::set<std::wstring> m_arEmptyStyleFiles;
+		std::set<std::wstring> m_arAllowedStyleFiles;
+		std::vector<TStyleFileData*> m_arStyleFiles;
+		std::map<std::wstring, CElement*> m_mEmbeddedStyleData;
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
 		typedef struct
 		{
 			std::vector<std::wstring>            m_wsNames;
@@ -32,27 +58,14 @@ namespace NSCSS
 		} TPageData;
 
 		std::vector<TPageData> m_arPageDatas;
-
-		#ifdef CSS_CALCULATOR_WITH_XHTML
-		std::map<std::vector<CNode>, CCompiledStyle> m_mUsedStyles;
-		
-		std::map<std::wstring, std::wstring> GetPageData(const std::wstring& wsPageName);
-		void SetPageData(NSProperties::CPage& oPage, const std::map<std::wstring, std::wstring>& mData, unsigned int unLevel, bool bHardMode = false);
-
-		std::vector<std::wstring> CalculateAllNodes(const std::vector<CNode>& arSelectors);
-
-		void FindPrevAndKindElements(const CElement* pElement, const std::vector<std::wstring>& arNextNodes, std::vector<CElement*>& arFindedElements, const std::wstring& wsName, const std::vector<std::wstring>& arClasses = {});
-		std::vector<CElement*> FindElements(std::vector<std::wstring>& arNodes, std::vector<std::wstring>& arNextNodes);
 		#endif
+	private:
+		void AddStyles(const std::string& sStyle, std::map<std::wstring, CElement*>& mStyleData);
 
-		std::wstring m_sEncoding;
+		void GetStylesheet(const KatanaStylesheet* oStylesheet, std::map<std::wstring, CElement*>& mStyleData);
+		void GetRule(const KatanaRule* oRule, std::map<std::wstring, CElement*>& mStyleData);
 
-		void AddPageData(const std::wstring& wsPageName, const std::wstring& wsStyles);
-
-		void GetStylesheet(const KatanaStylesheet* oStylesheet);
-		void GetRule(const KatanaRule* oRule);
-
-		void GetStyleRule(const KatanaStyleRule* oRule);
+		void GetStyleRule(const KatanaStyleRule* oRule, std::map<std::wstring, CElement*>& mStyleData);
 
 		std::wstring GetValueList(const KatanaArray* oValues);
 
@@ -62,20 +75,44 @@ namespace NSCSS
 		std::map<std::wstring, std::wstring> GetDeclarationList(const KatanaArray* oDeclarations) const;
 		std::pair<std::wstring, std::wstring> GetDeclaration(const KatanaDeclaration* oDecl) const;
 
-		void GetOutputData(KatanaOutput* oOutput);
+		void GetOutputData(KatanaOutput* oOutput, std::map<std::wstring, CElement*>& mStyleData);
 
+		const CElement* FindSelectorFromStyleData(const std::wstring& wsSelector, const std::map<std::wstring, CElement*>& mStyleData);
+	};
+
+	class CCssCalculator_Private
+	{
+		unsigned short int m_nDpi;
+		unsigned short int m_nCountNodes;
+
+		CStyleStorage m_oStyleStorage;
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		std::map<std::vector<CNode>, CCompiledStyle> m_mUsedStyles;
+
+		void SetPageData(NSProperties::CPage& oPage, const std::map<std::wstring, std::wstring>& mData, unsigned int unLevel, bool bHardMode = false);
+		std::map<std::wstring, std::wstring> GetPageData(const std::wstring &wsPageName);
+		#endif
+
+		void FindPrevAndKindElements(const CElement* pElement, const std::vector<std::wstring>& arNextNodes, std::vector<const CElement*>& arFindedElements, const std::wstring& wsName, const std::vector<std::wstring>& arClasses = {});
+
+		std::wstring m_sEncoding;
 	public:
 		CCssCalculator_Private();
 		~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);
+
+		void ClearPageData();
 		#endif
 
+		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);
 		void AddStyles(const std::wstring& wsStyle);
 		void AddStylesFromFile(const std::wstring& wsFileName);
@@ -85,10 +122,12 @@ namespace NSCSS
 		std::wstring GetEncoding() const;
 		unsigned short int GetDpi() const;
 
-		const std::map<std::wstring, CElement*>* GetData() const;
-
+		void ClearEmbeddedStyles();
+		void ClearAllowedStyleFiles();
+		void ClearStylesFromFile(const std::wstring& wsFilePath);
 		void Clear();
-
 	};
+
+	inline bool IsTableElement(const std::wstring& wsNameTag);
 }
 #endif // CCSSCALCULATOR_PRIVATE_H

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

@@ -40,6 +40,7 @@ namespace NSCSS
 	{
 		m_sSelector = sSelector;
 		m_sFullSelector = m_sSelector;
+		UpdateWeight();
 	}
 
 	void NSCSS::CElement::AddPropertie(const std::wstring &sName, const std::wstring& sValue)
@@ -67,6 +68,7 @@ namespace NSCSS
 
 		m_arPrevElements.push_back(oPrevElement);
 		oPrevElement->m_sFullSelector += L' ' + m_sFullSelector;
+		UpdateWeight();
 	}
 
 	void CElement::AddKinElement(CElement *oKinElement)
@@ -76,6 +78,7 @@ namespace NSCSS
 
 		m_arKinElements.push_back(oKinElement);
 		oKinElement->m_sFullSelector += m_sFullSelector;
+		oKinElement->UpdateWeight();
 	}
 
 	std::map<std::wstring, std::wstring> CElement::GetStyle() const
@@ -230,11 +233,14 @@ namespace NSCSS
 		return NULL;
 	}
 
-	std::vector<unsigned short> CElement::GetWeight()
+	void CElement::UpdateWeight()
 	{
 		if (m_arWeight.empty())
 			m_arWeight = NS_STATIC_FUNCTIONS::GetWeightSelector(m_sFullSelector);
+	}
 
+	std::vector<unsigned short> CElement::GetWeight() const
+	{
 		return m_arWeight;
 	}
 

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

@@ -44,7 +44,8 @@ namespace NSCSS
 
 		CElement *FindPrevElement(const std::wstring& sSelector) const;
 
-		std::vector<unsigned short int> GetWeight();
+		void UpdateWeight();
+		std::vector<unsigned short int> GetWeight() const;
 		void IncreasedWeight();
 	};
 }

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/StaticFunctions.cpp

@@ -48,7 +48,6 @@ namespace NS_STATIC_FUNCTIONS
 		if (sEncoding.empty())
 			sEncoding = "utf-8";
 
-
 		if (!sEncoding.empty() && sEncoding != "utf-8" && sEncoding != "UTF-8")
 		{
 			NSUnicodeConverter::CUnicodeConverter oConverter;

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

@@ -1328,7 +1328,6 @@ namespace NSCSS
 
 	// DISPLAY
 	CDisplay::CDisplay()
-	    : m_oDisplay(L"inline", 0)
 	{}
 
 	void CDisplay::Equation(CDisplay &oFirstDisplay, CDisplay &oSecondDisplay)

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;
 
@@ -316,7 +316,7 @@ namespace NSCSS
 
 		std::wstring wsTextAlign{oStyle.m_oText.GetAlign().ToWString()};
 
-		if (wsTextAlign.empty() && bInTable)
+		if (wsTextAlign.empty())
 			wsTextAlign = oStyle.m_oDisplay.GetHAlign().ToWString();
 
 		oXmlElement.AddPropertiesInP(PProperties::P_Jc, wsTextAlign);
@@ -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/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,102 @@
+#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; }");
+	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; background-color: transparent; border-radius: 0; color: inherit; }");
+	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>");
+	WriteBaseHtmlStyles(oFile);
+	oFile.WriteStringUTF8(L"</head>");
+
+	bool bResult = true;
+
+	if (0 != md_html(sMdData.c_str(), sMdData.length(), ToHtmlFile, &oFile, MD_DIALECT_GITHUB, 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)
@@ -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();
@@ -1397,6 +1667,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 +1696,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 +1721,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 +1733,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 +1776,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 +1852,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 +1881,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 +1912,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 +1926,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 +1962,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 +2066,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

@@ -109,6 +109,31 @@ win32:!contains(QMAKE_TARGET.arch, x86_64): {
 	CONFIG += core_win_32
 }
 
+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
 linux-g++:contains(QMAKE_HOST.arch, x86_64): {
@@ -196,6 +221,10 @@ core_mac {
 	}
 }
 
+core_linux_clang {
+	QMAKE_CFLAGS += -Wno-implicit-function-declaration
+}
+
 # PREFIXES
 core_windows {
 	CONFIG -= debug_and_release debug_and_release_target
@@ -416,6 +445,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 +458,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 {

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/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)

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/cximage/CxImage/ximacfg.h

@@ -38,6 +38,7 @@
 #define CXIMAGE_SUPPORT_PNM 1
 #define CXIMAGE_SUPPORT_RAS 1
 #define CXIMAGE_SUPPORT_PIC 1
+#define CXIMAGE_SUPPORT_HEIF 1
 
 #define CXIMAGE_SUPPORT_JBG 0		// GPL'd see ../jbig/copying.txt & ../jbig/patents.htm
 

DesktopEditor/cximage/CxImage/ximage.h

@@ -133,13 +133,17 @@ CXIMAGE_FORMAT_PSD = 20,
 #if CXIMAGE_SUPPORT_PIC
 CXIMAGE_FORMAR_PIC = 25,
 #endif
+#if CXIMAGE_SUPPORT_HEIF
+CXIMAGE_FORMAT_HEIF = 26,
+#endif
 CMAX_IMAGE_FORMATS = CXIMAGE_SUPPORT_BMP + CXIMAGE_SUPPORT_GIF + CXIMAGE_SUPPORT_JPG +
 					 CXIMAGE_SUPPORT_PNG + CXIMAGE_SUPPORT_MNG + CXIMAGE_SUPPORT_ICO +
 					 CXIMAGE_SUPPORT_TIF + CXIMAGE_SUPPORT_TGA + CXIMAGE_SUPPORT_PCX +
                      CXIMAGE_SUPPORT_WBMP+ CXIMAGE_SUPPORT_WMF + CXIMAGE_SUPPORT_PIC +
 					 CXIMAGE_SUPPORT_JBG + CXIMAGE_SUPPORT_JP2 + CXIMAGE_SUPPORT_JPC +
 					 CXIMAGE_SUPPORT_PGX + CXIMAGE_SUPPORT_PNM + CXIMAGE_SUPPORT_RAS +
-					 CXIMAGE_SUPPORT_SKA + CXIMAGE_SUPPORT_RAW + CXIMAGE_SUPPORT_PSD + 1
+					 CXIMAGE_SUPPORT_SKA + CXIMAGE_SUPPORT_RAW + CXIMAGE_SUPPORT_PSD +
+					 CXIMAGE_SUPPORT_HEIF + 1
 };
 
 #if CXIMAGE_SUPPORT_EXIF

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/cximage/tiff/tif_getimage.c

@@ -23,14 +23,14 @@
  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  * OF THIS SOFTWARE.
  */
-
-#pragma warning (disable : 4550)
+
+#pragma warning (disable : 4550)
 
 /*
  * TIFF Library
  *
  * Read and return a packed RGBA image.
- */
+ */
 #include "tiffiop.h"
 #include <stdio.h>
 
@@ -828,11 +828,12 @@ gtStripContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
 		nrowsub = nrow;
 		if ((nrowsub%subsamplingver)!=0)
 			nrowsub+=subsamplingver-nrowsub%subsamplingver;
+
 		if (TIFFReadEncodedStrip(tif,
 		    TIFFComputeStrip(tif,row+img->row_offset, 0),
 		    buf,
-		    ((row + img->row_offset)%rowsperstrip + nrowsub) * scanline) < 0
-		    && img->stoponerr)
+			((row + img->row_offset)%rowsperstrip + nrowsub) * scanline) < 0
+			&& img->stoponerr)
 		{
 			ret = 0;
 			break;

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/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.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
@@ -382,6 +383,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()))
@@ -422,6 +437,36 @@ class CDocBuilderValue:
                 return CDocBuilderValue(OBJECT_HANDLE(_lib.CDocBuilderValue_Call6(self._internal, ctypes.c_wchar_p(name), values[0]._internal, values[1]._internal, values[2]._internal, values[3]._internal, values[4]._internal, values[5]._internal)))
         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 +479,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 +653,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

@@ -82,7 +82,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 +92,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 +120,9 @@ bool CV8RealTimeWorker::ExecuteCommand(const std::wstring& command, NSDoctRender
 
 	LOGGER_SPEED_LAP("run_command");
 
+	if (isEnterContext)
+		m_context->Exit();
+
 	return true;
 }
 
@@ -240,6 +253,14 @@ bool CV8RealTimeWorker::InitVariables()
 		if (try_catch->Check())
 			return false;
 	}
+
+	if (!m_sJSCodeStart.empty())
+	{
+		m_context->runScript(m_sJSCodeStart, try_catch);
+		if (try_catch->Check())
+			return false;
+	}
+
 	return true;
 }
 
@@ -336,7 +357,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)
@@ -362,7 +393,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;
@@ -391,7 +424,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,
@@ -403,7 +436,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;
 }
@@ -1231,8 +1267,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 true;
+		}
+
+		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);
@@ -1391,7 +1448,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;
@@ -1413,6 +1470,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);
 					}
 				}
@@ -1478,7 +1539,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;
@@ -1539,6 +1600,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
@@ -422,6 +424,7 @@ public:
 	int m_nFileType;
 	std::string m_sUtf8ArgumentJSON;
 	std::string m_sGlobalVariable;
+	std::string m_sJSCodeStart;
 
 	CJSContextData m_oContextData;
 
@@ -434,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
@@ -455,7 +461,8 @@ namespace NSDoctRenderer
 		std::wstring m_sTmpFolder;
 		std::wstring m_sFileDir;
 		int m_nFileType;
-		bool m_bJavascriptBeforeEditor;
+
+		std::wstring m_sCommandsBeforeContextCreated;
 
 		std::wstring m_sX2tPath;
 
@@ -474,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_bJavascriptBeforeEditor(false)
+			  m_sGlobalVariable(""), m_bIsGlobalVariableUse(false), m_pParent(NULL), m_sCommandsBeforeContextCreated(L""), m_bIsOpenedFromSimpleJS(false)
 		{
 		}
 
@@ -637,10 +646,14 @@ namespace NSDoctRenderer
 			{
 				NSDirectory::CreateDirectory(m_sFileDir + L"/media");
 				NSDirectory::CreateDirectory(m_sFileDir + L"/changes");
-			}
 
-			if (m_bJavascriptBeforeEditor)
-				CheckWorkerAfterOpen();
+				if (m_pWorker && m_pWorker->IsSimpleJSInstance() && !m_bIsOpenedFromSimpleJS)
+				{
+					RELEASEOBJECT(m_pWorker);
+					CheckWorker();
+				}
+				return bRet;
+			}
 
 			return bRet;
 #else
@@ -931,8 +944,11 @@ namespace NSDoctRenderer
 
 			if (0 == nReturnCode)
 			{
-				if (m_bJavascriptBeforeEditor)
-					CheckWorkerAfterOpen();
+				if (m_pWorker && m_pWorker->IsSimpleJSInstance() && !m_bIsOpenedFromSimpleJS)
+				{
+					RELEASEOBJECT(m_pWorker);
+					CheckWorker();
+				}
 				return 0;
 			}
 
@@ -981,10 +997,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!");
@@ -1023,7 +1045,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";
 			}
 
@@ -1068,6 +1090,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();
@@ -1220,62 +1244,75 @@ namespace NSDoctRenderer
 		{
 			if (NULL == m_pWorker)
 			{
-				m_pWorker = new CV8RealTimeWorker(m_pParent, GetEditorType(), this);
+				NSDoctRenderer::DoctRendererEditorType editorType = GetEditorType();
+				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);
 
-				return CheckWorkerAfterOpen();
+				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;
+
+				return m_pWorker->OpenFile(m_sX2tPath, m_sFileDir, editorType, this, &oParams);
 			}
 			return true;
 		}
 
-		bool CheckWorkerAfterOpen()
-		{
-			if (!m_pWorker)
-				return false;
-
-			m_pWorker->m_nFileType = m_nFileType;
-			if (-1 == m_nFileType)
-			{
-				m_bJavascriptBeforeEditor = true;
-				return false;
-			}
-
-			m_bJavascriptBeforeEditor = false;
-
-			CV8Params oParams;
-			oParams.IsServerSaveVersion = m_bIsServerSafeVersion;
-			oParams.DocumentDirectory = m_sFileDir;
-
-			return m_pWorker->OpenFile(m_sX2tPath, m_sFileDir, GetEditorType(), this, &oParams);
-		}
-
 		int SaveFile(const std::wstring& ext, const std::wstring& path, const wchar_t* params = NULL)
 		{
 			int nType = GetFormatByTexExtention(ext);
 			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 && !forceExecute)
+			{
+				m_sCommandsBeforeContextCreated += command;
+				return true;
+			}
+
 			Init();
 
-			bool bRes = CheckWorker();
+			if (CheckWorker())
+			{
+				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;
+				}
+			}
 
-			if (!bRes && m_pWorker && m_bJavascriptBeforeEditor)
-				m_pWorker->InitVariables();
-
-			return m_pWorker->ExecuteCommand(command, retValue);
+			return false;
 		}
 
 		CDocBuilderContext GetContext(bool enterContext)
 		{
 			CDocBuilderContext ctx;
 
-			CheckWorker();
+			if (!CheckWorker())
+				return ctx;
 
 			ctx.m_internal->m_context = m_pWorker->m_context;
 			ctx.m_internal->m_context_data = &m_pWorker->m_oContextData;

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,24 @@ 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)
+	{
+		if (m_nType == 0)
+			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)
 	{

DesktopEditor/doctrenderer/editors.cpp

@@ -6,16 +6,16 @@ namespace NSDoctRenderer
 {
 	namespace
 	{
-		void AppendScript(NSStringUtils::CStringBuilderA* builder, const std::wstring& path)
+		bool AppendScript(NSStringUtils::CStringBuilderA* builder, const std::wstring& path, const std::string& header = "", const std::string& footer = "")
 		{
 			NSFile::CFileBinary oFile;
 
 			if (!oFile.OpenFile(path))
-				return;
+				return false;
 
 			int size = (int)oFile.GetFileSize();
 			if (size < 3)
-				return;
+				return false;
 
 			BYTE* pData = new BYTE[size];
 			DWORD dwReadSize = 0;
@@ -26,9 +26,18 @@ namespace NSDoctRenderer
 			if (pData[0] == 0xEF && pData[1] == 0xBB && pData[2] == 0xBF)
 				nOffset = 3;
 
+			if (!header.empty())
+				builder->WriteString(header);
+
 			builder->WriteString((char*)(pData + nOffset), size - nOffset);
+
+			if (!footer.empty())
+				builder->WriteString(footer);
+
 			builder->WriteString("\n\n");
 			RELEASEARRAYOBJECTS(pData);
+
+			return true;
 		}
 
 		bool RunScript(JSSmart<NSJSBase::CJSContext>& context, JSSmart<NSJSBase::CJSTryCatch>& try_catch, const std::wstring& path)
@@ -114,6 +123,7 @@ namespace NSDoctRenderer
 				AppendScript(builder, sFontsPath);
 				AppendScript(builder, config->m_strSdkPath + L"/word/sdk-all.js");
 				AppendScript(builder, config->m_strSdkPath + L"/pdf/src/engine/drawingfile_native.js");
+				AppendScript(builder, config->m_strSdkPath + L"/pdf/src/annotations/stamps.json", "window[\"native_pdf_stamps\"]=", ";");
 				sCachePath = config->m_strSdkPath + L"/pdf/sdk-all";
 				break;
 			}

DesktopEditor/doctrenderer/embed/DrawingFileEmbed.cpp

@@ -1,5 +1,6 @@
 #include "DrawingFileEmbed.h"
 #include "../drawingfile.h"
+#include "../../raster/BgraFrame.h"
 
 JSSmart<CJSValue> WasmMemoryToJS(BYTE* pWasmData)
 {
@@ -165,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);
+		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());

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);
 }
 

DesktopEditor/doctrenderer/embed/NativeBuilderEmbed.h

@@ -50,6 +50,7 @@ public:
 	~CBuilderEmbed() { if(m_pBuilder) 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/ZipEmbed.cpp

@@ -258,3 +258,64 @@ JSSmart<CJSValue> CZipEmbed::getImageType(JSSmart<CJSValue> typedArray)
 		oBuffer.Free();
 	return CJSContext::createInt(bIsImageFile ? oChecker.eFileType : 0);
 }
+
+JSSmart<CJSValue> CZipEmbed::getImageBuffer(JSSmart<CJSValue> filePath)
+{
+	if (!m_pFolder || !filePath->isString())
+		return CJSContext::createNull();
+
+	std::wstring sFilePath = filePath->toStringW();
+	IFolder::CBuffer* pBuffer;
+	if (!m_pFolder->read(sFilePath, pBuffer))
+		return CJSContext::createNull();
+
+	size_t nBufferSize = (size_t)pBuffer->Size;
+
+	CImageFileFormatChecker oChecker;
+	bool bIsImageFile = oChecker.isImageFile(pBuffer->Buffer, (DWORD)pBuffer->Size);
+
+	if (!bIsImageFile)
+	{
+		RELEASEOBJECT(pBuffer);
+		return CJSContext::createNull();
+	}
+
+	bool bIsNeedConvertMetfileToSvg = false;
+
+	// Make as wasm module
+	if (oChecker.eFileType == _CXIMAGE_FORMAT_WMF || oChecker.eFileType == _CXIMAGE_FORMAT_EMF)
+		oChecker.eFileType = _CXIMAGE_FORMAT_SVG;
+	else
+		bIsNeedConvertMetfileToSvg = false;
+
+	if (!bIsNeedConvertMetfileToSvg)
+	{
+		BYTE* pMemory = NSJSBase::NSAllocator::Alloc(nBufferSize);
+		memcpy(pMemory, pBuffer->Buffer, nBufferSize);
+		RELEASEOBJECT(pBuffer);
+
+		JSSmart<CJSObject> retObject = CJSContext::createObject();
+		retObject->set("type", CJSContext::createInt(oChecker.eFileType));
+		retObject->set("data", NSJSBase::CJSContext::createUint8Array(pMemory, (int)nBufferSize, false));
+		return retObject->toValue();
+	}
+
+#ifndef GRAPHICS_DISABLE_METAFILE
+	MetaFile::IMetaFile* pMetaFile = MetaFile::Create(NULL);
+	pMetaFile->LoadFromBuffer(pBuffer->Buffer, (unsigned int)pBuffer->Size);
+	std::wstring wsSvg = pMetaFile->ConvertToSvg();
+	std::string sSvg = U_TO_UTF8(wsSvg);
+	pMetaFile->Release();
+	RELEASEOBJECT(pBuffer);
+
+	BYTE* pData = NSAllocator::Alloc(sSvg.length());
+	memcpy(pData, sSvg.c_str(), sSvg.length());
+
+	JSSmart<CJSObject> retObject = CJSContext::createObject();
+	retObject->set("type", CJSContext::createInt(24));
+	retObject->set("data", NSJSBase::CJSContext::createUint8Array(pData, sSvg.length(), false));
+	return retObject->toValue();
+#else
+	return CJSContext::createNull();
+#endif
+}

DesktopEditor/doctrenderer/embed/ZipEmbed.h

@@ -36,6 +36,7 @@ public:
 	JSSmart<CJSValue> encodeImageData(JSSmart<CJSValue> typedArray, JSSmart<CJSValue> w, JSSmart<CJSValue> h, JSSmart<CJSValue> stride, JSSmart<CJSValue> format, JSSmart<CJSValue> isRgba);
 	JSSmart<CJSValue> encodeImage(JSSmart<CJSValue> typedArray, JSSmart<CJSValue> format);
 	JSSmart<CJSValue> getImageType(JSSmart<CJSValue> typedArray);
+	JSSmart<CJSValue> getImageBuffer(JSSmart<CJSValue> path);
 
 	DECLARE_EMBED_METHODS
 };

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/jsc/jsc_ZipEmbed.mm

@@ -17,6 +17,7 @@
 -(JSValue*) encodeImageData : (JSValue*)typedArray : (JSValue*)w : (JSValue*)h : (JSValue*)stride : (JSValue*)format : (JSValue*)isRgba;
 -(JSValue*) encodeImage : (JSValue*)typedArray : (JSValue*)format;
 -(JSValue*) getImageType : (JSValue*)typedArray;
+-(JSValue*) getImageBuffer : (JSValue*)path;
 @end
 
 @interface CJSCZipEmbed : NSObject<IJSCZipEmbed, JSEmbedObjectProtocol>
@@ -41,6 +42,7 @@ FUNCTION_WRAPPER_JS_2(decodeImage, decodeImage)
 FUNCTION_WRAPPER_JS_6(encodeImageData, encodeImageData)
 FUNCTION_WRAPPER_JS_2(encodeImage, encodeImage)
 FUNCTION_WRAPPER_JS_1(getImageType, getImageType)
+FUNCTION_WRAPPER_JS_1(getImageBuffer, getImageBuffer)
 @end
 
 class CZipEmbedAdapter : 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/embed/v8/v8_ZipEmbed.cpp

@@ -20,6 +20,7 @@ namespace NSZipEmbed
 	FUNCTION_WRAPPER_V8_6(_encodeImageData, encodeImageData)
 	FUNCTION_WRAPPER_V8_2(_encodeImage, encodeImage)
 	FUNCTION_WRAPPER_V8_1(_getImageType, getImageType)
+	FUNCTION_WRAPPER_V8_1(_getImageBuffer, getImageBuffer)
 
 	v8::Handle<v8::ObjectTemplate> CreateTemplate(v8::Isolate* isolate)
 	{
@@ -39,6 +40,7 @@ namespace NSZipEmbed
 		NSV8Objects::Template_Set(result, "encodeImageData",	_encodeImageData);
 		NSV8Objects::Template_Set(result, "encodeImage",	_encodeImage);
 		NSV8Objects::Template_Set(result, "getImageType",	_getImageType);
+		NSV8Objects::Template_Set(result, "getImageBuffer",	_getImageBuffer);
 
 		return handle_scope.Escape(result);
 	}

DesktopEditor/doctrenderer/js_internal/js_base.h

@@ -483,6 +483,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/jsc/jsc_base.mm

@@ -374,7 +374,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 +439,11 @@ namespace NSJSBase
 	{
 	}
 
+	bool CJSContext::IsEntered()
+	{
+		return true;
+	}
+
 	class CJSLocalScopePrivate
 	{
 	public:

DesktopEditor/doctrenderer/js_internal/v8/v8_base.cpp

@@ -255,6 +255,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 +273,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()

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)

DesktopEditor/fontengine/ApplicationFontsWorker.cpp

@@ -356,6 +356,8 @@ public:
 
 		virtual void Check(const int& nCode, const unsigned int& nIndex)
 		{
+			if (nCode > m_nMaxSymbols)
+				return;
 			if (nCode > m_nMax)
 				m_nMax = nCode;
 			if (nCode < m_nMin)
@@ -794,6 +796,8 @@ public:
 				std::wstring sNameCorrect = pPair->second.m_sName;
 				NSStringUtils::string_replace(sNameCorrect, L"\\", L"\\\\");
 				NSStringUtils::string_replace(sNameCorrect, L"\"", L"\\\"");
+				NSStringUtils::string_replace(sNameCorrect, L"\n", L"");
+				NSStringUtils::string_replace(sNameCorrect, L"\r", L"");
 				oWriterJS += sNameCorrect;
 
 				oWriterJS.AddSize(120);

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/allfonts/module.js

@@ -1,5 +1,5 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * (c) Copyright Ascensio System SIA 2010-2024
  *
  * 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)

DesktopEditor/fontengine/js/cpp/text.cpp

@@ -1,5 +1,5 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * (c) Copyright Ascensio System SIA 2010-2024
  *
  * 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)
@@ -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/engine/module_js.js

@@ -1,5 +1,5 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * (c) Copyright Ascensio System SIA 2010-2024
  *
  * 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)
@@ -531,6 +531,45 @@ ZLib.prototype.getImageAsSvg = function(path)
 
 	return string;
 };
+/**
+ * Get image file raw data. this memory was copied and detach from archive.
+ * @returns {Uint8Array}
+ */
+ZLib.prototype.getImageBuffer = function(path)
+{
+	let result = {
+		type : 0,
+		data : null
+	};
+	result.type = this.getImageType(path);
+	if (result.type === 0)
+		return null;
+
+	let fileData = this.getFile(path);
+	result.data = new Uint8Array(fileData.length);
+	result.data.set(fileData);
+	
+	if (result.type != 10 && 
+		result.type != 21)
+	{
+		return result;
+	}
+
+	result.type = 24;
+	// Source was saved as result.data for using original image in native convertations.
+	// But for js we need svg for metafiles.
+
+	let encodedData = Module["_Raster_Encode"](this.files[path].p + 4, fileData.length, 24);
+	let encodedSize = Module["_Raster_GetEncodedSize"](encodedData);
+	let encodedBuffer = Module["_Raster_GetEncodedBuffer"](encodedData);
+
+	let fileDataEnc = new Uint8Array(Module["HEAP8"].buffer, encodedBuffer, encodedSize);
+	result.dataBlob = new Uint8Array(fileDataEnc.length);
+	result.dataBlob.set(fileDataEnc);
+	
+	Module["_Raster_DestroyEncodedData"](encodedData);
+	return result;
+};
 /**
  * Get image blob for browser
  * @returns {Blob}

DesktopEditor/fontengine/js/engine/module_native.js

@@ -1,5 +1,5 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * (c) Copyright Ascensio System SIA 2010-2024
  *
  * 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)
@@ -35,7 +35,7 @@
 window['AscFonts'] = window['AscFonts'] || {};
 var AscFonts = window['AscFonts'];
 
-var g_native_engine = CreateEmbedObject("CTextMeasurerEmbed");
+var g_native_engine = null;
 
 function CReturnObject()
 {
@@ -236,4 +236,6 @@ AscFonts.Hyphen_Word = function(lang, word)
 AscFonts.onLoadModule();
 AscFonts.onLoadModule();
 
+window["InitNativeTextMeasurer"] = function() { g_native_engine = CreateEmbedObject("CTextMeasurerEmbed"); };
+
 })(window, undefined);

DesktopEditor/fontengine/js/libfont.json

@@ -100,6 +100,7 @@
 		"FT_CONFIG_OPTION_SYSTEM_ZLIB",
 		"GRAPHICS_NO_USE_DYNAMIC_LIBRARY",
 		"HYPHEN_ENGINE_DISABLE_FILESYSTEM",
+		"METAFILE_DISABLE_FILESYSTEM",
 
 		"HAVE_UNISTD_H", "HAVE_FCNTL_H", "_ARM_ALIGN_",
 		"METAFILE_SUPPORT_WMF_EMF",
@@ -259,10 +260,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/",

DesktopEditor/fontengine/js/module.js

@@ -1,5 +1,5 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * (c) Copyright Ascensio System SIA 2010-2024
  *
  * 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)
@@ -761,6 +761,14 @@ function onLoadFontsModule(window, undefined)
 	{
 		return this.engine["getImageBlob"](path);
 	};
+	/**
+	 * Get image file raw data. this memory was copied and detach from archive.
+	 * @returns {Uint8Array}
+	 */
+	ZLib.prototype.getImageBuffer = function(path)
+	{
+		return this.engine["getImageBuffer"](path);
+	};
 	/**
 	 * Get all file paths in archive
 	 * @returns {Array}
@@ -772,10 +780,84 @@ function onLoadFontsModule(window, undefined)
 
 	AscCommon.ZLib = ZLib;
 
+	function ZlibImageBlobs()
+	{
+		this.url2BlobUrl = {};
+		this.blobUrl2Data = {};
+		this.url2Base64 = {};
+
+		this.nativeBlobCounter = 1;
+	}
+	ZlibImageBlobs.prototype.getBlobUrl = function(path, zip)
+	{
+		if (this.url2BlobUrl[path])
+			return this.url2BlobUrl[path];
+
+		let result = zip.getImageBuffer(path);
+		if (result == null)
+			return "";
+
+		let blobUrl = "";
+		let blobType = AscCommon.openXml.GetMimeType((24 !== result["type"]) ? AscCommon.GetFileExtension(path) : "svg");
+
+		if (window["NATIVE_EDITOR_ENJINE"])
+		{
+			blobUrl = "blob:internal-image" + this.nativeBlobCounter++;
+		}
+		else
+		{
+			try
+			{
+				let blob = new Blob([result["dataBlob"] ? result["dataBlob"] : result["data"]], {type: blobType});
+				blobUrl = window.URL.createObjectURL(blob);
+			}
+			catch (e)
+			{
+				blobUrl = "error";
+				AscCommon.consoleLog("ERROR: Image blob was not loaded");
+			}
+		}
+
+		this.blobUrl2Data[blobUrl] = result;
+		this.url2BlobUrl[path] = blobUrl;
+		return blobUrl;
+	};
+	ZlibImageBlobs.prototype.getImageBase64 = function(url)
+	{
+		if (this.url2Base64[url])
+			return this.url2Base64[url];
+
+		let obj = this.blobUrl2Data[url];
+		if (!obj)
+			return url;
+
+		let header = "";
+		switch (obj.type)
+		{
+			case 3:
+				header = "data:image/jpeg;base64,";
+				break;
+			case 24:
+				header = "data:image/svg+xml;base64,";
+				break;
+			case 4:
+			default:
+				header = "data:image/png;base64,";
+		}
+
+		this.url2Base64[url] = header + AscCommon.Base64.encode(obj.data);
+		return this.url2Base64[url];
+	};
+
+	window["AscCommon"].g_oDocumentBlobUrls = new ZlibImageBlobs();
+
 	if (AscCommon["CZLibEngineJS"])
 		AscCommon["CZLibEngineJS"].prototype["isModuleInit"] = true;
 
-	window.nativeZlibEngine = new ZLib();
+	if (window["NATIVE_EDITOR_ENJINE"])
+		window["InitNativeZLib"] = function() { window.nativeZlibEngine = new ZLib(); };
+	else
+		window.nativeZlibEngine = new ZLib();
 
 	function Hyphenation()
 	{

DesktopEditor/graphics/BooleanOperations.cpp

@@ -1020,22 +1020,39 @@ void CBooleanOperations::TracePaths()
 {
 	size_t length = Segments1.size();
 	Result.StartFigure();
+	bool first_start = true;
 	for (size_t i = 0; i < length + Segments2.size(); i++)
 	{
 		Segment s = i >= length ? Segments2[i - length] : Segments1[i];
 		bool valid = s.IsValid(Op),
-			start = true;
+			 start = true;
+		PointD start_point;
 		while (valid)
 		{
 			if (!start || (Op == Intersection && s.Inters && !GetNextSegment(s).Inters))
 				SetVisited(s);
 
-			if (start)
+			if (first_start)
+			{
 				Result.MoveTo(s.P.X, s.P.Y);
+				start_point = s.P;
+			}
+			else if (start)
+			{
+				double x, y;
+				Result.GetLastPoint(x, y);
+				if (isZero(start_point.X - x) && isZero(start_point.Y - y))
+				{
+					Result.MoveTo(s.P.X, s.P.Y);
+					start_point = s.P;
+				}
+				else
+					Result.LineTo(s.P.X, s.P.Y);
+			}
 			else if (s.IsCurve)
 				Result.CurveTo(s.HI.X + s.P.X, s.HI.Y + s.P.Y,
-								s.HO.X + s.P.X, s.HO.Y + s.P.Y,
-								s.P.X, s.P.Y);
+							   s.HO.X + s.P.X, s.HO.Y + s.P.Y,
+							   s.P.X, s.P.Y);
 			else
 				Result.LineTo(s.P.X, s.P.Y);
 
@@ -1065,6 +1082,9 @@ void CBooleanOperations::TracePaths()
 
 			if (start)
 				start = false;
+
+			if (first_start)
+				first_start = false;
 		}
 
 		if (!start && AllOverlap()) break;
@@ -1645,12 +1665,14 @@ int CBooleanOperations::CheckInters(const PointD& point, const Segment& segment,
 		std::vector<double> roots = curve.GetCurveLineIntersection(segment.P.X,segment.P.Y, point.X - segment.P.X, point.Y - segment.P.Y);
 		Curve line(segment, Segment(point));
 
-		int count = 0;
-		for (const auto& r : roots)
-			if (line.GetTimeOf(curve.GetPoint(r)) != -1)
-				count++;
+		return roots.size() % 2;
 
-		return count;
+		// int count = 0;
+		// for (const auto& r : roots)
+		// 	if (line.GetTimeOf(curve.GetPoint(r)) != -1)
+		// 		count++;
+
+		// return count;
 	}
 	return 0;
 }

DesktopEditor/graphics/GraphicsPath.cpp

@@ -863,20 +863,22 @@ namespace Aggplus
 
 	double CGraphicsPath::GetArea(unsigned idx, bool isCurve) const noexcept
 	{
-		float area;
+		double area;
 		if (isCurve)
 		{
 			std::vector<PointD> points = GetPoints(idx, 4);
-			area = 3 * ((points[3].Y - points[0].Y)	* (points[1].X + points[2].X)
-						- (points[3].X - points[0].X) * (points[1].Y * points[2].Y)
-						+ points[1].Y * (points[0].X - points[2].X)
-						- points[1].X * (points[0].Y - points[2].Y)
-						+ points[3].Y * (points[2].X + points[0].X / 3)
-						- points[3].X * (points[2].Y - points[0].Y / 3)) / 20;
+			area = (points[3].Y - points[0].Y) * (points[1].X + points[2].X)
+					- (points[3].X - points[0].X) * (points[1].Y + points[2].Y)
+					+ points[1].Y * (points[0].X - points[2].X)
+					- points[1].X * (points[0].Y - points[2].Y)
+					+ points[3].Y * (points[2].X + points[0].X / 3.0)
+					- points[3].X * (points[2].Y + points[0].Y / 3.0);
+		}
+		else
+		{
+			std::vector<PointD> points = GetPoints(idx, 2);
+			area = 4.0 * (points[1].Y * points[0].X - points[1].X * points[0].Y) / 3.0;
 		}
-
-		std::vector<PointD> points = GetPoints(idx, 2);
-		area = (points[1].Y * points[0].X - points[1].X * points[0].Y) / 20;
 
 		return area;
 	}

DesktopEditor/graphics/MetafileToRenderer.cpp

@@ -153,13 +153,6 @@ IMetafileToRenderter::IMetafileToRenderter(IRenderer* pRenderer)
 }
 IMetafileToRenderter::~IMetafileToRenderter()
 {
-	for (std::vector<std::wstring>::iterator i = m_arTempFiles.begin(); i != m_arTempFiles.end(); i++)
-	{
-		std::wstring sPath = *i;
-		if (NSFile::CFileBinary::Exists(sPath))
-			NSFile::CFileBinary::Remove(sPath);
-	}
-
 	if (m_pPicker)
 	{
 		CMetafileFontPicker* pPicker = (CMetafileFontPicker*)m_pPicker;
@@ -234,8 +227,6 @@ std::wstring IMetafileToRenderter::GetImagePath(const std::wstring& sPath)
 					oFrame.put_Data(NULL);
 					sImagePath = sTempFile;
 				}
-
-				m_arTempFiles.push_back(sTempFile);
 			}
 
 			RELEASEARRAYOBJECTS(pImageBuffer);

DesktopEditor/graphics/MetafileToRenderer.h

@@ -49,7 +49,6 @@ public:
 
 protected:
 	std::wstring m_sTempDir;
-	std::vector<std::wstring> m_arTempFiles;
 
 	std::wstring m_sThemesDir;
 	std::wstring m_sMediaDir;

DesktopEditor/graphics/commands/AnnotField.cpp

@@ -48,7 +48,7 @@
 
 CAnnotFieldInfo::CAnnotFieldInfo() : IAdvancedCommand(AdvancedCommandType::Annotaion)
 {
-	m_nType = -1;
+	m_nType = EAnnotType::Unknown;
 
 	m_nFlag      = 0;
 	m_nID        = 0;
@@ -94,118 +94,108 @@ CAnnotFieldInfo::~CAnnotFieldInfo()
 	RELEASEOBJECT(m_pWidgetPr);
 }
 
+void CAnnotFieldInfo::CreateMarkup()
+{
+	RELEASEOBJECT(m_pMarkupPr);
+	m_pMarkupPr = new CAnnotFieldInfo::CMarkupAnnotPr();
+}
 void CAnnotFieldInfo::SetType(int nType)
 {
-	m_nType = nType;
-	switch (nType)
+	m_nType = static_cast<EAnnotType>(nType);
+	switch (m_nType)
 	{
-	case 0:
+	case EAnnotType::Text:
 	{
-		RELEASEOBJECT(m_pMarkupPr);
-		m_pMarkupPr = new CAnnotFieldInfo::CMarkupAnnotPr();
-
+		CreateMarkup();
 		RELEASEOBJECT(m_pTextPr);
 		m_pTextPr = new CAnnotFieldInfo::CTextAnnotPr();
 		break;
 	}
-	case 2:
+	case EAnnotType::FreeText:
 	{
-		RELEASEOBJECT(m_pMarkupPr);
-		m_pMarkupPr = new CAnnotFieldInfo::CMarkupAnnotPr();
-
+		CreateMarkup();
 		RELEASEOBJECT(m_pFreeTextPr);
 		m_pFreeTextPr = new CAnnotFieldInfo::CFreeTextAnnotPr();
 		break;
 	}
-	case 3:
+	case EAnnotType::Line:
 	{
-		RELEASEOBJECT(m_pMarkupPr);
-		m_pMarkupPr = new CAnnotFieldInfo::CMarkupAnnotPr();
-
+		CreateMarkup();
 		RELEASEOBJECT(m_pLinePr);
 		m_pLinePr = new CAnnotFieldInfo::CLineAnnotPr();
 		break;
 	}
-	case 4:
-	case 5:
+	case EAnnotType::Square:
+	case EAnnotType::Circle:
 	{
-		RELEASEOBJECT(m_pMarkupPr);
-		m_pMarkupPr = new CAnnotFieldInfo::CMarkupAnnotPr();
-
+		CreateMarkup();
 		RELEASEOBJECT(m_pSquareCirclePr);
 		m_pSquareCirclePr = new CAnnotFieldInfo::CSquareCircleAnnotPr();
 		break;
 	}
-	case 6:
-	case 7:
+	case EAnnotType::PolygonLine:
+	case EAnnotType::PolyLine:
 	{
-		RELEASEOBJECT(m_pMarkupPr);
-		m_pMarkupPr = new CAnnotFieldInfo::CMarkupAnnotPr();
-
+		CreateMarkup();
 		RELEASEOBJECT(m_pPolygonLinePr);
 		m_pPolygonLinePr = new CAnnotFieldInfo::CPolygonLineAnnotPr();
 		break;
 	}
-	case 8:
-	case 9:
-	case 10:
-	case 11:
+	case EAnnotType::Highlight:
+	case EAnnotType::Underline:
+	case EAnnotType::Squiggly:
+	case EAnnotType::Strikeout:
 	{
-		RELEASEOBJECT(m_pMarkupPr);
-		m_pMarkupPr = new CAnnotFieldInfo::CMarkupAnnotPr();
-
+		CreateMarkup();
 		RELEASEOBJECT(m_pTextMarkupPr);
 		m_pTextMarkupPr = new CAnnotFieldInfo::CTextMarkupAnnotPr();
 		break;
 	}
-	case 12:
+	case EAnnotType::Stamp:
 	{
-		RELEASEOBJECT(m_pMarkupPr);
-		m_pMarkupPr = new CAnnotFieldInfo::CMarkupAnnotPr();
-
+		CreateMarkup();
 		RELEASEOBJECT(m_pStampPr);
 		m_pStampPr = new CAnnotFieldInfo::CStampAnnotPr();
 		break;
 	}
-	case 13:
+	case EAnnotType::Caret:
 	{
-		RELEASEOBJECT(m_pMarkupPr);
-		m_pMarkupPr = new CAnnotFieldInfo::CMarkupAnnotPr();
-
+		CreateMarkup();
 		RELEASEOBJECT(m_pCaretPr);
 		m_pCaretPr = new CAnnotFieldInfo::CCaretAnnotPr();
 		break;
 	}
-	case 14:
+	case EAnnotType::Ink:
 	{
-		RELEASEOBJECT(m_pMarkupPr);
-		m_pMarkupPr = new CAnnotFieldInfo::CMarkupAnnotPr();
-
+		CreateMarkup();
 		RELEASEOBJECT(m_pInkPr);
 		m_pInkPr = new CAnnotFieldInfo::CInkAnnotPr();
 		break;
 	}
-	case 15:
+	case EAnnotType::Popup:
 	{
 		RELEASEOBJECT(m_pPopupPr);
 		m_pPopupPr = new CAnnotFieldInfo::CPopupAnnotPr();
 		break;
 	}
-	case 26:
-	case 27:
-	case 28:
-	case 29:
-	case 30:
-	case 31:
-	case 32:
-	case 33:
+	case EAnnotType::Widget:
+	case EAnnotType::WidgetPushButton:
+	case EAnnotType::WidgetRadioButton:
+	case EAnnotType::WidgetCheckBox:
+	case EAnnotType::WidgetText:
+	case EAnnotType::WidgetCombobox:
+	case EAnnotType::WidgetListbox:
+	case EAnnotType::WidgetSignature:
 	{
 		RELEASEOBJECT(m_pWidgetPr);
 		m_pWidgetPr = new CAnnotFieldInfo::CWidgetAnnotPr(nType);
 		break;
 	}
+	default:
+		break;
 	}
 }
+CAnnotFieldInfo::EAnnotType CAnnotFieldInfo::GetType() { return m_nType; }
 
 void CAnnotFieldInfo::GetBounds(double& dX1, double& dY1, double& dX2, double& dY2)
 {
@@ -224,6 +214,7 @@ int  CAnnotFieldInfo::GetFlag()      const { return m_nFlag; }
 int  CAnnotFieldInfo::GetID()        const { return m_nID; }
 int  CAnnotFieldInfo::GetAnnotFlag() const { return m_nAnnotFlag; }
 int  CAnnotFieldInfo::GetPage()      const { return m_nPage; }
+int CAnnotFieldInfo::GetCopyAP()     const { return m_nCopyAP; }
 void CAnnotFieldInfo::GetBE(BYTE& nS, double& dI) { nS = m_pBE.first; dI = m_pBE.second; }
 BYTE* CAnnotFieldInfo::GetRender(LONG& nLen)
 {
@@ -343,6 +334,7 @@ bool CAnnotFieldInfo::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMeta
 	if (nFlags & (1 << 3))
 	{
 		int n = pReader->ReadInt();
+		m_arrC.reserve(n);
 		for (int i = 0; i < n; ++i)
 			m_arrC.push_back(pReader->ReadDouble());
 	}
@@ -353,6 +345,7 @@ bool CAnnotFieldInfo::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMeta
 		if (m_oBorder.nType == 2)
 		{
 			int n = pReader->ReadInt();
+			m_oBorder.arrDash.reserve(n);
 			for (int i = 0; i < n; ++i)
 				m_oBorder.arrDash.push_back(pReader->ReadDouble());
 		}
@@ -367,6 +360,8 @@ bool CAnnotFieldInfo::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMeta
 	}
 	if (nFlags & (1 << 7))
 		m_wsOUserID = pReader->ReadString();
+	if (nFlags & (1 << 8))
+		m_nCopyAP = pReader->ReadInt();
 
 	if (IsMarkup())
 	{
@@ -428,6 +423,7 @@ void CAnnotFieldInfo::CMarkupAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferReader
 	if (nFlags & (1 << 3))
 	{
 		int nFont = pReader->ReadInt();
+		m_arrRC.reserve(nFont);
 		for (int i = 0; i < nFont; ++i)
 		{
 			CFontData* pFont = new CFontData();
@@ -480,6 +476,7 @@ void CAnnotFieldInfo::CInkAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferReader* p
 	{
 		std::vector<double> arrLine;
 		int m = pReader->ReadInt();
+		arrLine.reserve(m);
 		for (int j = 0; j < m; ++j)
 			arrLine.push_back(pReader->ReadDouble());
 		if (!arrLine.empty())
@@ -512,6 +509,7 @@ void CAnnotFieldInfo::CLineAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferReader*
 	if (nFlags & (1 << 16))
 	{
 		int n = pReader->ReadInt();
+		m_arrIC.reserve(n);
 		for (int i = 0; i < n; ++i)
 			m_arrIC.push_back(pReader->ReadDouble());
 	}
@@ -539,6 +537,7 @@ void CAnnotFieldInfo::CTextMarkupAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferRe
 {
 	m_nSubtype = nType;
 	int n = pReader->ReadInt();
+	m_arrQuadPoints.reserve(n);
 	for (int i = 0; i < n; ++i)
 		m_arrQuadPoints.push_back(pReader->ReadDouble());
 }
@@ -559,6 +558,7 @@ void CAnnotFieldInfo::CSquareCircleAnnotPr::Read(NSOnlineOfficeBinToPdf::CBuffer
 	if (nFlags & (1 << 16))
 	{
 		int n = pReader->ReadInt();
+		m_arrIC.reserve(n);
 		for (int i = 0; i < n; ++i)
 			m_arrIC.push_back(pReader->ReadDouble());
 	}
@@ -572,6 +572,7 @@ const std::vector<double>& CAnnotFieldInfo::CPolygonLineAnnotPr::GetVertices() {
 void CAnnotFieldInfo::CPolygonLineAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, BYTE nType, int nFlags)
 {
 	int n = pReader->ReadInt();
+	m_arrVertices.reserve(n);
 	for (int i = 0; i < n; ++i)
 		m_arrVertices.push_back(pReader->ReadDouble());
 
@@ -584,6 +585,7 @@ void CAnnotFieldInfo::CPolygonLineAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferR
 	if (nFlags & (1 << 16))
 	{
 		int n = pReader->ReadInt();
+		m_arrIC.reserve(n);
 		for (int i = 0; i < n; ++i)
 			m_arrIC.push_back(pReader->ReadDouble());
 	}
@@ -613,6 +615,7 @@ void CAnnotFieldInfo::CFreeTextAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferRead
 	if (nFlags & (1 << 16))
 	{
 		int n = pReader->ReadInt();
+		m_arrCL.reserve(n);
 		for (int i = 0; i < n; ++i)
 			m_arrCL.push_back(pReader->ReadDouble());
 	}
@@ -625,6 +628,7 @@ void CAnnotFieldInfo::CFreeTextAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferRead
 	if (nFlags & (1 << 21))
 	{
 		int n = pReader->ReadInt();
+		m_arrIC.reserve(n);
 		for (int i = 0; i < n; ++i)
 			m_arrIC.push_back(pReader->ReadDouble());
 	}
@@ -685,6 +689,7 @@ const std::wstring& CAnnotFieldInfo::CWidgetAnnotPr::GetDV() { return m_wsDV; }
 const std::wstring& CAnnotFieldInfo::CWidgetAnnotPr::GetT()  { return m_wsT; }
 const std::wstring& CAnnotFieldInfo::CWidgetAnnotPr::GetFontName()  { return m_wsFN; }
 const std::wstring& CAnnotFieldInfo::CWidgetAnnotPr::GetFontKey()   { return m_wsFK; }
+const std::wstring& CAnnotFieldInfo::CWidgetAnnotPr::GetOMetadata() { return m_wsOMetadata; }
 const std::vector<double>& CAnnotFieldInfo::CWidgetAnnotPr::GetTC() { return m_arrTC; }
 const std::vector<double>& CAnnotFieldInfo::CWidgetAnnotPr::GetBC() { return m_arrBC; }
 const std::vector<double>& CAnnotFieldInfo::CWidgetAnnotPr::GetBG() { return m_arrBG; }
@@ -814,6 +819,7 @@ CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget* ReadAction(NSOnlineOfficeBinToPd
 	{
 		pRes->nKind = pReader->ReadByte();
 		int n = pReader->ReadInt();
+		pRes->arrStr.reserve(n);
 		for (int i = 0; i < n; ++i)
 			pRes->arrStr.push_back(pReader->ReadString());
 		break;
@@ -822,6 +828,7 @@ CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget* ReadAction(NSOnlineOfficeBinToPd
 	{
 		pRes->nInt1 = pReader->ReadInt();
 		int n = pReader->ReadInt();
+		pRes->arrStr.reserve(n);
 		for (int i = 0; i < n; ++i)
 			pRes->arrStr.push_back(pReader->ReadString());
 		break;
@@ -841,6 +848,7 @@ void CAnnotFieldInfo::CWidgetAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferReader
 	m_nFontStyle = pReader->ReadInt();
 
 	int n = pReader->ReadInt();
+	m_arrTC.reserve(n);
 	for (int i = 0; i < n; ++i)
 		m_arrTC.push_back(pReader->ReadDouble());
 
@@ -863,6 +871,7 @@ void CAnnotFieldInfo::CWidgetAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferReader
 	if (nFlags & (1 << 5))
 	{
 		int n = pReader->ReadInt();
+		m_arrBC.reserve(n);
 		for (int i = 0; i < n; ++i)
 			m_arrBC.push_back(pReader->ReadDouble());
 	}
@@ -871,6 +880,7 @@ void CAnnotFieldInfo::CWidgetAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferReader
 	if (nFlags & (1 << 7))
 	{
 		int n = pReader->ReadInt();
+		m_arrBG.reserve(n);
 		for (int i = 0; i < n; ++i)
 			m_arrBG.push_back(pReader->ReadDouble());
 	}
@@ -880,6 +890,8 @@ void CAnnotFieldInfo::CWidgetAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferReader
 		m_nParentID = pReader->ReadInt();
 	if (nFlags & (1 << 18))
 		m_wsT = pReader->ReadString();
+	if (nFlags & (1 << 20))
+		m_wsOMetadata = pReader->ReadString();
 
 	// Action
 	int nAction = pReader->ReadInt();
@@ -976,7 +988,7 @@ void CAnnotFieldInfo::CWidgetAnnotPr::CTextWidgetPr::Read(NSOnlineOfficeBinToPdf
 		m_wsV = pReader->ReadString();
 	if (nFlags & (1 << 10))
 		m_nMaxLen = pReader->ReadInt();
-	if (nWidgetFlag & (1 << 25))
+	if (nFlags & (1 << 11))
 		m_wsRV = pReader->ReadString();
 	if (nFlags & (1 << 12))
 		m_wsAPV = pReader->ReadString();
@@ -1006,6 +1018,7 @@ void CAnnotFieldInfo::CWidgetAnnotPr::CChoiceWidgetPr::Read(NSOnlineOfficeBinToP
 	if (nFlags & (1 << 10))
 	{
 		int n = pReader->ReadInt();
+		m_arrOpt.reserve(n);
 		for (int i = 0; i < n; ++i)
 		{
 			std::wstring s1 = pReader->ReadString();
@@ -1020,12 +1033,14 @@ void CAnnotFieldInfo::CWidgetAnnotPr::CChoiceWidgetPr::Read(NSOnlineOfficeBinToP
 	if (nFlags & (1 << 13))
 	{
 		int n = pReader->ReadInt();
+		m_arrV.reserve(n);
 		for (int i = 0; i < n; ++i)
 			m_arrV.push_back(pReader->ReadString());
 	}
 	if (nFlags & (1 << 14))
 	{
 		int n = pReader->ReadInt();
+		m_arrI.reserve(n);
 		for (int i = 0; i < n; ++i)
 			m_arrI.push_back(pReader->ReadInt());
 	}
@@ -1052,16 +1067,24 @@ CWidgetsInfo::~CWidgetsInfo()
 	for (int i = 0; i < m_arrParents.size(); ++i)
 		RELEASEOBJECT(m_arrParents[i]);
 }
-const std::vector<int>& CWidgetsInfo::GetCO() { return m_arrCO; }
+const std::vector< std::pair<int, int> >& CWidgetsInfo::GetCO() { return m_arrCO; }
 const std::vector<std::wstring>& CWidgetsInfo::GetButtonImg() { return m_arrButtonImg; }
 const std::vector<CWidgetsInfo::CParent*>& CWidgetsInfo::GetParents() { return m_arrParents; }
+void CWidgetsInfo::ChangeCO(int i, int nNum, int nGen)
+{
+	if (i < 0 || i > m_arrCO.size() - 1)
+		return;
+	m_arrCO[i] = std::make_pair(nNum, nGen);
+}
 bool CWidgetsInfo::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMetafileToRenderter* pCorrector)
 {
 	int n = pReader->ReadInt();
+	m_arrCO.reserve(n);
 	for (int i = 0; i < n; ++i)
-		m_arrCO.push_back(pReader->ReadInt());
+		m_arrCO.push_back(std::make_pair(pReader->ReadInt(), -1));
 
 	n = pReader->ReadInt();
+	m_arrParents.reserve(n);
 	for (int i = 0; i < n; ++i)
 	{
 		CParent* pParent = new CParent();
@@ -1077,6 +1100,7 @@ bool CWidgetsInfo::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMetafil
 		if (nFlags & (1 << 3))
 		{
 			int n = pReader->ReadInt();
+			pParent->arrI.reserve(n);
 			for (int i = 0; i < n; ++i)
 				pParent->arrI.push_back(pReader->ReadInt());
 		}
@@ -1085,13 +1109,45 @@ bool CWidgetsInfo::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMetafil
 		if (nFlags & (1 << 5))
 		{
 			int n = pReader->ReadInt();
+			pParent->arrV.reserve(n);
 			for (int i = 0; i < n; ++i)
 				pParent->arrV.push_back(pReader->ReadString());
 		}
+		if (nFlags & (1 << 6))
+		{
+			int n = pReader->ReadInt();
+			pParent->arrOpt.reserve(n);
+			for (int i = 0; i < n; ++i)
+			{
+				std::wstring s1 = pReader->ReadString();
+				std::wstring s2 = pReader->ReadString();
+				pParent->arrOpt.push_back(std::make_pair(s1, s2));
+			}
+		}
+		if (nFlags & (1 << 7))
+			pParent->nFieldFlag = pReader->ReadInt();
+		if (nFlags & (1 << 8))
+		{
+			// Action
+			int nAction = pReader->ReadInt();
+			for (int i = 0; i < nAction; ++i)
+			{
+				std::wstring wsType = pReader->ReadString();
+				CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget* pA = ReadAction(pReader);
+				if (pA)
+				{
+					pA->wsType = wsType;
+					pParent->arrAction.push_back(pA);
+				}
+			}
+		}
+		if (nFlags & (1 << 9))
+			pParent->nMaxLen = pReader->ReadInt();
 		m_arrParents.push_back(pParent);
 	}
 
 	n = pReader->ReadInt();
+	m_arrButtonImg.reserve(n);
 	for (int i = 0; i < n; ++i)
 	{
 		std::string sImagePath = pReader->ReadStringA();

DesktopEditor/graphics/commands/AnnotField.h

@@ -39,6 +39,36 @@ class IMetafileToRenderter;
 class GRAPHICS_DECL CAnnotFieldInfo : public IAdvancedCommand
 {
 public:
+	enum EAnnotType
+	{
+		Unknown = -1,
+		Text = 0,
+		Link = 1,
+		FreeText = 2,
+		Line = 3,
+		Square = 4,
+		Circle = 5,
+		PolygonLine = 6,
+		PolyLine = 7,
+		Highlight = 8,
+		Underline = 9,
+		Squiggly = 10,
+		Strikeout = 11,
+		Stamp = 12,
+		Caret = 13,
+		Ink = 14,
+		Popup = 15,
+		FileAttachment = 16,
+		Widget = 26,
+		WidgetPushButton = 27,
+		WidgetRadioButton = 28,
+		WidgetCheckBox = 29,
+		WidgetText = 30,
+		WidgetCombobox = 31,
+		WidgetListbox = 32,
+		WidgetSignature = 33
+	};
+
 	class GRAPHICS_DECL CWidgetAnnotPr
 	{
 	public:
@@ -164,6 +194,7 @@ public:
 		const std::wstring& GetT();
 		const std::wstring& GetFontName();
 		const std::wstring& GetFontKey();
+		const std::wstring& GetOMetadata();
 		const std::vector<double>& GetTC();
 		const std::vector<double>& GetBC();
 		const std::vector<double>& GetBG();
@@ -193,6 +224,7 @@ public:
 		std::wstring m_wsT;
 		std::wstring m_wsFN;
 		std::wstring m_wsFK;
+		std::wstring m_wsOMetadata;
 		std::vector<double> m_arrTC;
 		std::vector<double> m_arrBC;
 		std::vector<double> m_arrBG;
@@ -423,7 +455,9 @@ public:
 	CAnnotFieldInfo();
 	virtual ~CAnnotFieldInfo();
 
+	void CreateMarkup();
 	void SetType(int nType);
+	EAnnotType GetType();
 
 	void  GetBounds(double& dX1, double& dY1, double& dX2, double& dY2);
 	void  GetBorder(BYTE& nType, double& dWidth, std::vector<double>& arrDash);
@@ -431,6 +465,7 @@ public:
 	int   GetID()        const;
 	int   GetAnnotFlag() const;
 	int   GetPage()      const;
+	int   GetCopyAP()    const;
 	void  GetBE(BYTE& nS, double& dI);
 	BYTE* GetRender(LONG& nLen);
 	const std::wstring& GetNM();
@@ -479,7 +514,7 @@ private:
 		std::vector<double> arrDash;
 	};
 
-	int          m_nType;
+	EAnnotType   m_nType;
 	double       m_dX1;
 	double       m_dY1;
 	double       m_dX2;
@@ -488,6 +523,7 @@ private:
 	int          m_nID;
 	int          m_nAnnotFlag;
 	int          m_nPage;
+	int          m_nCopyAP;
 	std::wstring m_wsNM;
 	std::wstring m_wsLM;
 	std::wstring m_wsOUserID;
@@ -533,25 +569,31 @@ public:
 	{
 		int nID;
 		int nFlags;
+		int nMaxLen;
 		int nParentID;
+		int nFieldFlag;
 		std::wstring sName;
 		std::wstring sV;
 		std::wstring sDV;
 		std::vector<int> arrI;
 		std::vector<std::wstring> arrV;
+		std::vector<CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget*> arrAction;
+		std::vector< std::pair<std::wstring, std::wstring> > arrOpt;
 	};
 
 	CWidgetsInfo();
 	virtual ~CWidgetsInfo();
 
-	const std::vector<int>& GetCO();
+	const std::vector< std::pair<int, int> >& GetCO();
 	const std::vector<std::wstring>& GetButtonImg();
 	const std::vector<CParent*>& GetParents();
 
+	void ChangeCO(int i, int nNum, int nGen);
+
 	bool Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMetafileToRenderter* pCorrector);
 
 private:
-	std::vector<int> m_arrCO;
+	std::vector< std::pair<int, int> > m_arrCO;
 	std::vector<std::wstring> m_arrButtonImg;
 	std::vector<CParent*> m_arrParents;
 };

DesktopEditor/graphics/pro/js/deploy.py

@@ -7,7 +7,7 @@ import os
 
 base.configure_common_apps()
 
-base.cmd_in_dir("./../../../../../core/Common/js", "make.py", ["./../../DesktopEditor/graphics/pro/js/drawingfile.json"])
+base.cmd_in_dir("./../../../../../core/Common/js", sys.executable, ["make.py", "./../../DesktopEditor/graphics/pro/js/drawingfile.json"])
 
 src_dir = "./deploy/"
 dst_dir = "./../../../../../sdkjs/pdf/src/engine/"

DesktopEditor/graphics/pro/js/drawingfile.json

@@ -51,6 +51,9 @@
 		"_IsNeedCMap",
 		"_SetCMapData",
 		"_ScanPage",
+		"_SplitPages",
+		"_MergePages",
+		"_UnmergePages",
 		"_GetImageBase64",
 		"_GetImageBase64Len",
 		"_GetImageBase64Ptr",
@@ -67,6 +70,7 @@
 		"../../../../PdfFile/lib/goo", "../../../../PdfFile/lib/fofi", "../../../../PdfFile/lib/splash", "../../../../PdfFile/lib", 
 		"../../../raster/Jp2/openjpeg", "../../../raster/Jp2/openjpeg/openjpeg-2.4.0/src/lib/openjp2", 
 		"../../../../Common/3dParty/openssl/openssl/include", 
+		"../../../../Common/3dParty/openssl/build/linux_64/include", 
 		"../../../../DocxRenderer"
 	],
 	"define": [
@@ -86,7 +90,7 @@
 		"NO_CONSOLE_IO", "USE_EXTERNAL_JPEG2000", "USE_JPIP", "OPJ_STATIC", "FONT_ENGINE_DISABLE_FILESYSTEM",
 		"IMAGE_CHECKER_DISABLE_XML",
 		"USE_OPENSSL_HASH",
-		"DISABLE_FULL_DOCUMENT_CREATION", "DISABLE_FILESYSTEM"
+		"DISABLE_FULL_DOCUMENT_CREATION", "DISABLE_FILESYSTEM", "CRYPTOPP_DISABLE_ASM", "DISABLE_TYPE_MISMATCH"
 	],
 	"compile_files_array": [
 	{
@@ -135,7 +139,7 @@
 	},
 	{
 		"folder": "./wasm/src/",
-		"files": ["lib/wasm_jmp.cpp", "drawingfile.cpp", "metafile.cpp", "pdfwriter.cpp", "HTMLRendererText.cpp"]
+		"files": ["lib/wasm_jmp.cpp", "drawingfile.cpp", "metafile.cpp", "HTMLRendererText.cpp"]
 	},
 	{
 		"folder": "freetype-2.10.4/src/",
@@ -143,7 +147,7 @@
 	},
 	{
 		"folder": "../../",
-		"files": ["GraphicsRenderer.cpp", "pro/pro_Graphics.cpp", "pro/pro_Fonts.cpp", "pro/pro_Image.cpp", "Graphics.cpp", "Brush.cpp", "BaseThread.cpp", "GraphicsPath.cpp", "BooleanOperations.cpp", "Image.cpp", "Matrix.cpp", "Clip.cpp", "TemporaryCS.cpp", "AlphaMask.cpp", "GraphicsLayer.cpp", "commands/DocInfo.cpp", "commands/AnnotField.cpp", "commands/FormField.cpp"]
+		"files": ["GraphicsRenderer.cpp", "pro/pro_Graphics.cpp", "pro/pro_Fonts.cpp", "pro/pro_Image.cpp", "Graphics.cpp", "Brush.cpp", "BaseThread.cpp", "GraphicsPath.cpp", "BooleanOperations.cpp", "Image.cpp", "Matrix.cpp", "Clip.cpp", "TemporaryCS.cpp", "AlphaMask.cpp", "GraphicsLayer.cpp", "commands/DocInfo.cpp", "commands/AnnotField.cpp", "commands/FormField.cpp", "MetafileToRenderer.cpp", "MetafileToRendererReader.cpp"]
 	},
 	{
 		"folder": "../../../fontengine/",
@@ -155,12 +159,16 @@
 	},
 	{
 		"folder": "../../../common/",
-		"files": ["File.cpp", "Directory.cpp", "ByteBuilder.cpp", "Base64.cpp", "StringExt.cpp", "Path.cpp"]
+		"files": ["File.cpp", "Directory.cpp", "ByteBuilder.cpp", "Base64.cpp", "StringExt.cpp", "Path.cpp", "SystemUtils.cpp"]
 	},
 	{
 		"folder": "../../../../Common/3dParty/icu/icu/source/common/",
 		"files": ["ucnv.c", "ustr_wcs.cpp", "ucnv_err.c", "ucnv_bld.cpp", "ustrtrns.cpp", "ucnv_cb.c", "udata.cpp", "ucnv_io.cpp", "uhash.c", "udatamem.c", "cmemory.c", "ustring.cpp", "umutex.cpp", "putil.cpp", "ustr_cnv.cpp", "ucnvmbcs.cpp", "ucnvlat1.c", "ucnv_u16.c", "ucnv_u8.c", "ucnv_u32.c", "ucnv_u7.c", "ucln_cmn.cpp", "ucnv2022.cpp", "ucnv_lmb.c", "ucnvhz.c", "ucnvscsu.c", "ucnvisci.c", "ucnvbocu.cpp", "ucnv_ct.c", "ucnv_cnv.c", "stringpiece.cpp", "charstr.cpp", "umapfile.c", "ucmndata.c", "ucnv_ext.cpp", "uobject.cpp", "umath.c", "ubidi_props.c", "uchar.c", "uinvchar.c", "usprep.cpp", "unistr.cpp", "uniset_props.cpp", "loadednormalizer2impl.cpp", "filterednormalizer2.cpp", "utrie2.cpp", "normalizer2.cpp", "normalizer2impl.cpp", "utrie.cpp", "ucase.cpp", "uniset.cpp", "ruleiter.cpp", "parsepos.cpp", "util.cpp", "uprops.cpp", "uvector.cpp", "unames.cpp", "propname.cpp", "utrie2_builder.cpp", "unifunct.cpp", "bmpset.cpp", "unisetspan.cpp", "unifilt.cpp", "patternprops.cpp", "utf_impl.c", "ustrcase.cpp", "cstring.c", "bytestrie.cpp"]
 	},
+	{
+		"folder": "../../../../Common/3dParty/cryptopp/",
+		"files": ["cryptlib.cpp", "cpu.cpp", "integer.cpp", "3way.cpp", "adler32.cpp", "algebra.cpp", "algparam.cpp", "allocate.cpp", "arc4.cpp", "aria.cpp", "aria_simd.cpp", "ariatab.cpp", "asn.cpp", "authenc.cpp", "base32.cpp", "base64.cpp", "basecode.cpp", "bfinit.cpp", "blake2.cpp", "blake2s_simd.cpp", "blake2b_simd.cpp", "blowfish.cpp", "blumshub.cpp", "camellia.cpp", "cast.cpp", "casts.cpp", "cbcmac.cpp", "ccm.cpp", "chacha.cpp", "chacha_simd.cpp", "chacha_avx.cpp", "chachapoly.cpp", "cham.cpp", "cham_simd.cpp", "channels.cpp", "cmac.cpp", "crc.cpp", "crc_simd.cpp", "darn.cpp", "default.cpp", "des.cpp", "dessp.cpp", "dh.cpp", "dh2.cpp", "dll.cpp", "donna_32.cpp", "donna_64.cpp", "donna_sse.cpp", "dsa.cpp", "eax.cpp", "ec2n.cpp", "ecp.cpp", "eccrypto.cpp", "eprecomp.cpp", "elgamal.cpp", "emsa2.cpp", "eprecomp.cpp", "esign.cpp", "files.cpp", "filters.cpp", "fips140.cpp", "gcm.cpp", "gcm_simd.cpp", "gf256.cpp", "gf2_32.cpp", "gf2n.cpp", "gf2n_simd.cpp", "gfpcrypt.cpp", "gost.cpp", "gzip.cpp", "hc128.cpp", "hc256.cpp", "hex.cpp", "hight.cpp", "hmac.cpp", "hrtimer.cpp", "ida.cpp", "idea.cpp", "iterhash.cpp", "kalyna.cpp", "md5.cpp", "randpool.cpp", "osrng.cpp", "rijndael.cpp", "modes.cpp", "misc.cpp", "rdtables.cpp", "sha.cpp", "mqueue.cpp", "queue.cpp"]
+	},
 	{
 		"folder": "../../../../OfficeUtils/src/",
 		"files": ["OfficeUtils.cpp", "ZipBuffer.cpp", "ZipUtilsCP.cpp", "zlib_addon.c"]
@@ -179,7 +187,23 @@
 	},
 	{
 		"folder": "../../../../PdfFile/",
-		"files": ["SrcReader/Adaptors.cpp", "SrcReader/GfxClip.cpp", "SrcReader/RendererOutputDev.cpp", "SrcReader/JPXStream2.cpp", "SrcReader/PdfAnnot.cpp", "Resources/BaseFonts.cpp", "Resources/CMapMemory/cmap_memory.cpp", "lib/fofi/FofiBase.cc", "lib/fofi/FofiEncodings.cc", "lib/fofi/FofiIdentifier.cc", "lib/fofi/FofiTrueType.cc", "lib/fofi/FofiType1.cc", "lib/fofi/FofiType1C.cc", "lib/goo/FixedPoint.cc", "lib/goo/gfile.cc", "lib/goo/GHash.cc", "lib/goo/GList.cc", "lib/goo/gmem.cc", "lib/goo/gmempp.cc", "lib/goo/GString.cc", "lib/goo/parseargs.c", "lib/goo/Trace.cc", "lib/splash/Splash.cc", "lib/splash/SplashBitmap.cc", "lib/splash/SplashClip.cc", "lib/splash/SplashFont.cc", "lib/splash/SplashFontEngine.cc", "lib/splash/SplashFontFile.cc", "lib/splash/SplashFontFileID.cc", "lib/splash/SplashFTFont.cc", "lib/splash/SplashFTFontEngine.cc", "lib/splash/SplashFTFontFile.cc", "lib/splash/SplashPath.cc", "lib/splash/SplashPattern.cc", "lib/splash/SplashScreen.cc", "lib/splash/SplashState.cc", "lib/splash/SplashXPath.cc", "lib/splash/SplashXPathScanner.cc", "lib/xpdf/AcroForm.cc", "lib/xpdf/Annot.cc", "lib/xpdf/Array.cc", "lib/xpdf/BuiltinFont.cc", "lib/xpdf/BuiltinFontTables.cc", "lib/xpdf/Catalog.cc", "lib/xpdf/CharCodeToUnicode.cc", "lib/xpdf/CMap.cc", "lib/xpdf/Decrypt.cc", "lib/xpdf/Dict.cc", "lib/xpdf/DisplayState.cc", "lib/xpdf/Error.cc", "lib/xpdf/FontEncodingTables.cc", "lib/xpdf/Function.cc", "lib/xpdf/Gfx.cc", "lib/xpdf/GfxFont.cc", "lib/xpdf/GfxState.cc", "lib/xpdf/GlobalParams.cc", "lib/xpdf/ImageOutputDev.cc", "lib/xpdf/JArithmeticDecoder.cc", "lib/xpdf/JBIG2Stream.cc", "lib/xpdf/JPXStream.cc", "lib/xpdf/Lexer.cc", "lib/xpdf/Link.cc", "lib/xpdf/NameToCharCode.cc", "lib/xpdf/Object.cc", "lib/xpdf/OptionalContent.cc", "lib/xpdf/Outline.cc", "lib/xpdf/OutputDev.cc", "lib/xpdf/Page.cc", "lib/xpdf/Parser.cc", "lib/xpdf/PDF417Barcode.cc", "lib/xpdf/PDFCore.cc", "lib/xpdf/PDFDoc.cc", "lib/xpdf/PDFDocEncoding.cc", "lib/xpdf/PreScanOutputDev.cc", "lib/xpdf/PSOutputDev.cc", "lib/xpdf/PSTokenizer.cc", "lib/xpdf/SecurityHandler.cc", "lib/xpdf/ShadingImage.cc", "lib/xpdf/SplashOutputDev.cc", "lib/xpdf/Stream.cc", "lib/xpdf/TextOutputDev.cc", "lib/xpdf/TextString.cc", "lib/xpdf/TileCache.cc", "lib/xpdf/TileCompositor.cc", "lib/xpdf/TileMap.cc", "lib/xpdf/UnicodeMap.cc", "lib/xpdf/UnicodeRemapping.cc", "lib/xpdf/UnicodeTypeTable.cc", "lib/xpdf/UTF8.cc", "lib/xpdf/WebFont.cc", "lib/xpdf/XFAScanner.cc", "lib/xpdf/XRef.cc", "lib/xpdf/Zoox.cc", "PdfFile.cpp", "PdfReader.cpp"]
+		"files": ["PdfFile.cpp", "PdfReader.cpp", "PdfWriter.cpp", "PdfEditor.cpp", "OnlineOfficeBinToPdf.cpp"]
+	},
+	{
+		"folder": "../../../../PdfFile/SrcReader/",
+		"files": ["Adaptors.cpp", "GfxClip.cpp", "RendererOutputDev.cpp", "JPXStream2.cpp", "PdfAnnot.cpp"]
+	},
+	{
+		"folder": "../../../../PdfFile/SrcWriter/",
+		"files": ["AcroForm.cpp", "Annotation.cpp", "Catalog.cpp", "Destination.cpp", "Document.cpp", "Encrypt.cpp", "EncryptDictionary.cpp", "Field.cpp", "Font.cpp", "Font14.cpp", "FontCidTT.cpp", "FontTT.cpp", "FontTTWriter.cpp", "GState.cpp", "Image.cpp", "Info.cpp", "Metadata.cpp", "Objects.cpp", "Outline.cpp", "Pages.cpp", "Pattern.cpp", "ResourcesDictionary.cpp", "Shading.cpp", "States.cpp", "Streams.cpp", "Utils.cpp"]
+	},
+	{
+		"folder": "../../../../PdfFile/Resources/",
+		"files": ["BaseFonts.cpp", "CMapMemory/cmap_memory.cpp"]
+	},
+	{
+		"folder": "../../../../PdfFile/lib/",
+		"files": ["fofi/FoFiBase.cc", "fofi/FoFiEncodings.cc", "fofi/FoFiIdentifier.cc", "fofi/FoFiTrueType.cc", "fofi/FoFiType1.cc", "fofi/FoFiType1C.cc", "goo/FixedPoint.cc", "goo/gfile.cc", "goo/GHash.cc", "goo/GList.cc", "goo/gmem.cc", "goo/gmempp.cc", "goo/GString.cc", "goo/parseargs.c", "goo/Trace.cc", "splash/Splash.cc", "splash/SplashBitmap.cc", "splash/SplashClip.cc", "splash/SplashFont.cc", "splash/SplashFontEngine.cc", "splash/SplashFontFile.cc", "splash/SplashFontFileID.cc", "splash/SplashFTFont.cc", "splash/SplashFTFontEngine.cc", "splash/SplashFTFontFile.cc", "splash/SplashPath.cc", "splash/SplashPattern.cc", "splash/SplashScreen.cc", "splash/SplashState.cc", "splash/SplashXPath.cc", "splash/SplashXPathScanner.cc", "xpdf/AcroForm.cc", "xpdf/Annot.cc", "xpdf/Array.cc", "xpdf/BuiltinFont.cc", "xpdf/BuiltinFontTables.cc", "xpdf/Catalog.cc", "xpdf/CharCodeToUnicode.cc", "xpdf/CMap.cc", "xpdf/Decrypt.cc", "xpdf/Dict.cc", "xpdf/DisplayState.cc", "xpdf/Error.cc", "xpdf/FontEncodingTables.cc", "xpdf/Function.cc", "xpdf/Gfx.cc", "xpdf/GfxFont.cc", "xpdf/GfxState.cc", "xpdf/GlobalParams.cc", "xpdf/ImageOutputDev.cc", "xpdf/JArithmeticDecoder.cc", "xpdf/JBIG2Stream.cc", "xpdf/JPXStream.cc", "xpdf/Lexer.cc", "xpdf/Link.cc", "xpdf/NameToCharCode.cc", "xpdf/Object.cc", "xpdf/OptionalContent.cc", "xpdf/Outline.cc", "xpdf/OutputDev.cc", "xpdf/Page.cc", "xpdf/Parser.cc", "xpdf/PDF417Barcode.cc", "xpdf/PDFCore.cc", "xpdf/PDFDoc.cc", "xpdf/PDFDocEncoding.cc", "xpdf/PreScanOutputDev.cc", "xpdf/PSOutputDev.cc", "xpdf/PSTokenizer.cc", "xpdf/SecurityHandler.cc", "xpdf/ShadingImage.cc", "xpdf/SplashOutputDev.cc", "xpdf/Stream.cc", "xpdf/TextOutputDev.cc", "xpdf/TextString.cc", "xpdf/TileCache.cc", "xpdf/TileCompositor.cc", "xpdf/TileMap.cc", "xpdf/UnicodeMap.cc", "xpdf/UnicodeRemapping.cc", "xpdf/UnicodeTypeTable.cc", "xpdf/UTF8.cc", "xpdf/WebFont.cc", "xpdf/XFAScanner.cc", "xpdf/XRef.cc", "xpdf/Zoox.cc"]
 	},
 	{
 		"folder": "../../../raster/Jp2/openjpeg/openjpeg-2.4.0/src/lib/openjp2/",
@@ -223,7 +247,7 @@
 	},
 	{
 		"folder": "../../../../DocxRenderer/src/logic/elements",
-		"files": ["BaseItem.cpp", "ContText.cpp", "Paragraph.cpp", "Shape.cpp", "TextLine.cpp"]
+		"files": ["BaseItem.cpp", "ContText.cpp", "Paragraph.cpp", "Shape.cpp", "TextLine.cpp", "Table.cpp"]
 	},
 	{
 		"folder": "../../../common",

DesktopEditor/graphics/pro/js/qt/nativegraphics.pro

@@ -619,10 +619,7 @@ INCLUDEPATH += \
 	$$PDF_ROOT_DIR/lib/splash \
 	$$PDF_ROOT_DIR/lib
 
-HEADERS += \
-	$$PDF_ROOT_DIR/lib/aconf.h \
-	$$$files($$PDF_ROOT_DIR/lib/*.h)
-
+HEADERS += $$files($$PDF_ROOT_DIR/lib/*.h, true)
 SOURCES += $$files($$PDF_ROOT_DIR/lib/*.c, true)
 SOURCES += $$files($$PDF_ROOT_DIR/lib/*.cc, true)
 
@@ -644,9 +641,7 @@ SOURCES += \
 	$$PDF_ROOT_DIR/SrcReader/GfxClip.cpp \
 	$$PDF_ROOT_DIR/SrcReader/PdfAnnot.cpp \
 	$$PDF_ROOT_DIR/Resources/BaseFonts.cpp \
-	$$PDF_ROOT_DIR/Resources/CMapMemory/cmap_memory.cpp \
-	$$PDF_ROOT_DIR/PdfReader.cpp \
-	$$PDF_ROOT_DIR/PdfFile.cpp
+	$$PDF_ROOT_DIR/Resources/CMapMemory/cmap_memory.cpp
 
 HEADERS +=\
 	$$PDF_ROOT_DIR/Resources/Fontd050000l.h \
@@ -670,9 +665,87 @@ HEADERS +=\
 	$$PDF_ROOT_DIR/SrcReader/MemoryUtils.h \
 	$$PDF_ROOT_DIR/SrcReader/GfxClip.h \
 	$$PDF_ROOT_DIR/SrcReader/FontsWasm.h \
-	$$PDF_ROOT_DIR/SrcReader/PdfAnnot.h \
+	$$PDF_ROOT_DIR/SrcReader/PdfAnnot.h
+
+DEFINES += CRYPTOPP_DISABLE_ASM
+LIBS += -L$$CORE_BUILDS_LIBRARIES_PATH -lCryptoPPLib
+
+# PdfWriter
+HEADERS += \
+	$$PDF_ROOT_DIR/SrcWriter/AcroForm.h \
+	$$PDF_ROOT_DIR/SrcWriter/Annotation.h \
+	$$PDF_ROOT_DIR/SrcWriter/Catalog.h \
+	$$PDF_ROOT_DIR/SrcWriter/Consts.h \
+	$$PDF_ROOT_DIR/SrcWriter/Destination.h \
+	$$PDF_ROOT_DIR/SrcWriter/Document.h \
+	$$PDF_ROOT_DIR/SrcWriter/Encodings.h \
+	$$PDF_ROOT_DIR/SrcWriter/Encrypt.h \
+	$$PDF_ROOT_DIR/SrcWriter/EncryptDictionary.h \
+	$$PDF_ROOT_DIR/SrcWriter/Field.h \
+	$$PDF_ROOT_DIR/SrcWriter/Font.h \
+	$$PDF_ROOT_DIR/SrcWriter/Font14.h \
+	$$PDF_ROOT_DIR/SrcWriter/FontCidTT.h \
+	$$PDF_ROOT_DIR/SrcWriter/FontTT.h \
+	$$PDF_ROOT_DIR/SrcWriter/FontTTWriter.h \
+	$$PDF_ROOT_DIR/SrcWriter/GState.h \
+	$$PDF_ROOT_DIR/SrcWriter/Image.h \
+	$$PDF_ROOT_DIR/SrcWriter/Info.h \
+	$$PDF_ROOT_DIR/SrcWriter/Objects.h \
+	$$PDF_ROOT_DIR/SrcWriter/Outline.h \
+	$$PDF_ROOT_DIR/SrcWriter/Pages.h \
+	$$PDF_ROOT_DIR/SrcWriter/Pattern.h \
+	$$PDF_ROOT_DIR/SrcWriter/ResourcesDictionary.h \
+	$$PDF_ROOT_DIR/SrcWriter/Shading.h \
+	$$PDF_ROOT_DIR/SrcWriter/Streams.h \
+	$$PDF_ROOT_DIR/SrcWriter/Types.h \
+	$$PDF_ROOT_DIR/SrcWriter/Utils.h \
+	$$PDF_ROOT_DIR/SrcWriter/Metadata.h \
+	$$PDF_ROOT_DIR/SrcWriter/ICCProfile.h \
+	$$PDF_ROOT_DIR/SrcWriter/States.h
+
+SOURCES += \
+	$$PDF_ROOT_DIR/SrcWriter/AcroForm.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Annotation.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Catalog.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Destination.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Document.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Encrypt.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/EncryptDictionary.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Field.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Font.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Font14.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/FontCidTT.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/FontTT.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/FontTTWriter.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/GState.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Image.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Info.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Objects.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Outline.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Pages.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Pattern.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/ResourcesDictionary.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Shading.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Streams.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Utils.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/Metadata.cpp \
+	$$PDF_ROOT_DIR/SrcWriter/States.cpp
+
+# PdfFile
+
+HEADERS += \
+	$$PDF_ROOT_DIR/PdfFile.h \
+	$$PDF_ROOT_DIR/PdfWriter.h \
 	$$PDF_ROOT_DIR/PdfReader.h \
-	$$PDF_ROOT_DIR/PdfFile.h
+	$$PDF_ROOT_DIR/PdfEditor.h \
+	$$PDF_ROOT_DIR/OnlineOfficeBinToPdf.h
+
+SOURCES += \
+	$$PDF_ROOT_DIR/PdfFile.cpp \
+	$$PDF_ROOT_DIR/PdfWriter.cpp \
+	$$PDF_ROOT_DIR/PdfReader.cpp \
+	$$PDF_ROOT_DIR/PdfEditor.cpp \
+	$$PDF_ROOT_DIR/OnlineOfficeBinToPdf.cpp
 
 # DocxRenderer
 DOCX_RENDERER_ROOT_DIR = $$CORE_ROOT_DIR/DocxRenderer
@@ -682,6 +755,7 @@ HEADERS += \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/DropCap.h \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/Paragraph.h \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/Shape.h \
+	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/Table.h \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/TextLine.h \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/managers/ExternalImageStorage.h \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/managers/FontStyleManager.h \
@@ -706,6 +780,7 @@ SOURCES += \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/ContText.cpp \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/Paragraph.cpp \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/Shape.cpp \
+	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/Table.cpp \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/TextLine.cpp \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/managers/FontManager.cpp \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/managers/FontStyleManager.cpp \
@@ -727,7 +802,6 @@ HEADERS += \
 	../wasm/src/Text.h
 
 SOURCES += \
-	../wasm/src/pdfwriter.cpp \
 	../wasm/src/HTMLRendererText.cpp \
 	../wasm/src/drawingfile.cpp \
 	../wasm/src/drawingfile_test.cpp

DesktopEditor/graphics/pro/js/qt/raster/pro_Fonts_empty.cpp

@@ -1,5 +1,5 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * (c) Copyright Ascensio System SIA 2010-2024
  *
  * 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)

DesktopEditor/graphics/pro/js/qt/raster/pro_Graphics_empty.cpp

@@ -1,5 +1,5 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * (c) Copyright Ascensio System SIA 2010-2024
  *
  * 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)

DesktopEditor/graphics/pro/js/wasm/js/drawingfile_native.js

@@ -42,6 +42,19 @@ CNativePointer.prototype.free = function()
 		g_native_drawing_file["FreeWasmData"](this.ptr);
 	this.ptr = null;
 };
+CNativePointer.prototype.getMemory = function(isCopy)
+{
+	if (!this.ptr)
+		return null;
+
+	if (!isCopy)
+		return this.ptr;
+
+	let copyArray = new Uint8Array(this.ptr.length);
+	copyArray.set(this.ptr);
+
+	return copyArray;
+};
 CNativePointer.prototype.getReader = function()
 {
 	if (!this.ptr)
@@ -94,6 +107,34 @@ CFile.prototype._getError = function()
 	return g_native_drawing_file["GetErrorCode"]();
 };
 
+CFile.prototype._SplitPages = function(pages, changes)
+{
+	let dataChanges = null;
+	if (changes) 
+		dataChanges = (undefined !== changes.byteLength) ? new Uint8Array(changes) : changes;
+	g_module_pointer.ptr = g_native_drawing_file["SplitPages"](pages, dataChanges);
+	return g_module_pointer;
+};
+
+CFile.prototype._MergePages = function(buffer, maxID, prefixForm)
+{
+	if (!buffer)
+		return false;
+
+	if (!maxID)
+		maxID = 0;
+	if (!prefixForm)
+		prefixForm = "";
+
+	let data = (undefined !== buffer.byteLength) ? new Uint8Array(buffer) : buffer;
+	return g_native_drawing_file["MergePages"](data, maxID, prefixForm);
+};
+
+CFile.prototype._UndoMergePages = function()
+{
+	return g_native_drawing_file["UnmergePages"]();
+};
+
 // FONTS
 CFile.prototype._isNeedCMap = function()
 {

DesktopEditor/graphics/pro/js/wasm/js/drawingfile_wasm.js

@@ -39,7 +39,7 @@ CWasmPointer.prototype.free = function()
 	Module["_free"](this.ptr);
 	this.ptr = 0;
 };
-CWasmPointer.prototype.getReader = function()
+CWasmPointer.prototype.getMemory = function(isCopy)
 {
 	if (!this.ptr)
 		return null;
@@ -59,8 +59,23 @@ CWasmPointer.prototype.getReader = function()
 	}
 
 	len -= 4;
-	let buffer = new Uint8Array(Module["HEAP8"].buffer, this.ptr + 4, len);
-	return new CBinaryReader(buffer, 0, len);
+	
+	let noCopyArray = new Uint8Array(Module["HEAP8"].buffer, this.ptr + 4, len);
+	if (!isCopy)
+		return noCopyArray;
+
+	let copyArray = new Uint8Array(len);
+	copyArray.set(noCopyArray);
+
+	return copyArray;
+};
+CWasmPointer.prototype.getReader = function()
+{
+	let noCopyArray = this.getMemory(false);
+	if (!noCopyArray)
+		return null;
+	
+	return new CBinaryReader(noCopyArray, 0, noCopyArray.length);
 };
 
 var g_module_pointer = new CWasmPointer();
@@ -86,8 +101,9 @@ CFile.prototype._openFile = function(buffer, password)
 	{
 		let data = new Uint8Array(buffer);
 		this.stream_size = data.length;
-		this.stream = Module["_malloc"](this.stream_size);
-		Module["HEAP8"].set(data, this.stream);
+		let stream = Module["_malloc"](this.stream_size);
+		Module["HEAP8"].set(data, stream);
+		this.stream.push(stream);
 	}
 
 	let passwordPtr = 0;
@@ -98,7 +114,7 @@ CFile.prototype._openFile = function(buffer, password)
 		Module["HEAP8"].set(passwordBuf, passwordPtr);
 	}
 
-	this.nativeFile = Module["_Open"](this.stream, this.stream_size, passwordPtr);
+	this.nativeFile = Module["_Open"](this.stream[0], this.stream_size, passwordPtr);
 
 	if (passwordPtr)
 		Module["_free"](passwordPtr);
@@ -112,7 +128,7 @@ CFile.prototype._closeFile = function()
 
 CFile.prototype._getType = function()
 {
-	return Module["_GetType"](this.stream, this.stream_size);
+	return Module["_GetType"](this.stream[0], this.stream_size);
 };
 
 CFile.prototype._getError = function()
@@ -120,6 +136,72 @@ CFile.prototype._getError = function()
 	return Module["_GetErrorCode"](this.nativeFile);
 };
 
+CFile.prototype._SplitPages = function(memoryBuffer, arrayBufferChanges)
+{
+	let changesPtr = 0;
+	let changesLen = 0;
+	if (arrayBufferChanges)
+	{
+		let changes = new Uint8Array(arrayBufferChanges);
+		changesLen = changes.length;
+		changesPtr = Module["_malloc"](changesLen);
+		Module["HEAP8"].set(changes, changesPtr);
+	}
+
+	let pointer = Module["_malloc"](memoryBuffer.length * 4);
+	Module["HEAP32"].set(memoryBuffer, pointer >> 2);
+	let ptr = Module["_SplitPages"](this.nativeFile, pointer, memoryBuffer.length, changesPtr, changesLen);
+	Module["_free"](pointer);
+	if (changesPtr)
+		Module["_free"](changesPtr);
+
+	g_module_pointer.ptr = ptr;
+	return g_module_pointer;
+};
+
+CFile.prototype._MergePages = function(buffer, maxID, prefixForm)
+{
+	if (!buffer)
+		return false;
+
+	let data = (undefined !== buffer.byteLength) ? new Uint8Array(buffer) : buffer;
+	let stream2 = Module["_malloc"](data.length);
+	Module["HEAP8"].set(data, stream2);
+
+	if (!maxID)
+		maxID = 0;
+
+	let prefixPtr = 0;
+	if (prefixForm)
+	{
+		let prefixBuf = prefixForm.toUtf8();
+		prefixPtr = Module["_malloc"](prefixBuf.length);
+		Module["HEAP8"].set(prefixBuf, prefixPtr);
+	}
+
+	let bRes = Module["_MergePages"](this.nativeFile, stream2, data.length, maxID, prefixPtr);
+	if (bRes == 1)
+		this.stream.push(stream2);
+	else
+		Module["_free"](stream2);
+
+	if (prefixPtr)
+		Module["_free"](prefixPtr);
+
+	return bRes == 1;
+};
+
+CFile.prototype._UndoMergePages = function()
+{
+	let bRes = Module["_UnmergePages"](this.nativeFile);
+	if (bRes == 1)
+	{
+		let str = this.stream.pop();
+		Module["_free"](str);
+	}
+	return bRes == 1;
+};
+
 // FONTS
 CFile.prototype._isNeedCMap = function()
 {

DesktopEditor/graphics/pro/js/wasm/js/stream.js

@@ -42,6 +42,12 @@ CBinaryReader.prototype.readByte = function()
 	this.pos += 1;
 	return val;
 };
+CBinaryReader.prototype.readShort = function()
+{
+	let val = this.data[this.pos] | this.data[this.pos + 1] << 8;
+	this.pos += 2;
+	return val;
+};
 CBinaryReader.prototype.readInt = function()
 {
 	let val = this.data[this.pos] | this.data[this.pos + 1] << 8 | this.data[this.pos + 2] << 16 | this.data[this.pos + 3] << 24;
@@ -56,6 +62,10 @@ CBinaryReader.prototype.readDouble2 = function()
 {
 	return this.readInt() / 10000;
 };
+CBinaryReader.prototype.readDouble3 = function()
+{
+	return this.readInt() / 100000;
+};
 CBinaryReader.prototype.readString = function()
 {
 	let len = this.readInt();
@@ -63,9 +73,20 @@ CBinaryReader.prototype.readString = function()
 	this.pos += len;
 	return val;
 };
+CBinaryReader.prototype.readString2 = function()
+{
+	let len = this.readShort();
+	let val = "";
+	for (let i = 0; i < len; ++i)
+	{
+		let c = this.readShort();
+		val += String.fromCharCode(c);
+	}
+	return val;
+};
 CBinaryReader.prototype.readData = function()
 {
-	let len = this.readInt();
+	let len = this.readInt() - 4;
 	let val = this.data.slice(this.pos, this.pos + len);
 	this.pos += len;
 	return val;

DesktopEditor/graphics/pro/js/wasm/src/drawingfile.cpp

@@ -125,7 +125,7 @@ WASM_EXPORT BYTE* GetGlyphs(CDrawingFile* pFile, int nPageIndex)
 {
 	return pFile->GetGlyphs(nPageIndex);
 }
-WASM_EXPORT BYTE* GetLinks  (CDrawingFile* pFile, int nPageIndex)
+WASM_EXPORT BYTE* GetLinks(CDrawingFile* pFile, int nPageIndex)
 {
 	return pFile->GetLinks(nPageIndex);
 }
@@ -177,6 +177,18 @@ WASM_EXPORT BYTE* ScanPage(CDrawingFile* pFile, int nPageIndex, int mode)
 {
 	return pFile->ScanPage(nPageIndex, mode);
 }
+WASM_EXPORT BYTE* SplitPages(CDrawingFile* pFile, int* arrPageIndex, int nLength, BYTE* data, LONG size)
+{
+	return pFile->SplitPages(arrPageIndex, nLength, data, size);
+}
+WASM_EXPORT int MergePages(CDrawingFile* pFile, BYTE* data, LONG size, int nMaxID, const char* sPrefixForm)
+{
+	return pFile->MergePages(data, size, nMaxID, sPrefixForm) ? 1 : 0;
+}
+WASM_EXPORT int UnmergePages(CDrawingFile* pFile)
+{
+	return pFile->UnmergePages() ? 1 : 0;
+}
 
 WASM_EXPORT void* GetImageBase64(CDrawingFile* pFile, int rId)
 {