fix bug #71673

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

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/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",
@@ -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 <= 0x1F),
+// 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(), [](char chValue){ return chValue <= 0x1F; });
+
+	while (itFound != text.end())
+	{
+		itFound = text.erase(itFound);
+		itFound = std::find_if(itFound, text.end(), [](char chValue){ return chValue <= 0x1F; });
+	}
+}
+
 // Заменяет сущности " в 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;");
 }
@@ -486,7 +501,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)
@@ -532,8 +547,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 +556,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 +569,7 @@ 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);
+			substitute_xml_entities_into_text(val);
 
 			// Избавление от FF
 			size_t found = val.find_first_of("\014");
@@ -613,7 +625,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 +637,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/OfficeFileFormatChecker.h

@@ -103,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)
@@ -786,6 +797,13 @@ 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)
@@ -816,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;
@@ -1150,6 +1172,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;
@@ -1159,58 +1185,222 @@ bool COfficeFileFormatChecker::isOnlyOfficeFormatFile(const std::wstring &fileNa
 	}
 	return false;
 }
-bool COfficeFileFormatChecker::isMacFormatFile(const std::wstring& fileName)
+
+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 nBufferSize = 0;
+	ULONG unSize = 0;
 	BYTE* pBuffer = NULL;
 
-	HRESULT hresult = OfficeUtils.LoadFileFromArchive(fileName, L"Index/Document.iwa", &pBuffer, nBufferSize);
-	if (hresult == S_OK && 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)
 	{
-		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_PAGES;
-
-		delete[] pBuffer;
-		pBuffer = NULL;
-
-		hresult = OfficeUtils.LoadFileFromArchive(fileName, L"Index/Slide.iwa", &pBuffer, nBufferSize);
-		if (hresult == S_OK && pBuffer != NULL)
+		if (0x08 == pBuffer[uPos] && 0x01 == pBuffer[uPos + 1])
 		{
-			delete[] pBuffer;
-			pBuffer = NULL;
-
-			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_KEY;
-			return true;
+			--uPos;
+			break;
 		}
-		hresult = OfficeUtils.LoadFileFromArchive(fileName, L"Index/Tables/DataList.iwa", &pBuffer, nBufferSize);
-		if (hresult == S_OK && pBuffer != NULL)
-		{
-			delete[] pBuffer;
-			pBuffer = NULL;
-
-			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_NUMBERS;
-			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;
-
-		return true;
 	}
-	return false;
+
+	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();
@@ -1496,6 +1686,8 @@ 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_SPREADSHEET_XLSX:
 		return L".xlsx";
@@ -1527,6 +1719,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:
@@ -1568,12 +1762,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:
@@ -1662,6 +1859,8 @@ 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".xlsx" == ext)
 		return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX;
@@ -1701,6 +1900,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;
@@ -1735,6 +1936,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;
@@ -1837,3 +2040,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

@@ -103,6 +103,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 +139,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
@@ -151,4 +154,4 @@
 #define AVS_OFFICESTUDIO_FILE_DRAW_VSTX					AVS_OFFICESTUDIO_FILE_DRAW + 0x0003
 #define AVS_OFFICESTUDIO_FILE_DRAW_VSDM					AVS_OFFICESTUDIO_FILE_DRAW + 0x0004
 #define AVS_OFFICESTUDIO_FILE_DRAW_VSSM					AVS_OFFICESTUDIO_FILE_DRAW + 0x0005
-#define AVS_OFFICESTUDIO_FILE_DRAW_VSTM					AVS_OFFICESTUDIO_FILE_DRAW + 0x0006
+#define AVS_OFFICESTUDIO_FILE_DRAW_VSTM					AVS_OFFICESTUDIO_FILE_DRAW + 0x0006

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_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,

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/png/pngpriv.h

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

DesktopEditor/doctrenderer/addon/docbuilder_addon.h

@@ -33,6 +33,7 @@
 #define DOC_BUILDER_ADDON_PRIVATE
 
 #include <string>
+#include "../docbuilder.h"
 
 namespace NSDoctRenderer
 {
@@ -46,11 +47,11 @@ namespace NSDoctRenderer
 			m_sWorkDirectory = sWorkDir;
 		}
 	public:
-		std::wstring GetX2tSaveAddon()
+		std::wstring GetX2tSaveAddon(NSDoctRenderer::CDocBuilder* builder, const int& filetype)
 		{
 			return L"";
 		}
-		int GetX2tPreSaveError()
+		int GetX2tPreSaveError(NSDoctRenderer::CDocBuilder* builder, const int& filetype)
 		{
 			return 0;
 		}

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

@@ -57,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.

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
@@ -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, const bool& isEnterContext)
+bool CV8RealTimeWorker::ExecuteCommand(const std::wstring& command, NSDoctRenderer::CDocBuilderValue* retValue, const bool& isEnterContextSrc)
 {
 	LOGGER_SPEED_START();
 
@@ -92,6 +92,10 @@ bool CV8RealTimeWorker::ExecuteCommand(const std::wstring& command, NSDoctRender
 	std::string commandA = U_TO_UTF8(command);
 	//commandA = "Api." + commandA;
 
+	bool isEnterContext = isEnterContextSrc;
+	if (!isEnterContext && !m_context->IsEntered())
+		isEnterContext = true;
+
 	if (isEnterContext)
 		m_context->Enter();
 
@@ -1596,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

@@ -1003,7 +1003,7 @@ namespace NSDoctRenderer
 
 			CDocBuilderAddon oSaveAddon(m_sX2tPath);
 
-			int nPreSaveError = oSaveAddon.GetX2tPreSaveError();
+			int nPreSaveError = oSaveAddon.GetX2tPreSaveError(m_pParent, m_nFileType);
 			if (0 != nPreSaveError)
 				return nPreSaveError;
 
@@ -1090,7 +1090,7 @@ namespace NSDoctRenderer
 			if (!sOptions.empty())
 				oBuilder.WriteString(UTF8_TO_U(sOptions));
 
-			oBuilder.WriteString(oSaveAddon.GetX2tSaveAddon());
+			oBuilder.WriteString(oSaveAddon.GetX2tSaveAddon(m_pParent, m_nFileType));
 
 			oBuilder.WriteString(L"</TaskQueueDataConvert>");
 
@@ -1275,7 +1275,7 @@ namespace NSDoctRenderer
 			return SaveFile(nType, path, params);
 		}
 
-		bool ExecuteCommand(const std::wstring& command, CDocBuilderValue* retValue = NULL, const bool& forceExecute = false)
+		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;
@@ -1291,12 +1291,12 @@ namespace NSDoctRenderer
 			if (CheckWorker())
 			{
 				bool bIsOpenedFromSimpleJSOld = m_bIsOpenedFromSimpleJS;
-				bool bResult = m_pWorker->ExecuteCommand(command, retValue);
+				bool bResult = m_pWorker->ExecuteCommand(command, retValue, isEnterContext);
 				if (!bResult && !bIsOpenedFromSimpleJSOld && m_bIsOpenedFromSimpleJS)
 				{
 					RELEASEOBJECT(m_pWorker);
 					CheckWorker();
-					return m_pWorker->ExecuteCommand(command, retValue);
+					return m_pWorker->ExecuteCommand(command, retValue, isEnterContext);
 				}
 				else
 				{

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/embed/GraphicsEmbed.cpp

@@ -165,9 +165,14 @@ JSSmart<CJSValue> CGraphicsEmbed::create(JSSmart<CJSValue> Native, JSSmart<CJSVa
 		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 = NULL;
+		}
+
+		if (NULL == m_pInternal->m_pAppImage)
+			m_pInternal->m_pAppImage = new CGraphicsAppImage();
 
 		if (pNativeEmbedObject)
 		{

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

@@ -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/TextShaper.cpp

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

DesktopEditor/fontengine/TextShaper_p.h

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

DesktopEditor/fontengine/js/cpp/text.cpp

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

DesktopEditor/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/drawingfile.json

@@ -51,6 +51,9 @@
 		"_IsNeedCMap",
 		"_SetCMapData",
 		"_ScanPage",
+		"_SplitPages",
+		"_MergePages",
+		"_UnmergePages",
 		"_GetImageBase64",
 		"_GetImageBase64Len",
 		"_GetImageBase64Ptr",
@@ -86,7 +89,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 +138,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 +146,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 +158,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 +186,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/",

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
@@ -729,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/wasm/js/drawingfile_native.js

@@ -94,6 +94,11 @@ CFile.prototype._getError = function()
 	return g_native_drawing_file["GetErrorCode"]();
 };
 
+CFile.prototype._addPDF = function(buffer, password)
+{
+	return g_native_drawing_file["AddPDF"]();
+}
+
 // FONTS
 CFile.prototype._isNeedCMap = function()
 {

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

@@ -86,8 +86,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 +99,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 +113,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 +121,70 @@ 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);
+	return ptr;
+};
+
+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)
 {

DesktopEditor/graphics/pro/officedrawingfile.h

@@ -40,6 +40,7 @@ enum OfficeDrawingFileType
     odftPDF = 0,
     odftXPS = 1,
     odftDJVU = 2,
+    odftOFD = 3,
     odftUndefined = 255
 };
 

DesktopEditor/graphics/pro/raster.pri

@@ -19,6 +19,10 @@ core_linux {
 	QMAKE_CXXFLAGS += -Wno-narrowing
 }
 
+core_linux_clang {
+    QMAKE_CFLAGS += -Wno-incompatible-function-pointer-types
+}
+
 core_mac {
 	DEFINES += HAVE_UNISTD_H HAVE_FCNTL_H
 }

DesktopEditor/raster/ImageFileFormatChecker.cpp

@@ -58,7 +58,7 @@ CImageFileFormatChecker::CImageFileFormatChecker()
 {
 	eFileType = _CXIMAGE_FORMAT_UNKNOWN;
 }
-CImageFileFormatChecker::CImageFileFormatChecker(std::wstring sFileName)
+CImageFileFormatChecker::CImageFileFormatChecker(const std::wstring& sFileName)
 {
 	eFileType = _CXIMAGE_FORMAT_UNKNOWN;
 	isImageFile(sFileName);
@@ -433,7 +433,7 @@ bool CImageFileFormatChecker::isPicFile(BYTE *pBuffer, DWORD dwBytes)
     return false;
 }
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool CImageFileFormatChecker::isImageFile(std::wstring& fileName)
+bool CImageFileFormatChecker::isImageFile(const std::wstring& fileName)
 {
 	eFileType  = _CXIMAGE_FORMAT_UNKNOWN;
 	///////////////////////////////////////////////////////////////////////////////
@@ -673,7 +673,7 @@ bool CImageFileFormatChecker::isImageFile(BYTE* buffer, DWORD sizeRead)
 	if (eFileType) return true;
 	return false;
 }
-bool CImageFileFormatChecker::isSvmFile(std::wstring & fileName)
+bool CImageFileFormatChecker::isSvmFile(const std::wstring & fileName)
 {
 	eFileType = _CXIMAGE_FORMAT_UNKNOWN;
 	////////////////////////////////////////////////////////////////////////////////
@@ -703,7 +703,7 @@ bool CImageFileFormatChecker::isSvmFile(std::wstring & fileName)
 	if (eFileType)return true;
 	else return false;
 }
-bool CImageFileFormatChecker::isPngFile(std::wstring & fileName)
+bool CImageFileFormatChecker::isPngFile(const std::wstring & fileName)
 {
 	eFileType = _CXIMAGE_FORMAT_UNKNOWN;
 	////////////////////////////////////////////////////////////////////////////////
@@ -735,7 +735,7 @@ bool CImageFileFormatChecker::isPngFile(std::wstring & fileName)
 
 }
 
-bool CImageFileFormatChecker::isRawFile(std::wstring& fileName)
+bool CImageFileFormatChecker::isRawFile(const std::wstring& fileName)
 {
 	// TODO:
 	return false;
@@ -745,7 +745,7 @@ bool CImageFileFormatChecker::isRawFile(BYTE* pBuffer, DWORD dwBytes)
 	// TODO:
 	return false;
 }
-bool CImageFileFormatChecker::isSvgFile(std::wstring& fileName)
+bool CImageFileFormatChecker::isSvgFile(const std::wstring& fileName)
 {
 #ifndef IMAGE_CHECKER_DISABLE_XML
 	XmlUtils::CXmlLiteReader oReader;

DesktopEditor/raster/ImageFileFormatChecker.h

@@ -71,17 +71,17 @@ public:
 	__ENUM_CXIMAGE_FORMATS eFileType;
 	
 	CImageFileFormatChecker();
-	CImageFileFormatChecker(std::wstring sFileName);
+	CImageFileFormatChecker(const std::wstring& sFileName);
 	CImageFileFormatChecker(BYTE* pBuffer, DWORD dwBytes);
 
-	bool isImageFileInZip(std::wstring& fileName);
+	bool isImageFileInZip(const std::wstring& fileName);
 	
-	bool isImageFile(std::wstring& fileName);
-	bool isPngFile(std::wstring& fileName);
-	bool isSvmFile(std::wstring& fileName);
+	bool isImageFile(const std::wstring& fileName);
+	bool isPngFile(const std::wstring& fileName);
+	bool isSvmFile(const std::wstring& fileName);
 
-	bool isRawFile(std::wstring& fileName);
-	bool isSvgFile(std::wstring& fileName);
+	bool isRawFile(const std::wstring& fileName);
+	bool isSvgFile(const std::wstring& fileName);
 
 	bool isImageFile(BYTE* pBuffer,DWORD dwBytes);
 	bool isBmpFile(BYTE* pBuffer,DWORD dwBytes);

DesktopEditor/raster/Metafile/Common/MetaFileTypes.h

@@ -34,6 +34,7 @@
 
 #include <string>
 #include <cfloat>
+#include <cmath>
 #include "../../../common/StringExt.h"
 
 #ifndef BYTE

DesktopEditor/raster/Metafile/Emf/EmfParser/CEmfPlusParser.cpp

@@ -645,6 +645,9 @@ namespace MetaFile
 				//TODO::реализовать при встрече
 			}
 
+			if (BrushDataTransform & unBrushDataFlags)
+				m_oStream.Skip(24);
+
 			if (BrushDataPresetColors & unBrushDataFlags)
 			{
 				unsigned int unPositionCount;

DesktopEditor/xml/include/xmlutils.h

@@ -85,6 +85,7 @@ namespace XmlUtils
 		bool FromString	(const wchar_t* sXml);
 		bool FromString	(const std::wstring& sXml);
 		bool FromStringA(const std::string& sXml);
+        bool FromStringA(const char* sXml, int size);
 
 		bool MoveToStart();
 

DesktopEditor/xml/src/xmllight.cpp

@@ -111,6 +111,10 @@ namespace XmlUtils
 	{
 		return m_pInternal->FromStringA(sXml);
 	}
+    bool CXmlLiteReader::FromStringA(const char* sXml, int size)
+    {
+        return m_pInternal->FromStringA(sXml, size);
+    }
     bool CXmlLiteReader::MoveToStart()
     {
         return m_pInternal->MoveToStart();

DesktopEditor/xml/src/xmllight_private.h

@@ -214,7 +214,15 @@ namespace XmlUtils
 
             return true;
         }
+        inline bool FromStringA(const char* sXml, int size)
+        {
+            m_lStreamLen = size;
+            m_pStream = new BYTE[m_lStreamLen];
+            memcpy(m_pStream, sXml, m_lStreamLen);
+            reader = xmlReaderForMemory((char*)m_pStream, m_lStreamLen, NULL, NULL, 0);
 
+            return true;
+        }
         inline bool MoveToStart()
         {
             if (NULL != reader)

DjVuFile/DjVu.cpp

@@ -121,3 +121,15 @@ BYTE* CDjVuFile::GetLinks (int nPageIndex)
         return m_pImplementation->GetPageLinks(nPageIndex);
     return NULL;
 }
+
+unsigned char* CDjVuFile::ConvertToPixels(
+	int nPageIndex,
+	int nRasterW, int nRasterH, bool bIsFlip,
+	NSFonts::IFontManager* pFonts,
+	int nBackgroundColor, bool bIsDarkMode,
+	int nBackgroundOpacity)
+{
+	if (m_pImplementation)
+		return m_pImplementation->ConvertToPixels(nPageIndex, nRasterW, nRasterH, !bIsFlip);
+	return NULL;
+}

DjVuFile/DjVu.h

@@ -76,4 +76,11 @@ public:
 
     virtual BYTE* GetStructure();
     virtual BYTE* GetLinks (int nPageIndex);
+
+    virtual unsigned char* ConvertToPixels(
+        int nPageIndex,
+        int nRasterW, int nRasterH, bool bIsFlip = false,
+        NSFonts::IFontManager* pFonts = NULL,
+        int nBackgroundColor = 0xFFFFFF, bool bIsDarkMode = false,
+        int nBackgroundOpacity = 0xFF);
 };

DjVuFile/DjVuFileImplementation.cpp

@@ -247,18 +247,11 @@ void  CDjVuFileImplementation::DrawPageOnRenderer(IRenderer* pRenderer, int nPag
 		long lRendererType = c_nUnknownRenderer;
 		pRenderer->get_Type(&lRendererType);
 
-#ifndef BUILDING_WASM_MODULE
-		if (c_nPDFWriter == lRendererType)
-		{
-			XmlUtils::CXmlNode oText = ParseText(pPage);
-			CreatePdfFrame(pRenderer, pPage, nPageIndex, oText);
-		}
-		else
-#endif
-		{
-			XmlUtils::CXmlNode oText = ParseText(pPage);
-			CreateFrame(pRenderer, pPage, nPageIndex, oText);
-		}
+		XmlUtils::CXmlNode text;
+		if (c_nPDFWriter == lRendererType || c_nHtmlRendrererText == lRendererType)
+			text = ParseText(pPage);
+
+		CreateFrame(pRenderer, pPage, nPageIndex, text);
 	}
 	catch (...)
 	{
@@ -463,9 +456,14 @@ void CDjVuFileImplementation::CreateFrame(IRenderer* pRenderer, GP<DjVuImage>& p
 	}
 
 	int nDpi = pPage->get_dpi();
-
 	double dPixToMM = 25.4;
 
+	if (c_nHtmlRendrererText == lRendererType && text.IsValid())
+	{
+		TextToRenderer(pRenderer, text, dPixToMM / nDpi);
+		return;
+	}
+
 	double dRendDpiX = 0;
 	double dRendDpiY = 0;
 
@@ -491,150 +489,22 @@ void CDjVuFileImplementation::CreateFrame(IRenderer* pRenderer, GP<DjVuImage>& p
 	LONG lImageWidth	= (LONG)(dRendDpiX * dRendWidth / dPixToMM);
 	LONG lImageHeight	= (LONG)(dRendDpiY * dRendHeight / dPixToMM);
 
-	BYTE* pBufferDst = new BYTE[4 * lImageHeight * lImageWidth];
+	BYTE* pBufferDst = this->ConvertToPixels(pPage, lImageWidth, lImageHeight, false);
+
 	if (!pBufferDst)
 		return;
 
-	bool bIsInit = false;
-
 	Aggplus::CImage oImage;
 	oImage.Create(pBufferDst, lImageWidth, lImageHeight, 4 * lImageWidth);
-	if (pPage->is_legal_photo() || pPage->is_legal_compound())
-	{
-		bIsInit = true;
-		GRect oRectAll(0, 0, lImageWidth, lImageHeight);
-		GP<GPixmap> pImage = pPage->get_pixmap(oRectAll, oRectAll);
-
-		BYTE* pBuffer = pBufferDst;
-		for (int j = lImageHeight - 1; j >= 0; --j)
-		{
-			GPixel* pLine = pImage->operator [](j);
-
-			for (int i = 0; i < lImageWidth; ++i, pBuffer += 4, ++pLine)
-			{
-				pBuffer[0] = pLine->b;
-				pBuffer[1] = pLine->g;
-				pBuffer[2] = pLine->r;
-				pBuffer[3] = 255;
-			}
-		}
-	}
-	else if (pPage->is_legal_bilevel())
-	{
-		bIsInit = true;
-		GRect oRectAll(0, 0, lImageWidth, lImageHeight);
-		GP<GBitmap> pBitmap = pPage->get_bitmap(oRectAll, oRectAll, 4);
-		int nPaletteEntries = pBitmap->get_grays();
-
-		unsigned int* palette = new unsigned int[nPaletteEntries];
-
-		// Create palette for the bitmap
-		int color = 0xff0000;
-		int decrement = color / (nPaletteEntries - 1);
-		for (int i = 0; i < nPaletteEntries; ++i)
-		{
-			BYTE level = (BYTE)(color >> 16);
-			palette[i] = (0xFF000000 | level << 16 | level << 8 | level);
-			color -= decrement;
-		}
-
-		unsigned int* pBuffer = (unsigned int*)pBufferDst;
-		for (int j = lImageHeight - 1; j >= 0; --j)
-		{
-			BYTE* pLine = pBitmap->operator [](j);
-
-			for (int i = 0; i < lImageWidth; ++i, ++pBuffer, ++pLine)
-			{
-				if (*pLine < nPaletteEntries)
-				{
-					*pBuffer = palette[*pLine];
-				}
-				else
-				{
-					*pBuffer = palette[0];
-				}
-			}
-		}
-
-		RELEASEARRAYOBJECTS(palette);
-	}
-	else
-	{
-		// белый фрейм??
-		//memset(pBufferDst, 0xFF, 4 * lImageWidth * lImageHeight);
-		GRect oRectAll(0, 0, lImageWidth, lImageHeight);
-		GP<GPixmap> pImage = pPage->get_pixmap(oRectAll, oRectAll);
-
-		if (NULL != pImage)
-		{
-			bIsInit = true;
-			BYTE* pBuffer = pBufferDst;
-			for (int j = lImageHeight - 1; j >= 0; --j)
-			{
-				GPixel* pLine = pImage->operator [](j);
-
-				for (int i = 0; i < lImageWidth; ++i, pBuffer += 4, ++pLine)
-				{
-					pBuffer[0] = pLine->b;
-					pBuffer[1] = pLine->g;
-					pBuffer[2] = pLine->r;
-					pBuffer[3] = 255;
-				}
-			}
-		}
-		else
-		{
-			GP<GBitmap> pBitmap = pPage->get_bitmap(oRectAll, oRectAll, 4);
-
-			if (NULL != pBitmap)
-			{
-				bIsInit = true;
-				int nPaletteEntries = pBitmap->get_grays();
-
-				unsigned int* palette = new unsigned int[nPaletteEntries];
-
-				// Create palette for the bitmap
-				int color = 0xff0000;
-				int decrement = color / (nPaletteEntries - 1);
-				for (int i = 0; i < nPaletteEntries; ++i)
-				{
-					BYTE level = (BYTE)(color >> 16);
-					palette[i] = (0xFF000000 | level << 16 | level << 8 | level);
-					color -= decrement;
-				}
-
-				unsigned int* pBuffer = (unsigned int*)pBufferDst;
-				for (int j = lImageHeight - 1; j >= 0; --j)
-				{
-					BYTE* pLine = pBitmap->operator [](j);
-
-					for (int i = 0; i < lImageWidth; ++i, ++pBuffer, ++pLine)
-					{
-						if (*pLine < nPaletteEntries)
-						{
-							*pBuffer = palette[*pLine];
-						}
-						else
-						{
-							*pBuffer = palette[0];
-						}
-					}
-				}
-
-				RELEASEARRAYOBJECTS(palette);
-			}
-		}
-	}
 
 	pRenderer->BeginCommand(c_nPageType);
 
-	if (c_nGrRenderer != lRendererType && c_nHtmlRendrerer != lRendererType && c_nHtmlRendrerer2 != lRendererType)
+	if (text.IsValid())
 	{
 		TextToRenderer(pRenderer, text, dPixToMM / nDpi);
 	}
 
-	if (bIsInit)
-		pRenderer->DrawImage((IGrObject*)&oImage, 0, 0, dRendWidth, dRendHeight);
+	pRenderer->DrawImage((IGrObject*)&oImage, 0, 0, dRendWidth, dRendHeight);
 	pRenderer->EndCommand(c_nPageType);
 }
 void CDjVuFileImplementation::CreatePdfFrame(IRenderer* pRenderer, GP<DjVuImage>& pPage, int nPageIndex, XmlUtils::CXmlNode& oText)
@@ -849,6 +719,104 @@ void CDjVuFileImplementation::CreatePdfFrame(IRenderer* pRenderer, GP<DjVuImage>
 	pRenderer->EndCommand(c_nPageType);
 }
 
+unsigned char* CDjVuFileImplementation::ConvertToPixels(int nPageIndex, int nRasterW, int nRasterH, bool bIsFlip)
+{
+	try
+	{
+		GP<DjVuImage> pPage = m_pDoc->get_page(nPageIndex);
+		//pPage->wait_for_complete_decode();
+		pPage->set_rotate(0);
+		return ConvertToPixels(pPage, nRasterW, nRasterH, bIsFlip);
+	}
+	catch (...)
+	{
+	}
+	return NULL;
+}
+
+unsigned char* CDjVuFileImplementation::ConvertToPixels(GP<DjVuImage>& pPage, int nImageW, int nImageH, bool bFlip)
+{
+	BYTE* pBufferDst = NULL;
+
+	auto processPixmap = [&](GP<GPixmap> pImage, bool bFlip = false)
+	{
+		pBufferDst = new BYTE[4 * nImageW * nImageH];
+
+		unsigned int* pBuffer = (unsigned int*)pBufferDst;
+		for (int j = 0; j < nImageH; ++j)
+		{
+			int nRow = bFlip ? j : (nImageH - 1 - j);
+			GPixel* pLine = pImage->operator[](nRow);
+			for (int i = 0; i < nImageW; ++i)
+			{
+				*pBuffer++ = 0xFF000000 | pLine->r << 16 | pLine->g << 8 | pLine->b;
+				++pLine;
+			}
+		}
+	};
+
+	auto processBitmap = [&](GP<GBitmap> pBitmap, bool bFlip = false)
+	{
+		pBufferDst = new BYTE[4 * nImageW * nImageH];
+
+		int nPaletteEntries = pBitmap->get_grays();
+		unsigned int* palette = new unsigned int[nPaletteEntries];
+		int color = 0xFF0000;
+		int decrement = color / (nPaletteEntries - 1);
+		for (int i = 0; i < nPaletteEntries; ++i)
+		{
+			BYTE level = (BYTE)(color >> 16);
+			palette[i] = (0xFF000000 | level << 16 | level << 8 | level);
+			color -= decrement;
+		}
+
+		unsigned int* pBuffer = (unsigned int*)pBufferDst;
+		for (int j = 0; j < nImageH; ++j)
+		{
+			int nRow = bFlip ? j : (nImageH - 1 - j);
+			BYTE* pLine = pBitmap->operator[](nRow);
+			for (int i = 0; i < nImageW; ++i)
+			{
+				*pBuffer++ = palette[*pLine < nPaletteEntries ? *pLine : 0];
+				++pLine;
+			}
+		}
+
+		RELEASEARRAYOBJECTS(palette);
+	};
+
+	GRect oRectAll(0, 0, nImageW, nImageH);
+
+	if (pPage->is_legal_photo() || pPage->is_legal_compound())
+	{
+		GP<GPixmap> pImage = pPage->get_pixmap(oRectAll, oRectAll);
+		processPixmap(pImage, bFlip);
+	}
+	else if (pPage->is_legal_bilevel())
+	{
+		GP<GBitmap> pBitmap = pPage->get_bitmap(oRectAll, oRectAll, 4);
+		processBitmap(pBitmap, bFlip);
+	}
+	else
+	{
+		GP<GPixmap> pImage = pPage->get_pixmap(oRectAll, oRectAll);
+		if (pImage)
+		{
+			processPixmap(pImage, bFlip);
+		}
+		else
+		{
+			GP<GBitmap> pBitmap = pPage->get_bitmap(oRectAll, oRectAll, 4);
+			if (pBitmap)
+			{
+				processBitmap(pBitmap, bFlip);
+			}
+		}
+	}
+
+	return pBufferDst;
+}
+
 XmlUtils::CXmlNode CDjVuFileImplementation::ParseText(GP<DjVuImage> pPage)
 {
 	XmlUtils::CXmlNode paragraph;

DjVuFile/DjVuFileImplementation.h

@@ -79,8 +79,12 @@ public:
     BYTE*        GetPageGlyphs(int nPageIndex);
     BYTE*        GetPageLinks (int nPageIndex);
 
+	unsigned char* ConvertToPixels(int nPageIndex, int nRasterW, int nRasterH, bool bIsFlip = false);
+
 private:
 
+	unsigned char* ConvertToPixels(GP<DjVuImage>& pPage, int nRasterW, int nRasterH, bool bIsFlip = false);
+
 	void               CreateFrame(IRenderer* pRenderer, GP<DjVuImage>& pImage, int nPage, XmlUtils::CXmlNode& oText);
     void               CreatePdfFrame(IRenderer* pRenderer, GP<DjVuImage>& pImage, int nPage, XmlUtils::CXmlNode& oText);
 	XmlUtils::CXmlNode ParseText(GP<DjVuImage> pPage);

DjVuFile/libdjvu/DjVuDocument.cpp

@@ -1943,15 +1943,15 @@ void DjVuDocument::ReadPageInfo(int nPage, int& width, int& height, int& nDpi)
 				bHasIW44 = true;
 
 				// Get image dimensions and resolution from bitmap chunk
-				UINT serial = chunk_stream->read8();
-				UINT slices = chunk_stream->read8();
-				UINT major = chunk_stream->read8();
-				UINT minor = chunk_stream->read8();
+				unsigned int serial = chunk_stream->read8();
+				unsigned int slices = chunk_stream->read8();
+				unsigned int major = chunk_stream->read8();
+				unsigned int minor = chunk_stream->read8();
 
-				UINT xhi = chunk_stream->read8();
-				UINT xlo = chunk_stream->read8();
-				UINT yhi = chunk_stream->read8();
-				UINT ylo = chunk_stream->read8();
+				unsigned int xhi = chunk_stream->read8();
+				unsigned int xlo = chunk_stream->read8();
+				unsigned int yhi = chunk_stream->read8();
+				unsigned int ylo = chunk_stream->read8();
 
 				width = (xhi << 8) | xlo;
 				height = (yhi << 8) | ylo;

HwpFile/HWPFile.pro

@@ -16,7 +16,9 @@ LIBS += -L$$CORE_BUILDS_LIBRARIES_PATH -lCryptoPPLib
 
 ADD_DEPENDENCY(kernel, UnicodeConverter, graphics)
 
-DEFINES += HWPFILE_USE_DYNAMIC_LIBRARY
+DEFINES += HWPFILE_USE_DYNAMIC_LIBRARY \
+           CRYPTOPP_DISABLE_ASM 
+
 
 SOURCES += \
     HWPFile.cpp \

HwpFile/HwpDoc/Common/XMLNode.h

@@ -19,6 +19,7 @@ public:
 };
 
 int ConvertWidthToHWP(const std::wstring& wsValue);
+int ConvertHexToInt(const std::string& wsValue, const int& _default = 0x00000000);
 }
 
 #endif // XMLNODEH_H

HwpFile/HwpDoc/Common/XMLReader.cpp

@@ -17,20 +17,7 @@ bool CXMLNode::GetAttributeBool(const std::wstring& wsName)
 
 int CXMLNode::GetAttributeColor(const std::wstring& wsName, const int& _default)
 {
-	std::wstring sColor = XmlUtils::CXmlNode::GetAttribute(wsName);
-
-	if (L"none" != sColor)
-	{
-		if (L'#' == sColor.front())
-			sColor.erase(0, 1);
-
-		if (sColor.length() < 6)
-			return _default;
-
-		return std::stoi(sColor.substr(0, 6), nullptr, 16);
-	}
-
-	return _default;
+	return ConvertHexToInt(XmlUtils::CXmlNode::GetAttributeA(wsName), _default);
 }
 
 CXMLNode CXMLNode::GetChild(const std::wstring& wsName)
@@ -98,4 +85,36 @@ int ConvertWidthToHWP(const std::wstring& wsValue)
 
 	return 0;
 }
+
+int ConvertHexToInt(const std::string& wsValue, const int& _default)
+{
+	if (wsValue.empty() || "none" == wsValue)
+		return _default;
+
+	std::string::const_iterator itStart = wsValue.cbegin();
+
+	if ('#' == *itStart)
+		++itStart;
+
+	if (wsValue.cend() - itStart < 6)
+		return _default;
+
+	itStart = wsValue.cend() - 6;
+
+	int nResult = 0;
+
+	while (itStart != wsValue.cend())
+	{
+		if ('0' <= *itStart && *itStart <= '9')
+			nResult = (nResult << 4) | (*itStart++ - '0');
+		else if ('A' <= *itStart && *itStart <= 'F')
+			nResult = (nResult << 4) | (*itStart++ - 'A' + 10);
+		else if ('a' <= *itStart && *itStart <= 'f')
+			nResult = (nResult << 4) | (*itStart++ - 'a' + 10);
+		else
+			return _default;
+	}
+
+	return nResult;
+}
 }

HwpFile/HwpDoc/HWPElements/HWPRecordBorderFill.cpp

@@ -62,12 +62,7 @@ EColorFillPattern GetColorFillPattern(int nPattern)
 void TBorder::ReadFromNode(CXMLNode& oNode)
 {
 	m_eStyle = GetLineStyle2(oNode.GetAttribute(L"type"));
-
-	HWP_STRING sColor = std::regex_replace(oNode.GetAttribute(L"color"), std::wregex(L"^#([0-9A-Fa-f]+)$"), L"$1");
-
-	if (L"none" != sColor)
-		m_nColor = std::stoi(sColor, 0, 16);
-
+	m_nColor = oNode.GetAttributeColor(L"color");
 	m_chWidth = (HWP_BYTE)ConvertWidthToHWP(oNode.GetAttribute(L"width"));
 }
 
@@ -199,7 +194,7 @@ void CFill::ReadGradation(CXMLNode& oNode)
 	m_arColors.resize(arChilds.size());
 
 	for (unsigned int unIndex = 0; unIndex < arChilds.size(); ++unIndex)
-		m_arColors[unIndex] = std::stoi(std::regex_replace(arChilds[unIndex].GetText(), std::wregex(L"\\D"), L""), 0, 16);
+		m_arColors[unIndex] = ConvertHexToInt(arChilds[unIndex].GetTextA());
 }
 
 void CFill::ReadImgBrush(CXMLNode& oNode)

HwpFile/HwpDoc/HWPElements/HWPRecordBullet.cpp

@@ -48,8 +48,16 @@ CHWPRecordBullet::CHWPRecordBullet(CHWPDocInfo& oDocInfo, int nTagNum, int nLeve
 CHWPRecordBullet::CHWPRecordBullet(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion)
 	: CHWPRecord(EHWPTag::HWPTAG_BULLET, 0, 0), m_pParent(&oDocInfo)
 {
-	m_chBulletChar = oNode.GetAttribute(L"char").at(0);
-	m_chCheckBulletChar = oNode.GetAttribute(L"checkedChar").at(0);
+	std::wstring wsAttributeValue = oNode.GetAttribute(L"char");
+
+	if (!wsAttributeValue.empty())
+		m_chBulletChar = wsAttributeValue.at(0);
+
+	wsAttributeValue = oNode.GetAttribute(L"checkedChar");
+
+	if (!wsAttributeValue.empty())
+		m_chCheckBulletChar = wsAttributeValue.at(0);
+
 	m_nBulletImage = oNode.GetAttributeInt(L"useImage");
 
 	for (CXMLNode& oChild : oNode.GetChilds())

MsBinaryFile/PptFile/PPTXWriter/Converter.cpp

@@ -619,6 +619,7 @@ namespace PPT
 
         WriteSlides();
         WriteNotes();
+        m_pShapeWriter->SetRelsGenerator(NULL);
     }
 
     // todo reforming and refactoring!
@@ -1544,6 +1545,8 @@ namespace PPT
 
             oRels.StartSlide(nLayout, pSlide->m_lNotesID);
         }
+        
+        m_pShapeWriter->SetRelsGenerator(&oRels);
 
         oWriter.WriteString(std::wstring(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"));
         oWriter.WriteString(std::wstring(L"<p:sld \
@@ -1637,10 +1640,12 @@ xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\""));
     {
         CStringWriter oWriter;
         CRelsGenerator oRels(&m_oManager);
-
+        
         CSlide* pNotes = m_pDocument->m_arNotes[nIndexNotes];
 
         oRels.StartNotes(pNotes->m_lSlideID, m_pDocument->m_pNotesMaster != NULL);
+        
+        m_pShapeWriter->SetRelsGenerator(&oRels);
 
         oWriter.WriteString(std::wstring(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"));
         oWriter.WriteString(std::wstring(L"<p:notes xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\""));

MsBinaryFile/XlsFile/Format/Auxiliary/HelpFunc.cpp

@@ -780,20 +780,5 @@ bool isColumn(const std::wstring& columnName, _UINT32 listIndex, _UINT16& indexC
 	}
 	return false;
 }
-unsigned int getColumnsCount(_UINT32 listIndex)
-{
-    auto arrColumn = XLS::GlobalWorkbookInfo::mapTableColumnNames_static.find(listIndex);
-	if(arrColumn != XLS::GlobalWorkbookInfo::mapTableColumnNames_static.end())
-	{
-		auto counter = 0;
-		for(auto i:arrColumn->second)
-		{
-			if(!i.empty())
-				counter++;
-		}
-		return counter;
-	}
-	return 0;
-}
 } //namespace XMLSTUFF
 

MsBinaryFile/XlsFile/Format/Auxiliary/HelpFunc.h

@@ -87,15 +87,13 @@ namespace STR
 };
 
 namespace XMLSTUFF
-{;
-
+{
 const std::wstring name2sheet_name(std::wstring name, const std::wstring prefix);
 const std::wstring xti_indexes2sheet_name(const short tabFirst, const short tabLast, std::vector<std::wstring>& names, const std::wstring prefix = L"");
 unsigned short sheetsnames2ixti(std::wstring name);
 unsigned int definenames2index(std::wstring name);
 bool isTableFmla(const std::wstring& tableName, _UINT32& listIndex);
 bool isColumn(const std::wstring& columnName, _UINT32 listIndex, _UINT16& indexColumn);
-unsigned int getColumnsCount(_UINT32 listIndex);
 unsigned short AddMultysheetXti(const std::wstring& name, const _INT32& firstIxti, const _INT32& secondIxti);
 unsigned int AddDefinedName(const std::wstring& name);
 }

MsBinaryFile/XlsFile/Format/Logic/Biff_records/DVal.h

@@ -53,11 +53,11 @@ public:
 	static const ElementType	type = typeDVal;
 
 //-----------------------------
-	bool fWnClosed;
-	_UINT32	xLeft;
-	_UINT32	yTop;
-	_INT32	idObj;
-	_UINT32	idvMac;
+    bool fWnClosed = 0;
+    _UINT32	xLeft = 0;
+    _UINT32	yTop = 0;
+    _INT32	idObj = 0;
+    _UINT32	idvMac = 0;
 
 };
 

MsBinaryFile/XlsFile/Format/Logic/Biff_records/FileSharing.h

@@ -56,7 +56,7 @@ public:
 	static const ElementType	type = typeFileSharing;
 
     Boolean<unsigned short>     fReadOnlyRec;
-    unsigned short              wResPassNum;
+    unsigned short              wResPassNum = 0;
     std::wstring                wResPass;
     _UINT16                     iNoResPass;
     XLUnicodeString             stUNUsername;

MsBinaryFile/XlsFile/Format/Logic/Biff_records/XF.h

@@ -61,12 +61,12 @@ namespace XLS
 
 		static const ElementType type = typeXF;
 
-		_UINT16		font_index;
+        _UINT16		font_index = 0;
 		
-		_UINT16		ifmt; //used
-		std::wstring format_code;
+        _UINT16		ifmt = 0; //used
+        std::wstring format_code = L"";
 		
-		_UINT16		ixfParent;
+        _UINT16		ixfParent = 0;
 
 		bool fLocked = false;
 		bool fHidden = false;

MsBinaryFile/XlsFile/Format/Logic/Biff_structures/BIFF12/FRTSqref.cpp

@@ -1,4 +1,4 @@
-/*
+/*
  * (c) Copyright Ascensio System SIA 2010-2021
  *
  * This program is a free software product. You can redistribute it and/or
@@ -71,10 +71,9 @@ namespace XLSB
 
 	void FRTSqref::save(XLS::CFRecord& record)
 	{
-		_UINT32 flags = 0;
+        _UINT32 flags = 2;
 
 		SETBIT(flags, 0, fAdjDelete)
-		SETBIT(flags, 1, fDoAdjust)
 		SETBIT(flags, 2, fAdjChange)
 		SETBIT(flags, 3, fEdit)
 

MsBinaryFile/XlsFile/Format/Logic/Biff_structures/BIFF12/UncheckedSqRfX.h

@@ -1,4 +1,4 @@
-/*
+/*
  * (c) Copyright Ascensio System SIA 2010-2021
  *
  * This program is a free software product. You can redistribute it and/or
@@ -52,7 +52,7 @@ namespace XLSB
         void load(XLS::CFRecord& record) override;
 		void save(XLS::CFRecord& record) override;
 
-        _INT32                      crfx;
+        _INT32                      crfx = 0;
         std::vector<UncheckedRfX>   rgrfx;
 
         const XLS::CellRef getLocationFirstCell() const;

MsBinaryFile/XlsFile/Format/Logic/Biff_structures/CellRef.h

@@ -64,10 +64,10 @@ public:
 	const bool	getRowRelative() const;
 	const bool	getColumnRelative() const;
 
-    int		row;
-    int		column;
-	bool	rowRelative;
-	bool	colRelative;
+    int		row = 0;
+    int		column = 0;
+    bool	rowRelative = false;
+    bool	colRelative = false;
 protected:
 	bool	fQuoted;
 	mutable std::wstring to_string_cache;

MsBinaryFile/XlsFile/Format/Logic/Biff_structures/Ftab_Cetab.cpp

@@ -531,8 +531,8 @@ Ftab_Cetab::ValuesDetermination::ValuesDetermination()
     params_fixed.insert(ParamsFixed(0x01E0, 2, L"IFERROR"));
     params_fixed.insert(ParamsFixed(0x01E1, -1, L"COUNTIFS"));
     params_fixed.insert(ParamsFixed(0x01E2, 3, L"SUMIFS"));
-    params_fixed.insert(ParamsFixed(0x01E3, 2, L"AVERAGEIF"));
-    params_fixed.insert(ParamsFixed(0x01E4, 3, L"AVERAGEIFS"));
+    params_fixed.insert(ParamsFixed(0x01E3, -1, L"AVERAGEIF"));
+    params_fixed.insert(ParamsFixed(0x01E4, -1, L"AVERAGEIFS"));
 
 // Cetab values
 	params_fixed.insert(ParamsFixed(0x8000, -1, L"BEEP"));

MsBinaryFile/XlsFile/Format/Logic/Biff_structures/ODRAW/OfficeArtContainer.cpp

@@ -82,6 +82,7 @@ OfficeArtRecordPtr OfficeArtContainer::CreateOfficeArt(unsigned short type)
 		case FSP:
 			art_record = OfficeArtRecordPtr(new OfficeArtFSP);							break;
 		case FOPT:
+		case SecondaryFOPT:
 			art_record = OfficeArtRecordPtr(new OfficeArtFOPT);							break;
 		case ChildAnchor:
 			art_record = OfficeArtRecordPtr(new OfficeArtChildAnchor);					break;
@@ -116,8 +117,6 @@ OfficeArtRecordPtr OfficeArtContainer::CreateOfficeArt(unsigned short type)
 			art_record = OfficeArtRecordPtr(new OfficeArtBStoreContainer);				break;
 		case TertiaryFOPT:
 			art_record = OfficeArtRecordPtr(new OfficeArtTertiaryFOPT);					break;
-		case SecondaryFOPT:
-		
 		case FPSPL:
 		case FDGSL:
 		case FBSE:

MsBinaryFile/XlsFile/Format/Logic/Biff_structures/StringPtgParser.cpp

@@ -317,9 +317,6 @@ const bool StringPtgParser::parseToPtgs(const std::wstring& assembled_formula, R
                             [&](XLS::GlobalWorkbookInfo::_xti i) {
                         return i.iSup == ixti;
                     });
-                    if(pos->itabFirst == pos->itabLast)
-                        rgce.addPtg(found_operand = OperandPtgPtr(new PtgRef3d(ixti, operand_str, OperandPtg::ptg_VALUE, rgce.getLocation())));
-                    else
                         rgce.addPtg(found_operand = OperandPtgPtr(new PtgRef3d(ixti, operand_str, OperandPtg::ptg_REFERENCE, rgce.getLocation())));
                 }
                 else if(SyntaxPtg::extract_PtgRefErr(it, itEnd))

MsBinaryFile/XlsFile/Format/Logic/Biff_structures/SyntaxPtg.cpp

@@ -617,21 +617,11 @@ const bool SyntaxPtg::extract_PtgList(std::wstring::const_iterator& first, std::
 			}
 			else if (boost::regex_search(first, last, results_1, reg_inside_table6))
 			{
-				auto colCount = XMLSTUFF::getColumnsCount(indexTable);
-				if(colCount>1)
-				{
-					ptgList.columns = 0x02;
-					ptgList.colFirst = 0;
-					ptgList.colLast = colCount-1;
-                    first = results_1[0].second;
-				}
-				else
-				{
-					ptgList.columns = 0x01;
-					ptgList.colFirst = 0;
-                    ptgList.colLast = 0;
-					first = results_1[0].second;
-				}
+                ptgList.columns = 0;
+                ptgList.colFirst = 0;
+                ptgList.colLast = 0;
+                ptgList.rowType = 0x00;
+                first = results_1[0].second;
 				return true;
 			}
 			else if(boost::regex_search(first, last, results_1, reg_inside_table4))

OFDFile/OFDFile.cpp

@@ -0,0 +1,147 @@
+#include "OFDFile.h"
+#include "src/OFDFile_Private.h"
+
+#ifndef DISABLE_PDF_CONVERTATION
+#include "../PdfFile/PdfFile.h"
+#endif
+
+COFDFile::COFDFile(NSFonts::IApplicationFonts* pFonts)
+	: m_pInternal(new COFDFile_Private(pFonts))
+{}
+
+COFDFile::~COFDFile()
+{
+	COFDFile::Close();
+
+	if (nullptr != m_pInternal)
+		delete m_pInternal;
+}
+
+bool COFDFile::LoadFromFile(const std::wstring& file, const std::wstring& options, const std::wstring& owner_password, const std::wstring& user_password)
+{
+	if (nullptr == m_pInternal)
+		return false;
+
+	Close();
+
+	return m_pInternal->LoadFromFile(file);
+}
+
+bool COFDFile::LoadFromMemory(unsigned char* data, unsigned long length, const std::wstring& options, const std::wstring& owner_password, const std::wstring& user_password)
+{
+	if (nullptr == m_pInternal)
+		return false;
+
+	Close();
+
+	return m_pInternal->LoadFromMemory(data, length);
+}
+
+void COFDFile::Close()
+{
+	if (nullptr != m_pInternal)
+		m_pInternal->Close();
+}
+
+NSFonts::IApplicationFonts* COFDFile::GetFonts()
+{
+	return (nullptr != m_pInternal) ? m_pInternal->GetFonts() : nullptr;
+}
+
+OfficeDrawingFileType COFDFile::GetType()
+{
+	return odftOFD;
+}
+
+std::wstring COFDFile::GetTempDirectory()
+{
+	if (nullptr != m_pInternal)
+		return m_pInternal->GetTempDir();
+
+	return std::wstring();
+}
+
+void COFDFile::SetTempDirectory(const std::wstring& directory)
+{
+	if (nullptr != m_pInternal)
+		m_pInternal->SetTempDir(directory);
+}
+
+int COFDFile::GetPagesCount()
+{
+	if (nullptr != m_pInternal)
+		return m_pInternal->GetPageCount();
+
+	return 0;
+}
+
+void COFDFile::GetPageInfo(int nPageIndex, double* pdWidth, double* pdHeight, double* pdDpiX, double* pdDpiY)
+{
+	if (nullptr == m_pInternal)
+		return;
+
+	m_pInternal->GetPageSize(nPageIndex, *pdWidth, *pdHeight);
+
+	*pdDpiX = 25.4;
+	*pdDpiY = 25.4;
+}
+
+void COFDFile::DrawPageOnRenderer(IRenderer* pRenderer, int nPageIndex, bool* pBreak, COfficeDrawingPageParams* pParams)
+{
+	if (nullptr == pRenderer || nullptr == m_pInternal)
+		return;
+
+	m_pInternal->DrawPage(pRenderer, nPageIndex);
+}
+
+#ifndef DISABLE_PDF_CONVERTATION
+void COFDFile::ConvertToPdf(const std::wstring& wsDstPath)
+{
+	CPdfFile oPdf(GetFonts());
+	oPdf.CreatePdf();
+	bool bBreak = false;
+
+	int nPagesCount = GetPagesCount();
+	for (int nPageIndex = 0; nPageIndex < nPagesCount; nPageIndex++)
+	{
+		oPdf.NewPage();
+		oPdf.BeginCommand(c_nPageType);
+
+		double dPageDpiX = 96., dPageDpiY = 96.;
+		double dWidth = 0., dHeight = 0.;
+
+		GetPageInfo(nPageIndex, &dWidth, &dHeight, &dPageDpiX, &dPageDpiY);
+
+		dWidth  *= 25.4 / dPageDpiX;
+		dHeight *= 25.4 / dPageDpiY;
+
+		oPdf.put_Width(dWidth);
+		oPdf.put_Height(dHeight);
+
+		DrawPageOnRenderer(&oPdf, nPageIndex, &bBreak);
+
+		oPdf.EndCommand(c_nPageType);
+
+#ifdef _DEBUG
+		printf("page %d / %d\n", nPageIndex + 1, nPagesCount);
+#endif
+	}
+
+	oPdf.SaveToFile(wsDstPath);
+}
+
+std::wstring COFDFile::GetInfo()
+{
+	return std::wstring();
+}
+
+unsigned char* COFDFile::GetStructure()
+{
+	return nullptr;
+}
+
+unsigned char* COFDFile::GetLinks(int nPageIndex)
+{
+	return nullptr;
+}
+#endif

OFDFile/OFDFile.h

@@ -0,0 +1,56 @@
+#ifndef OFDFILE_H
+#define OFDFILE_H
+
+#ifndef OFD_USE_DYNAMIC_LIBRARY
+#define OFD_DECL_EXPORT
+#else
+#include "../DesktopEditor/common/base_export.h"
+#define OFD_DECL_EXPORT Q_DECL_EXPORT
+#endif
+
+#include "../DesktopEditor/graphics/pro/officedrawingfile.h"
+#include "../DesktopEditor/graphics/pro/Fonts.h"
+
+class COFDFile_Private;
+class OFD_DECL_EXPORT COFDFile : public IOfficeDrawingFile
+{
+	COFDFile_Private* m_pInternal;
+public:
+	COFDFile(NSFonts::IApplicationFonts* pFonts);
+	virtual ~COFDFile();
+
+	// Open
+	virtual bool LoadFromFile(const std::wstring& file, const std::wstring& options = L"",
+	                          const std::wstring& owner_password = L"", const std::wstring& user_password = L"") override;
+	virtual bool LoadFromMemory(unsigned char* data, unsigned long length, const std::wstring& options = L"",
+	                            const std::wstring& owner_password = L"", const std::wstring& user_password = L"") override;
+
+	// Close
+	void Close() override;
+
+	// Get IApplicationFonts for wrappers
+	virtual NSFonts::IApplicationFonts* GetFonts() override;
+
+	// Type
+	virtual OfficeDrawingFileType GetType() override;
+
+	// Temp directory
+	virtual std::wstring GetTempDirectory() override;
+	virtual void SetTempDirectory(const std::wstring& directory) override;
+
+	// Pages info/draw
+	virtual int GetPagesCount() override;
+	virtual void GetPageInfo(int nPageIndex, double* pdWidth, double* pdHeight, double* pdDpiX, double* pdDpiY) override;
+	virtual void DrawPageOnRenderer(IRenderer* pRenderer, int nPageIndex, bool* pBreak, COfficeDrawingPageParams* pParams = NULL) override;
+
+	#ifndef DISABLE_PDF_CONVERTATION
+	void ConvertToPdf(const std::wstring& wsDstPath);
+	#endif
+
+	// Common methods for viewer
+	virtual std::wstring GetInfo() override;
+	virtual unsigned char* GetStructure() override;
+	virtual unsigned char* GetLinks(int nPageIndex) override;
+};
+
+#endif // OFDFILE_H

OFDFile/OFDFile.pro

@@ -0,0 +1,86 @@
+QT       -= core gui
+
+VERSION = 1.0.0.1
+TARGET = OFDFile
+TEMPLATE = lib
+
+CONFIG += shared
+CONFIG += plugin
+
+CORE_ROOT_DIR = $$PWD/..
+PWD_ROOT_DIR = $$PWD
+
+include($$CORE_ROOT_DIR/Common/base.pri)
+include($$CORE_ROOT_DIR/Common/3dParty/boost/boost.pri)
+
+DEFINES += OFD_USE_DYNAMIC_LIBRARY
+
+ADD_DEPENDENCY(graphics, kernel, UnicodeConverter, PdfFile)
+
+core_windows {
+LIBS += -lgdi32 \
+        -ladvapi32 \
+        -luser32 \
+        -lshell32
+}
+
+INCLUDEPATH += \
+	$$CORE_ROOT_DIR/DesktopEditor/freetype-2.10.4/include \
+	$$CORE_ROOT_DIR/DesktopEditor/freetype-2.10.4/include/freetype
+
+HEADERS += \
+	OFDFile.h \
+	src/Content/ImageObject.h \
+	src/Content/PageBlock.h \
+	src/Content/PathObject.h \
+	src/IOFDElement.h \
+	src/OFDFile_Private.h \
+	src/Base.h \
+	src/Content/Content.h \
+	src/Content/GraphicUnit.h \
+	src/Content/IPageBlock.h \
+	src/Content/Layer.h \
+	src/Content/TextObject.h \
+	src/Document.h \
+	src/Page.h \
+	src/Res.h \
+	src/Types/Color.h \
+	src/Types/ColorSpace.h \
+	src/Types/CommonData.h \
+	src/Types/CompositeGraphicUnit.h \
+	src/Types/DrawParam.h \
+	src/Types/Font.h \
+	src/Types/MultiMedia.h \
+	src/Types/PageArea.h \
+	src/Types/Signature.h \
+	src/Types/TemplatePage.h \
+	src/Utils/Types.h \
+	src/Utils/Utils.h \
+	src/Utils/XmlReader.h
+
+SOURCES += \
+	OFDFile.cpp \
+	src/Content/ImageObject.cpp \
+	src/Content/PageBlock.cpp \
+	src/Content/PathObject.cpp \
+	src/OFDFile_Private.cpp \
+	src/Base.cpp \
+	src/Content/Content.cpp \
+	src/Content/GraphicUnit.cpp \
+	src/Content/Layer.cpp \
+	src/Content/TextObject.cpp \
+	src/Document.cpp \
+	src/Page.cpp \
+	src/Res.cpp \
+	src/Types/Color.cpp \
+	src/Types/ColorSpace.cpp \
+	src/Types/CommonData.cpp \
+	src/Types/CompositeGraphicUnit.cpp \
+	src/Types/DrawParam.cpp \
+	src/Types/Font.cpp \
+	src/Types/MultiMedia.cpp \
+	src/Types/PageArea.cpp \
+	src/Types/Signature.cpp \
+	src/Types/TemplatePage.cpp \
+	src/Utils/Types.cpp \
+	src/Utils/XmlReader.cpp

OFDFile/src/Base.cpp

@@ -0,0 +1,213 @@
+#include "Base.h"
+#include "Utils/Utils.h"
+
+namespace OFD
+{
+#define IF_CHECK_NODE(node_name, varible_name)\
+if (node_name == sNodeName)\
+	varible_name = oLiteReader.GetText2()
+
+#define ELSE_IF_CHECK_NODE(node_name, varible_name)\
+else if (node_name == sNodeName)\
+	varible_name = oLiteReader.GetText2()
+
+EDocUsege GetDocUsage(const std::wstring& wsValue)
+{
+	if (L"EBook" == wsValue)
+		return EDocUsege::EBook;
+	else if (L"ENewsPaper" == wsValue)
+		return EDocUsege::ENewsPaper;
+	else if (L"EMagnize" == wsValue)
+		return EDocUsege::EMagzine;
+	else
+		return EDocUsege::Normal;
+}
+
+CDocInfo::CDocInfo()
+	: m_eDocUsage(EDocUsege::Normal)
+{}
+
+bool CDocInfo::Read(CXmlReader& oLiteReader)
+{
+	if (L"ofd:DocInfo" != oLiteReader.GetName())
+		return false;
+
+	const int nDepth = oLiteReader.GetDepth();
+
+	std::string sNodeName;
+
+	while (oLiteReader.ReadNextSiblingNode(nDepth))
+	{
+		sNodeName = oLiteReader.GetNameA();
+
+		IF_CHECK_NODE("ofd:DocID", m_wsDocId);
+		ELSE_IF_CHECK_NODE("ofd:Title", m_wsTitle);
+		ELSE_IF_CHECK_NODE("ofd:Author", m_wsAuthor);
+		ELSE_IF_CHECK_NODE("ofd:Subject", m_wsSubject);
+		ELSE_IF_CHECK_NODE("ofd:Abstruct", m_wsAbstact);
+		ELSE_IF_CHECK_NODE("ofd:CreationDate", m_wsCreationDate);
+		ELSE_IF_CHECK_NODE("ofd:ModDate", m_wsModDate);
+		ELSE_IF_CHECK_NODE("ofd:Cover", m_wsCover);
+		ELSE_IF_CHECK_NODE("ofd:Creator", m_wsCreator);
+		ELSE_IF_CHECK_NODE("ofd:CreatorVersion", m_wsCreatorVersion);
+		else if ("ofd:DocUsage" == sNodeName)
+			m_eDocUsage = GetDocUsage(oLiteReader.GetText2());
+	}
+
+	return true;
+}
+
+void CDocBody::ReadSignatures(const std::wstring& wsFilePath, IFolder* pFolder)
+{
+	if (wsFilePath.empty() || !CanUseThisPath(wsFilePath, pFolder->getFullFilePath(L"")))
+		return;
+
+	CXmlReader oLiteReader;
+	if (!oLiteReader.FromFile(CombinePaths(pFolder->getFullFilePath(L""), wsFilePath)) || !oLiteReader.ReadNextNode() || L"ofd:Signatures" != oLiteReader.GetName())
+		return;
+
+	const int nDepth = oLiteReader.GetDepth();
+	std::string sNodeName;
+	unsigned int unMaxSignId = 0;
+
+	while (oLiteReader.ReadNextSiblingNode(nDepth))
+	{
+		sNodeName = oLiteReader.GetNameA();
+
+		if ("ofd:MaxSignId" == sNodeName)
+			unMaxSignId = oLiteReader.GetUInteger();
+		else if ("ofd:Signature" == sNodeName)
+		{
+			if (0 == oLiteReader.GetAttributesCount() || !oLiteReader.MoveToFirstAttribute())
+				continue;
+
+			do
+			{
+				if ("BaseLoc" == oLiteReader.GetNameA())
+					AddToContainer(CSignature::Read(oLiteReader.GetText(), pFolder), m_arSignatures);
+			} while (oLiteReader.MoveToNextAttribute());
+
+			oLiteReader.MoveToElement();
+		}
+	}
+}
+
+CDocBody::CDocBody()
+{}
+
+CDocBody::~CDocBody()
+{
+	ClearContainer(m_arSignatures);
+}
+
+CDocBody* CDocBody::Read(CXmlReader& oLiteReader, IFolder* pFolder)
+{
+	if (L"ofd:DocBody" != oLiteReader.GetName())
+		return nullptr;
+
+	const int nDepth = oLiteReader.GetDepth();
+	std::string sNodeName;
+
+	CDocBody *pDocBody = new CDocBody();
+
+	if (nullptr == pDocBody)
+		return nullptr;
+
+	while (oLiteReader.ReadNextSiblingNode(nDepth))
+	{
+		sNodeName = oLiteReader.GetNameA();
+
+		if ("ofd:DocInfo" == sNodeName)
+		{
+			if (!pDocBody->m_oDocInfo.Read(oLiteReader))
+			{
+				delete pDocBody;
+				return nullptr;
+			}
+		}
+		else if ("ofd:DocRoot" == sNodeName)
+			pDocBody->m_oDocument.Read(oLiteReader.GetText2(), pFolder);
+		else if ("ofd:Signatures" == sNodeName)
+			pDocBody->ReadSignatures(oLiteReader.GetText2(), pFolder);
+	}
+
+	return pDocBody;
+}
+
+bool CDocBody::DrawPage(IRenderer* pRenderer, int nPageIndex) const
+{
+	const bool bResult = m_oDocument.DrawPage(pRenderer, nPageIndex);
+
+	for (const CSignature* pSignature : m_arSignatures)
+		if (pSignature->Draw(pRenderer, nPageIndex, nullptr))
+			break;
+
+	return bResult;
+}
+
+unsigned int CDocBody::GetPageCount() const
+{
+	return m_oDocument.GetPageCount();
+}
+
+bool CDocBody::GetPageSize(int nPageIndex, double& dWidth, double& dHeight) const
+{
+	return m_oDocument.GetPageSize(nPageIndex, dWidth, dHeight);
+}
+
+CBase::CBase()
+{}
+
+CBase::~CBase()
+{
+	for (CDocBody* pDocBody : m_arDocBodies)
+		RELEASEOBJECT(pDocBody);
+}
+
+bool CBase::Read(IFolder* pFolder)
+{
+	if (nullptr == pFolder || !pFolder->existsXml(L"OFD.xml"))
+		return false;
+
+	CXmlReader oLiteReader;
+	if (!oLiteReader.FromFile(pFolder->getFullFilePath(L"OFD.xml")) || !oLiteReader.ReadNextNode() || L"ofd:OFD" != oLiteReader.GetName())
+		return false;
+
+	const int nDepth = oLiteReader.GetDepth();
+
+	CDocBody* pDocBody = nullptr;
+
+	while (oLiteReader.ReadNextSiblingNode(nDepth))
+	{
+		pDocBody = CDocBody::Read(oLiteReader, pFolder);
+		if (nullptr != pDocBody)
+			m_arDocBodies.push_back(pDocBody);
+	}
+
+	return !m_arDocBodies.empty();
+}
+
+void CBase::DrawPage(IRenderer* pRenderer, int nPageIndex) const
+{
+	for (const CDocBody* pDocBody : m_arDocBodies)
+		if (pDocBody->DrawPage(pRenderer, nPageIndex))
+			return;
+}
+
+unsigned int CBase::GetPageCount() const
+{
+	unsigned int unCount = 0;
+
+	for (const CDocBody* pDocBody : m_arDocBodies)
+		unCount += pDocBody->GetPageCount();
+
+	return unCount;
+}
+
+void CBase::GetPageSize(int nPageIndex, double& dWidth, double& dHeight) const
+{
+	for (const CDocBody* pDocBody : m_arDocBodies)
+		if (pDocBody->GetPageSize(nPageIndex, dWidth, dHeight))
+			return;
+}
+}

OFDFile/src/Base.h

@@ -0,0 +1,79 @@
+#ifndef BASE_H
+#define BASE_H
+
+#include "../../DesktopEditor/graphics/IRenderer.h"
+#include "../../OfficeUtils/src/ZipFolder.h"
+
+#include "Document.h"
+#include "Types/Signature.h"
+
+namespace OFD
+{
+enum class EDocUsege
+{
+	Normal,
+	EBook,
+	ENewsPaper,
+	EMagzine
+};
+
+class CDocInfo
+{
+	std::wstring m_wsDocId;
+	std::wstring m_wsTitle;
+	std::wstring m_wsAuthor;
+	std::wstring m_wsSubject;
+	std::wstring m_wsAbstact;
+
+	std::wstring m_wsCreationDate;
+	std::wstring m_wsModDate;
+
+	EDocUsege    m_eDocUsage;
+	std::wstring m_wsCover;
+	std::vector<std::wstring> m_arKeywords;
+
+	std::wstring m_wsCreator;
+	std::wstring m_wsCreatorVersion;
+
+	std::vector<std::wstring> m_arCustomData;
+public:
+	CDocInfo();
+	bool Read(CXmlReader& oLiteReader);
+};
+
+class CDocBody
+{
+	CDocInfo  m_oDocInfo;
+	CDocument m_oDocument;
+	// std::wstring m_wsVersions;
+	std::vector<CSignature*> m_arSignatures;
+
+	void ReadSignatures(const std::wstring& wsFilePath, IFolder* pFolder);
+public:
+	CDocBody();
+	~CDocBody();
+
+	static CDocBody* Read(CXmlReader& oLiteReader, IFolder* pFolder);
+
+	bool DrawPage(IRenderer* pRenderer, int nPageIndex) const;
+
+	unsigned int GetPageCount() const;
+	bool GetPageSize(int nPageIndex, double& dWidth, double& dHeight) const;
+};
+
+class CBase
+{
+	std::vector<CDocBody*> m_arDocBodies;
+public:
+	CBase();
+	~CBase();
+
+	bool Read(IFolder* pFolder);
+	void DrawPage(IRenderer* pRenderer, int nPageIndex) const;
+
+	unsigned int GetPageCount() const;
+	void GetPageSize(int nPageIndex, double& dWidth, double& dHeight) const;
+};
+}
+
+#endif // BASE_H

OFDFile/src/Content/Content.cpp

@@ -0,0 +1,41 @@
+#include "Content.h"
+
+namespace OFD
+{
+CContent::CContent()
+{}
+
+CContent::~CContent()
+{
+	for (CLayer* pLayer : m_arLayers)
+		delete pLayer;
+}
+
+bool CContent::Read(CXmlReader& oLiteReader)
+{
+	if (L"ofd:Content" != oLiteReader.GetName())
+		return false;
+
+	const int nDepth = oLiteReader.GetDepth();
+	std::wstring wsNodeName;
+
+	while (oLiteReader.ReadNextSiblingNode(nDepth))
+	{
+		wsNodeName = oLiteReader.GetName();
+
+		if (L"ofd:Layer" == wsNodeName)
+			m_arLayers.push_back(new CLayer(oLiteReader));
+	}
+
+	return false;
+}
+
+void CContent::Draw(IRenderer* pRenderer, const CCommonData& oCommonData) const
+{
+	if (nullptr == pRenderer)
+		return;
+
+	for (const CLayer* pLayer : m_arLayers)
+		pLayer->Draw(pRenderer, oCommonData);
+}
+}

OFDFile/src/Content/Content.h

@@ -0,0 +1,21 @@
+#ifndef CONTENT_H
+#define CONTENT_H
+
+#include "Layer.h"
+#include "../Types/CommonData.h"
+
+namespace OFD
+{
+class CContent
+{
+	std::vector<CLayer*> m_arLayers;
+public:
+	CContent();
+	~CContent();
+
+	bool Read(CXmlReader& oLiteReader);
+	void Draw(IRenderer* pRenderer, const CCommonData& oCommonData) const;
+};
+}
+
+#endif // CONTENT_H

OFDFile/src/Content/GraphicUnit.cpp

@@ -0,0 +1,108 @@
+#include "GraphicUnit.h"
+#include "../../../OOXML/Base/Unit.h"
+
+namespace OFD
+{
+CGraphicUnit::CGraphicUnit(CXmlReader& oLiteReader)
+	: m_bVisible(true), m_unDrawParam(0), m_dLineWidth(0.353),
+	  m_eCap(ECap::Butt), m_eJoin(EJoin::Miter), m_dMiterLimit(4.234),
+	  m_dDashOffset(0.), m_uchAlpha(255)
+{
+	if (0 == oLiteReader.GetAttributesCount() || !oLiteReader.MoveToFirstAttribute())
+		return;
+
+	std::wstring wsAttributeName;
+
+	do
+	{
+		wsAttributeName = oLiteReader.GetName();
+
+		if (L"Boundary" == wsAttributeName)
+			m_oBoundary.Read(oLiteReader.GetTextA());
+		else if (L"Name" == wsAttributeName)
+			m_wsName = oLiteReader.GetText();
+		else if (L"Visible" == wsAttributeName)
+			m_bVisible = oLiteReader.GetBoolean(true);
+		else if (L"CTM" == wsAttributeName)
+			m_oCTM.Read(oLiteReader.GetTextA());
+		else if (L"DrawParam" == wsAttributeName)
+			m_unDrawParam = oLiteReader.GetUInteger(true);
+		else if (L"LineWidth" == wsAttributeName)
+			m_dLineWidth = oLiteReader.GetDouble(true);
+		else if (L"Cap" == wsAttributeName)
+		{
+			const std::wstring wsValue{oLiteReader.GetText()};
+
+			if (L"Butt" == wsValue)
+				m_eCap = ECap::Butt;
+			else if (L"Round" == wsValue)
+				m_eCap = ECap::Round;
+			else if (L"Square" == wsValue)
+				m_eCap = ECap::Square;
+		}
+		else if (L"Join" == wsAttributeName)
+		{
+			const std::wstring wsValue{oLiteReader.GetText()};
+
+			if (L"Miter" == wsValue)
+				m_eJoin = EJoin::Miter;
+			else if (L"Round" == wsValue)
+				m_eJoin = EJoin::Round;
+			else if (L"Bevel" == wsValue)
+				m_eJoin = EJoin::Bevel;
+		}
+		else if (L"MiterLimit" == wsAttributeName)
+			m_dMiterLimit = oLiteReader.GetDouble(true);
+		else if (L"DashOffset" == wsAttributeName)
+			m_dDashOffset = oLiteReader.GetDouble(true);
+		else if (L"Alpha" == wsAttributeName)
+			m_uchAlpha = oLiteReader.GetUInteger(true);
+	} while (oLiteReader.MoveToNextAttribute());
+
+	oLiteReader.MoveToElement();
+}
+
+void CGraphicUnit::Apply(IRenderer* pRenderer, TMatrix& oOldTransform) const
+{
+	if (nullptr == pRenderer)
+		return;
+
+	pRenderer->GetTransform(&oOldTransform.m_dM11, &oOldTransform.m_dM12, &oOldTransform.m_dM21, &oOldTransform.m_dM22, &oOldTransform.m_dDx, &oOldTransform.m_dDy);
+
+	Aggplus::CMatrix oTransform(oOldTransform.m_dM11, oOldTransform.m_dM12, oOldTransform.m_dM21, oOldTransform.m_dM22, oOldTransform.m_dDx, oOldTransform.m_dDy);
+	const Aggplus::CMatrix oCurrentTransform(m_oCTM.m_dM11, m_oCTM.m_dM12, m_oCTM.m_dM21, m_oCTM.m_dM22, m_oBoundary.m_dX + m_oCTM.m_dDx, m_oBoundary.m_dY + m_oCTM.m_dDy);
+
+	oTransform.Multiply(&oCurrentTransform);
+
+	// Clipping
+	pRenderer->put_ClipMode(c_nClipRegionTypeWinding | c_nClipRegionIntersect);
+
+	pRenderer->BeginCommand(c_nResetClipType);
+	pRenderer->EndCommand(c_nResetClipType);
+
+	if (!m_oBoundary.Empty())
+	{
+		pRenderer->BeginCommand(c_nClipType);
+		pRenderer->BeginCommand(c_nPathType);
+		pRenderer->PathCommandStart();
+
+		pRenderer->PathCommandMoveTo(m_oBoundary.m_dX, m_oBoundary.m_dY);
+		pRenderer->PathCommandLineTo(m_oBoundary.m_dX + m_oBoundary.m_dWidth, m_oBoundary.m_dY);
+		pRenderer->PathCommandLineTo(m_oBoundary.m_dX + m_oBoundary.m_dWidth, m_oBoundary.m_dY + m_oBoundary.m_dHeight);
+		pRenderer->PathCommandLineTo(m_oBoundary.m_dX, m_oBoundary.m_dY + m_oBoundary.m_dHeight);
+		pRenderer->PathCommandLineTo(m_oBoundary.m_dX, m_oBoundary.m_dY);
+
+		pRenderer->EndCommand(c_nPathType);
+		pRenderer->EndCommand(c_nClipType);
+		pRenderer->PathCommandEnd();
+	}
+
+	pRenderer->SetTransform(oTransform.sx(), oTransform.shy(), oTransform.shx(), oTransform.sy(), oTransform.tx(), oTransform.ty());
+}
+
+TBox CGraphicUnit::GetBoundary() const
+{
+	return m_oBoundary;
+}
+
+}

OFDFile/src/Content/GraphicUnit.h

@@ -0,0 +1,51 @@
+#ifndef GRAPHICUNIT_H
+#define GRAPHICUNIT_H
+
+#include "../Utils/XmlReader.h"
+#include "../Utils/Types.h"
+
+#include "../../../DesktopEditor/graphics/IRenderer.h"
+
+#include <vector>
+
+namespace OFD
+{
+class CGraphicUnit
+{
+	TBox m_oBoundary;
+	std::wstring m_wsName;
+	bool m_bVisible;
+	TMatrix m_oCTM;
+	unsigned int m_unDrawParam;
+	double m_dLineWidth;
+
+	enum class ECap
+	{
+		Butt,
+		Round,
+		Square
+	} m_eCap;
+
+	enum class EJoin
+	{
+		Miter,
+		Round,
+		Bevel
+	} m_eJoin;
+
+	double m_dMiterLimit;
+	double m_dDashOffset;
+	std::vector<double> m_arDashPattern;
+	unsigned char m_uchAlpha;
+
+	friend class CPathObject;
+public:
+	CGraphicUnit(CXmlReader& oLiteReader);
+
+	void Apply(IRenderer* pRenderer, TMatrix& oOldTransform) const;
+
+	TBox GetBoundary() const;
+};
+}
+
+#endif // GRAPHICUNIT_H

OFDFile/src/Content/IPageBlock.h

@@ -0,0 +1,21 @@
+#ifndef IPAGEBLOCK_H
+#define IPAGEBLOCK_H
+
+#include "../IOFDElement.h"
+
+#include "../../../DesktopEditor/graphics/IRenderer.h"
+#include "../Types/CommonData.h"
+
+namespace OFD
+{
+class IPageBlock : public IOFDElement
+{
+public:
+	IPageBlock(CXmlReader& oLiteReader)
+		: IOFDElement(oLiteReader){};
+	virtual ~IPageBlock(){};
+	virtual void Draw(IRenderer* pRenderer, const CCommonData& oCommonData) const = 0;
+};
+}
+
+#endif // IPAGEBLOCK_H

OFDFile/src/Content/ImageObject.cpp

@@ -0,0 +1,49 @@
+#include "ImageObject.h"
+
+namespace OFD
+{
+CImageObject::CImageObject(CXmlReader& oLiteReader)
+	: IPageBlock(oLiteReader), CGraphicUnit(oLiteReader), m_unMultiMediaID(0)
+{
+	if ("ofd:ImageObject" != oLiteReader.GetNameA() || 0 == oLiteReader.GetAttributesCount() || !oLiteReader.MoveToFirstAttribute())
+		return;
+
+	std::string sAttributeName;
+
+	do
+	{
+		sAttributeName = oLiteReader.GetNameA();
+
+		if ("ResourceID" == sAttributeName)
+		{
+			m_unMultiMediaID = oLiteReader.GetUInteger(true);
+			break;
+		}
+	} while(oLiteReader.MoveToNextAttribute());
+
+	oLiteReader.MoveToElement();
+}
+
+void CImageObject::Draw(IRenderer* pRenderer, const CCommonData& oCommonData) const
+{
+	if (nullptr == pRenderer || nullptr == oCommonData.GetDocumentRes())
+		return;
+
+	const CMultiMedia* pMultiMedia = oCommonData.GetDocumentRes()->GetMultiMedia(m_unMultiMediaID);
+
+	if (nullptr == pMultiMedia)
+		return;
+
+	TMatrix oOldTransform;
+	CGraphicUnit::Apply(pRenderer, oOldTransform);
+
+	const std::wstring wsFilePath = pMultiMedia->GetFilePath();
+
+	if (wsFilePath.empty())
+		return;
+
+	pRenderer->DrawImageFromFile(wsFilePath, 0, 0, 1, 1);
+
+	pRenderer->SetTransform(oOldTransform.m_dM11, oOldTransform.m_dM12, oOldTransform.m_dM21, oOldTransform.m_dM22, oOldTransform.m_dDx, oOldTransform.m_dDy);
+}
+}

OFDFile/src/Content/ImageObject.h

@@ -0,0 +1,19 @@
+#ifndef IMAGEOBJECT_H
+#define IMAGEOBJECT_H
+
+#include "IPageBlock.h"
+#include "GraphicUnit.h"
+
+namespace OFD
+{
+class CImageObject : public IPageBlock, public CGraphicUnit
+{
+	unsigned int m_unMultiMediaID;
+public:
+	CImageObject(CXmlReader& oLiteReader);
+
+	void Draw(IRenderer* pRenderer, const CCommonData& oCommonData) const override;
+};
+}
+
+#endif // IMAGEOBJECT_H

OFDFile/src/Content/Layer.cpp

@@ -0,0 +1,32 @@
+#include "Layer.h"
+
+#include "../../../OOXML/Base/Unit.h"
+
+#include "PageBlock.h"
+
+namespace OFD
+{
+CLayer::CLayer(CXmlReader& oLiteReader)
+	: IPageBlock(oLiteReader), m_eType(EType::Body)
+{
+	if (L"ofd:Layer" != oLiteReader.GetName())
+		return;
+
+	CPageBlock::ReadIntoContainer(oLiteReader, m_arPageBlocks);
+}
+
+CLayer::~CLayer()
+{
+	for (IPageBlock* pPageBlock : m_arPageBlocks)
+		delete pPageBlock;
+}
+
+void CLayer::Draw(IRenderer* pRenderer, const CCommonData& oCommonData) const
+{
+	if (nullptr == pRenderer)
+		return;
+
+	for (const IPageBlock* pPageBlock : m_arPageBlocks)
+		pPageBlock->Draw(pRenderer, oCommonData);
+}
+}

OFDFile/src/Content/Layer.h

@@ -0,0 +1,27 @@
+#ifndef LAYER_H
+#define LAYER_H
+
+#include "IPageBlock.h"
+
+namespace OFD
+{
+class CLayer : public IPageBlock
+{
+	enum class EType
+	{
+		Body,
+		Foreground,
+		Background
+	} m_eType;
+
+	unsigned int m_unID;
+	std::vector<IPageBlock*> m_arPageBlocks;
+public:
+	CLayer(CXmlReader& oLiteReader);
+	~CLayer();
+
+	void Draw(IRenderer* pRenderer, const CCommonData& oCommonData) const override;
+};
+}
+
+#endif // LAYER_H

OFDFile/src/Content/PageBlock.cpp

@@ -0,0 +1,52 @@
+#include "PageBlock.h"
+
+#include "TextObject.h"
+#include "PathObject.h"
+#include "ImageObject.h"
+
+namespace OFD
+{
+CPageBlock::CPageBlock(CXmlReader& oLiteReader)
+	: IPageBlock(oLiteReader)
+{
+	if ("ofd:PageBlock" != oLiteReader.GetNameA() || oLiteReader.IsEmptyNode())
+		return;
+
+	CPageBlock::ReadIntoContainer(oLiteReader, m_arPageBlocks);
+}
+
+void CPageBlock::ReadIntoContainer(CXmlReader& oLiteReader, std::vector<IPageBlock*>& arPageBlocks)
+{
+	const int nDepth = oLiteReader.GetDepth();
+	std::wstring wsNodeName;
+
+	IPageBlock* pPageBlock = nullptr;
+
+	while (oLiteReader.ReadNextSiblingNode(nDepth))
+	{
+		wsNodeName = oLiteReader.GetName();
+		pPageBlock = nullptr;
+
+		if (L"ofd:TextObject" == wsNodeName)
+			pPageBlock = new CTextObject(oLiteReader);
+		else if (L"ofd:PathObject" == wsNodeName)
+			pPageBlock = new CPathObject(oLiteReader);
+		else if (L"ofd:PageBlock" == wsNodeName)
+			pPageBlock = new CPageBlock(oLiteReader);
+		else if (L"ofd:ImageObject" == wsNodeName)
+			pPageBlock = new CImageObject(oLiteReader);
+
+		if (nullptr != pPageBlock)
+			arPageBlocks.push_back(pPageBlock);
+	}
+}
+
+void CPageBlock::Draw(IRenderer* pRenderer, const CCommonData& oCommonData) const
+{
+	if (nullptr == pRenderer)
+		return;
+
+	for (const IPageBlock* pPageBlock : m_arPageBlocks)
+		pPageBlock->Draw(pRenderer, oCommonData);
+}
+}

OFDFile/src/Content/PageBlock.h

@@ -0,0 +1,21 @@
+#ifndef PAGEBLOCK_H
+#define PAGEBLOCK_H
+
+#include "IPageBlock.h"
+#include "../Res.h"
+
+namespace OFD
+{
+class CPageBlock : public IPageBlock
+{
+	std::vector<IPageBlock*> m_arPageBlocks;
+public:
+	CPageBlock(CXmlReader& oLiteReader);
+
+	static void ReadIntoContainer(CXmlReader& oLiteReader, std::vector<IPageBlock*>& arPageBlocks);
+
+	void Draw(IRenderer* pRenderer, const CCommonData& oCommonData) const override;
+};
+}
+
+#endif // PAGEBLOCK_H

OFDFile/src/Content/PathObject.cpp

@@ -0,0 +1,392 @@
+#include "PathObject.h"
+#include "src/Utils/Utils.h"
+
+namespace OFD
+{
+CPathObject::CPathObject(CXmlReader& oLiteReader)
+	: IPageBlock(oLiteReader), CGraphicUnit(oLiteReader),
+	  m_bStroke(true), m_bFill(false), m_eRule(ERule::NonZero),
+	  m_pFillColor(nullptr), m_pStrokeColor(nullptr)
+{
+	if (L"ofd:PathObject" != oLiteReader.GetName() || oLiteReader.IsEmptyElement() || !oLiteReader.IsValid())
+		return;
+
+	if (0 != oLiteReader.GetAttributesCount() && oLiteReader.MoveToFirstAttribute())
+	{
+		std::wstring wsAttributeName;
+
+		do
+		{
+			wsAttributeName = oLiteReader.GetName();
+
+			if (L"Stroke" == wsAttributeName)
+				m_bStroke = oLiteReader.GetBoolean(true);
+			else if (L"Fill" == wsAttributeName)
+				m_bFill = oLiteReader.GetBoolean(true);
+			else if (L"Rule" == wsAttributeName)
+			{
+				if (L"Even-odd" == oLiteReader.GetText())
+					m_eRule = ERule::Even_Odd;
+				else
+					m_eRule = ERule::NonZero;
+			}
+		} while (oLiteReader.MoveToNextAttribute());
+	}
+
+	oLiteReader.MoveToElement();
+
+	const int nDepth = oLiteReader.GetDepth();
+	std::wstring wsNodeName;
+
+	while (oLiteReader.ReadNextSiblingNode(nDepth))
+	{
+		wsNodeName = oLiteReader.GetName();
+
+		if (L"ofd:FillColor" == wsNodeName)
+		{
+			if (nullptr != m_pFillColor)
+				delete m_pFillColor;
+
+			m_pFillColor = new CColor(oLiteReader);
+		}
+		else if (L"ofd:StrokeColor" == wsNodeName)
+		{
+			if (nullptr != m_pStrokeColor)
+				delete m_pStrokeColor;
+
+			m_pStrokeColor = new CColor(oLiteReader);
+		}
+		else if (L"ofd:AbbreviatedData" == wsNodeName)
+		{
+			std::vector<std::string> arValues{Split(oLiteReader.GetText2A(), ' ')};
+
+			std::vector<std::string>::const_iterator itElement = arValues.cbegin();
+
+			char chElementName;
+
+			while (arValues.cend() != itElement)
+			{
+				if (arValues.front().length() != 1)
+				{
+					++itElement;
+					continue;
+				}
+
+				chElementName = (*itElement)[0];
+				++itElement;
+
+				switch (chElementName)
+				{
+					case 'S':
+					{
+						AddElement(CStartElement::ReadFromArray(itElement, arValues.cend()));
+						break;
+					}
+					case 'M':
+					{
+						AddElement(CMoveElement::ReadFromArray(itElement, arValues.cend()));
+						break;
+					}
+					case 'L':
+					{
+						AddElement(CLineElement::ReadFromArray(itElement, arValues.cend()));
+						break;
+					}
+					case 'Q':
+					{
+						AddElement(CBezierCurve2Element::ReadFromArray(itElement, arValues.cend()));
+						break;
+					}
+					case 'B':
+					{
+						AddElement(CBezierCurveElement::ReadFromArray(itElement, arValues.cend()));
+						break;
+					}
+					case 'A':
+					{
+						AddElement(CArcElement::ReadFromArray(itElement, arValues.cend()));
+						break;
+					}
+					case 'C':
+					{
+						AddElement(new CCloseElement());
+						break;
+					}
+					default:
+						continue;
+				}
+			}
+		}
+	}
+}
+
+CPathObject::~CPathObject()
+{
+	for (const IPathElement* pElement : m_arElements)
+		delete pElement;
+}
+
+void CPathObject::AddElement(const IPathElement* pElement)
+{
+	if (nullptr != pElement)
+		m_arElements.push_back(pElement);
+}
+
+void CPathObject::Draw(IRenderer* pRenderer, const CCommonData& oCommonData) const
+{
+	if (nullptr == pRenderer || m_arElements.empty())
+		return;
+
+	TMatrix oOldTransform;
+	CGraphicUnit::Apply(pRenderer, oOldTransform);
+
+	pRenderer->BeginCommand(c_nPathType);
+	pRenderer->PathCommandStart();
+
+	for (const IPathElement* pElement : m_arElements)
+		pElement->Draw(pRenderer);
+
+	int nEndType = -1;
+
+	if (m_bStroke)
+		nEndType = c_nStroke;
+
+	if (m_bFill)
+	{
+		switch (m_eRule)
+		{
+			case ERule::NonZero:
+			{
+				nEndType = (-1 == nEndType ? c_nWindingFillMode : nEndType | c_nWindingFillMode);
+				break;
+			}
+			case ERule::Even_Odd:
+			{
+				nEndType = (-1 == nEndType ? c_nEvenOddFillMode : nEndType | c_nEvenOddFillMode);
+				break;
+			}
+		}
+	}
+
+	if (m_bFill)
+	{
+		pRenderer->put_BrushType(c_BrushTypeSolid);
+
+		if (nullptr != m_pFillColor)
+		{
+			pRenderer->put_BrushColor1(m_pFillColor->ToInt(oCommonData.GetPublicRes()));
+			pRenderer->put_BrushAlpha1(m_pFillColor->GetAlpha());
+		}
+		else
+		{
+			pRenderer->put_BrushColor1(0);
+			pRenderer->put_BrushAlpha1(0xff);
+		}
+	}
+	else
+		pRenderer->put_BrushType(c_BrushTypeNotSet);
+
+
+	if(m_bStroke)
+	{
+		pRenderer->put_PenSize(m_dLineWidth);
+
+		if (nullptr != m_pStrokeColor)
+		{
+			pRenderer->put_PenColor(m_pStrokeColor->ToInt(oCommonData.GetPublicRes()));
+			pRenderer->put_PenAlpha(m_pStrokeColor->GetAlpha());
+		}
+		else
+		{
+			pRenderer->put_PenColor(0);
+			pRenderer->put_PenAlpha(0xff);
+		}
+	}
+	else
+		pRenderer->put_PenSize(0.);
+
+	if (-1 != nEndType)
+		pRenderer->DrawPath(nEndType);
+
+	pRenderer->PathCommandEnd();
+	pRenderer->EndCommand(c_nPathType);
+
+	pRenderer->SetTransform(oOldTransform.m_dM11, oOldTransform.m_dM12, oOldTransform.m_dM21, oOldTransform.m_dM22, oOldTransform.m_dDx, oOldTransform.m_dDy);
+}
+
+CStartElement::CStartElement()
+{}
+
+IPathElement* CStartElement::ReadFromArray(std::vector<std::string>::const_iterator& itBegin, const std::vector<std::string>::const_iterator& itEnd)
+{
+	if (itEnd - itBegin < 2)
+		return nullptr;
+
+	CStartElement *pElement = new CStartElement();
+
+	if (nullptr == pElement)
+		return nullptr;
+
+	if (StringToDouble(*itBegin++, pElement->m_dX) && StringToDouble(*itBegin++, pElement->m_dY))
+		return pElement;
+
+	delete pElement;
+	return nullptr;
+}
+
+void CStartElement::Draw(IRenderer* pRenderer) const
+{
+	if (nullptr != pRenderer)
+		pRenderer->PathCommandMoveTo(m_dX, m_dY);
+}
+
+CMoveElement::CMoveElement()
+{}
+
+IPathElement* CMoveElement::ReadFromArray(std::vector<std::string>::const_iterator& itBegin, const std::vector<std::string>::const_iterator& itEnd)
+{
+	if (itEnd - itBegin < 2)
+		return nullptr;
+
+	CMoveElement *pElement = new CMoveElement();
+
+	if (nullptr == pElement)
+		return nullptr;
+
+	if (StringToDouble(*itBegin++, pElement->m_dX) && StringToDouble(*itBegin++, pElement->m_dY))
+		return pElement;
+
+	delete pElement;
+	return nullptr;
+}
+
+void CMoveElement::Draw(IRenderer* pRenderer) const
+{
+	if (nullptr != pRenderer)
+		pRenderer->PathCommandMoveTo(m_dX, m_dY);
+}
+
+CLineElement::CLineElement()
+{}
+
+IPathElement* CLineElement::ReadFromArray(std::vector<std::string>::const_iterator& itBegin, const std::vector<std::string>::const_iterator& itEnd)
+{
+	if (itEnd - itBegin < 2)
+		return nullptr;
+
+	CLineElement *pElement = new CLineElement();
+
+	if (nullptr == pElement)
+		return nullptr;
+
+	if (StringToDouble(*itBegin++, pElement->m_dX) && StringToDouble(*itBegin++, pElement->m_dY))
+		return pElement;
+
+	delete pElement;
+	return nullptr;
+}
+
+void CLineElement::Draw(IRenderer* pRenderer) const
+{
+	if (nullptr != pRenderer)
+		pRenderer->PathCommandLineTo(m_dX, m_dY);
+}
+
+CBezierCurve2Element::CBezierCurve2Element()
+{}
+
+IPathElement* CBezierCurve2Element::ReadFromArray(std::vector<std::string>::const_iterator& itBegin, const std::vector<std::string>::const_iterator& itEnd)
+{
+	if (itEnd - itBegin < 4)
+		return nullptr;
+
+	CBezierCurve2Element *pElement = new CBezierCurve2Element();
+
+	if (nullptr == pElement)
+		return nullptr;
+
+	if (StringToDouble(*itBegin++, pElement->m_dX1) && StringToDouble(*itBegin++, pElement->m_dY1) &&
+	    StringToDouble(*itBegin++, pElement->m_dX2) && StringToDouble(*itBegin++, pElement->m_dY2))
+		return pElement;
+
+	delete pElement;
+	return nullptr;
+}
+
+void CBezierCurve2Element::Draw(IRenderer* pRenderer) const
+{
+	if (nullptr == pRenderer)
+		return;
+
+	double dX = 0, dY = 0;
+	pRenderer->PathCommandGetCurrentPoint(&dX, &dY);
+	pRenderer->PathCommandCurveTo(dX, dY, m_dX1, m_dY1, m_dX2, m_dY2);
+}
+
+CBezierCurveElement::CBezierCurveElement()
+{}
+
+IPathElement* CBezierCurveElement::ReadFromArray(std::vector<std::string>::const_iterator& itBegin, const std::vector<std::string>::const_iterator& itEnd)
+{
+	if (itEnd - itBegin < 6)
+		return nullptr;
+
+	CBezierCurveElement *pElement = new CBezierCurveElement();
+
+	if (nullptr == pElement)
+		return nullptr;
+
+	if (StringToDouble(*itBegin++, pElement->m_dX1) && StringToDouble(*itBegin++, pElement->m_dY1) &&
+	    StringToDouble(*itBegin++, pElement->m_dX2) && StringToDouble(*itBegin++, pElement->m_dY2) &&
+	    StringToDouble(*itBegin++, pElement->m_dX3) && StringToDouble(*itBegin++, pElement->m_dY3))
+		return pElement;
+
+	delete pElement;
+	return nullptr;
+}
+
+void CBezierCurveElement::Draw(IRenderer* pRenderer) const
+{
+	if (nullptr != pRenderer)
+		pRenderer->PathCommandCurveTo(m_dX1, m_dY1, m_dX2, m_dY2, m_dX3, m_dY3);
+}
+
+CArcElement::CArcElement()
+{}
+
+IPathElement* CArcElement::ReadFromArray(std::vector<std::string>::const_iterator& itBegin, const std::vector<std::string>::const_iterator& itEnd)
+{
+
+	if (itEnd - itBegin < 7)
+		return nullptr;
+
+	CArcElement *pElement = new CArcElement();
+
+	if (nullptr == pElement)
+		return nullptr;
+
+	if (StringToDouble (*itBegin++, pElement->m_dRadiusX) && StringToDouble (*itBegin++, pElement->m_dRadiusY) &&
+	    StringToDouble (*itBegin++, pElement->m_dAngle)   && StringToBoolean(*itBegin++, pElement->m_bLarge)   &&
+	    StringToBoolean(*itBegin++, pElement->m_bSweep)   && StringToDouble (*itBegin++, pElement->m_dX)       &&
+	    StringToDouble (*itBegin++, pElement->m_dY))
+		return pElement;
+
+	delete pElement;
+	return nullptr;
+}
+
+void CArcElement::Draw(IRenderer* pRenderer) const
+{
+	// if (nullptr != pRenderer)
+		// pRenderer->PathCommandArcTo(m_dX, m_dY, m_dRadiusX * 2., m_dRadiusY * 2., )
+}
+
+CCloseElement::CCloseElement()
+{}
+
+void CCloseElement::Draw(IRenderer* pRenderer) const
+{
+	if (nullptr != pRenderer)
+		pRenderer->PathCommandClose();
+}
+}

OFDFile/src/Content/PathObject.h

@@ -0,0 +1,124 @@
+#ifndef PATHOBJECT_H
+#define PATHOBJECT_H
+
+#include "IPageBlock.h"
+#include "GraphicUnit.h"
+
+#include "../Types/Color.h"
+
+namespace OFD
+{
+class IPathElement
+{
+public:
+	IPathElement(){};
+	virtual ~IPathElement(){};
+
+	static IPathElement* ReadFromArray(std::vector<std::string>& arValues) { return nullptr; };
+	virtual void Draw(IRenderer* pRenderer) const = 0;
+};
+
+class CStartElement : public IPathElement
+{
+	double m_dX;
+	double m_dY;
+public:
+	CStartElement();
+	static IPathElement* ReadFromArray(std::vector<std::string>::const_iterator& itBegin, const std::vector<std::string>::const_iterator& itEnd);
+	void Draw(IRenderer* pRenderer) const override;
+};
+
+class CMoveElement : public IPathElement
+{
+	double m_dX;
+	double m_dY;
+public:
+	CMoveElement();
+	static IPathElement* ReadFromArray(std::vector<std::string>::const_iterator& itBegin, const std::vector<std::string>::const_iterator& itEnd);
+	void Draw(IRenderer* pRenderer) const override;
+};
+
+class CLineElement :  public IPathElement
+{
+	double m_dX;
+	double m_dY;
+public:
+	CLineElement();
+	static IPathElement* ReadFromArray(std::vector<std::string>::const_iterator& itBegin, const std::vector<std::string>::const_iterator& itEnd);
+	void Draw(IRenderer* pRenderer) const override;
+};
+
+class CBezierCurve2Element : public IPathElement
+{
+	double m_dX1;
+	double m_dY1;
+	double m_dX2;
+	double m_dY2;
+public:
+	CBezierCurve2Element();
+	static IPathElement* ReadFromArray(std::vector<std::string>::const_iterator& itBegin, const std::vector<std::string>::const_iterator& itEnd);
+	void Draw(IRenderer* pRenderer) const override;
+};
+
+class CBezierCurveElement : public IPathElement
+{
+	double m_dX1;
+	double m_dY1;
+	double m_dX2;
+	double m_dY2;
+	double m_dX3;
+	double m_dY3;
+public:
+	CBezierCurveElement();
+	static IPathElement* ReadFromArray(std::vector<std::string>::const_iterator& itBegin, const std::vector<std::string>::const_iterator& itEnd);
+	void Draw(IRenderer* pRenderer) const override;
+};
+
+class CArcElement : public IPathElement
+{
+	double m_dRadiusX;
+	double m_dRadiusY;
+	double m_dAngle;
+	bool   m_bLarge;
+	bool   m_bSweep;
+	double m_dX;
+	double m_dY;
+public:
+	CArcElement();
+	static IPathElement* ReadFromArray(std::vector<std::string>::const_iterator& itBegin, const std::vector<std::string>::const_iterator& itEnd);
+	void Draw(IRenderer* pRenderer) const override;
+};
+
+class CCloseElement : public IPathElement
+{
+public:
+	CCloseElement();
+	void Draw(IRenderer* pRenderer) const override;
+};
+
+class CPathObject : public IPageBlock, public CGraphicUnit
+{
+	bool m_bStroke;
+	bool m_bFill;
+
+	enum class ERule
+	{
+		NonZero,
+		Even_Odd
+	} m_eRule;
+
+	CColor* m_pFillColor;
+	CColor* m_pStrokeColor;
+
+	std::vector<const IPathElement*> m_arElements;
+
+	void AddElement(const IPathElement* pElement);
+public:
+	CPathObject(CXmlReader& oLiteReader);
+	~CPathObject();
+
+	void Draw(IRenderer* pRenderer, const CCommonData& oCommonData) const override;
+};
+}
+
+#endif // PATHOBJECT_H

OFDFile/src/Content/TextObject.cpp

@@ -0,0 +1,277 @@
+#include "TextObject.h"
+
+#include "../Utils/Utils.h"
+
+namespace OFD
+{
+CTextCode::CTextCode(CXmlReader& oLiteReader)
+{
+	if (L"ofd:TextCode" != oLiteReader.GetName() || oLiteReader.IsEmptyElement() || !oLiteReader.IsValid())
+		return;
+
+	if (0 != oLiteReader.GetAttributesCount() && oLiteReader.MoveToFirstAttribute())
+	{
+		std::wstring wsAttributeName;
+
+		do
+		{
+			wsAttributeName = oLiteReader.GetName();
+
+			if (L"X" == wsAttributeName)
+				m_dX = oLiteReader.GetDouble(true);
+			else if (L"Y" == wsAttributeName)
+				m_dY = oLiteReader.GetDouble(true);
+			else if (L"DeltaX" == wsAttributeName ||
+			         L"DeltaY" == wsAttributeName)
+			{
+				const std::vector<std::string> arValues{oLiteReader.GetArrayStrings(true)};
+
+				std::vector<double>& arDelta{L"DeltaX" == wsAttributeName ? m_arDeltaX : m_arDeltaY};
+
+				arDelta.reserve(arValues.size());
+				double dValue = 0.;
+
+				for (unsigned int unIndex = 0; unIndex < arValues.size(); ++unIndex)
+				{
+					if ("g" == arValues[unIndex] && unIndex + 2 < arValues.size())
+					{
+						unsigned int unCount = 0;
+
+						if (!StringToUInteger(arValues[unIndex + 1], unCount) || !StringToDouble(arValues[unIndex + 2], dValue))
+							continue;
+
+						unIndex += 2;
+
+						arDelta.insert(arDelta.end(), unCount, dValue);
+					}
+					else if (StringToDouble(arValues[unIndex], dValue))
+						arDelta.push_back(dValue);
+					else
+						arDelta.push_back(0.);
+				}
+			}
+		} while (oLiteReader.MoveToNextAttribute());
+	}
+
+	oLiteReader.MoveToElement();
+
+	m_wsText = oLiteReader.GetText2();
+}
+
+void CTextCode::Draw(IRenderer* pRenderer, unsigned int& unIndex, const std::vector<TCGTransform>& arCGTransforms) const
+{
+	if (nullptr == pRenderer || m_wsText.empty())
+		return;
+
+	double dX = m_dX, dY = m_dY, dDeltaX = 0, dDeltaY = 0;
+	bool bDrawed = false;
+
+	for (unsigned int unGlyphIndex = 0; unGlyphIndex < m_wsText.length(); ++unGlyphIndex)
+	{
+		if (!arCGTransforms.empty())
+		{
+			for (const TCGTransform& oCGTransform : arCGTransforms)
+			{
+				if (oCGTransform.Draw(pRenderer, m_wsText[unGlyphIndex], unIndex, dX, dY))
+				{
+					bDrawed = true;
+					break;
+				}
+			}
+		}
+
+		if (!bDrawed)
+		{
+			pRenderer->CommandDrawTextCHAR(m_wsText[unGlyphIndex], dX, dY, 0, 0);
+			++unIndex;
+		}
+
+		if (unGlyphIndex < m_arDeltaX.size())
+			dDeltaX = m_arDeltaX[unGlyphIndex];
+
+		if (unGlyphIndex < m_arDeltaY.size())
+			dDeltaY = m_arDeltaY[unGlyphIndex];
+
+		dX += dDeltaX;
+		dY += dDeltaY;
+	}
+}
+
+CTextObject::CTextObject(CXmlReader& oLiteReader)
+	: IPageBlock(oLiteReader), CGraphicUnit(oLiteReader),
+	  m_bStroke(false), m_bFill(true), m_dHScale(1.),
+	  m_unReadDirection(0), m_unCharDirection(0), m_unWeight(400),
+	  m_bItalic(false),
+	  m_pFillColor(nullptr), m_pStrokeColor(nullptr), m_unFontID(0)
+{
+	if (L"ofd:TextObject" != oLiteReader.GetName() || oLiteReader.IsEmptyElement() || !oLiteReader.IsValid())
+		return;
+
+	if (0 != oLiteReader.GetAttributesCount() && oLiteReader.MoveToFirstAttribute())
+	{
+		std::wstring wsAttributeName;
+
+		do
+		{
+			wsAttributeName = oLiteReader.GetName();
+
+			if (L"Font" == wsAttributeName)
+				m_unFontID = oLiteReader.GetUInteger(true);
+			else if (L"Size" == wsAttributeName)
+				m_dSize = oLiteReader.GetDouble(true);
+			else if (L"Stroke" == wsAttributeName)
+				m_bStroke = oLiteReader.GetBoolean(true);
+			else if (L"Fill" == wsAttributeName)
+				m_bFill = oLiteReader.GetBoolean(true);
+			else if (L"HScale" == wsAttributeName)
+				m_dHScale = oLiteReader.GetDouble(true);
+			else if (L"ReadDirection" == wsAttributeName)
+				m_unReadDirection = oLiteReader.GetUInteger(true);
+			else if (L"CharDirection" == wsAttributeName)
+				m_unCharDirection =oLiteReader.GetUInteger(true);
+			else if (L"Weight" == wsAttributeName)
+				m_unWeight = oLiteReader.GetUInteger(true);
+			else if (L"Italic" == wsAttributeName)
+				m_bItalic = oLiteReader.GetBoolean(true);
+		} while (oLiteReader.MoveToNextAttribute());
+	}
+
+	oLiteReader.MoveToElement();
+
+	const int nDepth = oLiteReader.GetDepth();
+	std::wstring wsNodeName;
+
+	while (oLiteReader.ReadNextSiblingNode(nDepth))
+	{
+		wsNodeName = oLiteReader.GetName();
+
+		if (L"ofd:FillColor" == wsNodeName)
+		{
+			if (nullptr != m_pFillColor)
+				delete m_pFillColor;
+
+			m_pFillColor = new CColor(oLiteReader);
+		}
+		else if (L"ofd:StrokeColor" == wsNodeName)
+		{
+			if (nullptr != m_pStrokeColor)
+				delete m_pStrokeColor;
+
+			m_pStrokeColor = new CColor(oLiteReader);
+		}
+		else if (L"ofd:TextCode" == wsNodeName)
+			m_arTextCodes.push_back(new CTextCode(oLiteReader));
+		else if (L"ofd:CGTransform" == wsNodeName)
+			m_arCGTransforms.push_back(TCGTransform::Read(oLiteReader));
+	}
+}
+
+CTextObject::~CTextObject()
+{
+	if (nullptr != m_pFillColor)
+		delete m_pFillColor;
+
+	if (nullptr != m_pStrokeColor)
+		delete m_pStrokeColor;
+
+	for (const CTextCode* pTextCode : m_arTextCodes)
+		delete pTextCode;
+}
+
+void CTextObject::Draw(IRenderer* pRenderer, const CCommonData& oCommonData) const
+{
+	if (nullptr == pRenderer || m_arTextCodes.empty())
+		return;
+
+	const CFont* pFont = oCommonData.GetPublicRes()->GetFont(m_unFontID);
+
+	if (nullptr == pFont)
+		return;
+
+	pFont->Apply(pRenderer);
+
+	TMatrix oOldTransform;
+	CGraphicUnit::Apply(pRenderer, oOldTransform);
+
+	if (m_bFill)
+	{
+		pRenderer->put_BrushType(c_BrushTypeSolid);
+
+		if (nullptr != m_pFillColor)
+		{
+			pRenderer->put_BrushColor1(m_pFillColor->ToInt(oCommonData.GetPublicRes()));
+			pRenderer->put_BrushAlpha1(m_pFillColor->GetAlpha());
+		}
+		else
+		{
+			pRenderer->put_BrushColor1(0);
+			pRenderer->put_BrushAlpha1(0xff);
+		}
+	}
+	else
+		pRenderer->put_BrushType(c_BrushTypeNotSet);
+
+	pRenderer->put_FontSize(m_dSize * 72. / 25.4);
+
+	unsigned int unGlyphsIndex = 0;
+
+	for (const CTextCode* pTextCode : m_arTextCodes)
+		pTextCode->Draw(pRenderer, unGlyphsIndex, m_arCGTransforms);
+
+	pRenderer->SetTransform(oOldTransform.m_dM11, oOldTransform.m_dM12, oOldTransform.m_dM21, oOldTransform.m_dM22, oOldTransform.m_dDx, oOldTransform.m_dDy);
+}
+
+TCGTransform TCGTransform::Read(CXmlReader& oLiteReader)
+{
+	TCGTransform oCGTransform;
+
+	if (L"ofd:CGTransform" != oLiteReader.GetName() || oLiteReader.IsEmptyElement())
+		return oCGTransform;
+
+	if (0 != oLiteReader.GetAttributesCount() && oLiteReader.MoveToFirstAttribute())
+	{
+		std::wstring wsAttributeName;
+
+		do
+		{
+			wsAttributeName = oLiteReader.GetName();
+
+			if (L"CodePosition" == wsAttributeName)
+				oCGTransform.m_unCodePosition = oLiteReader.GetUInteger(true);
+			else if (L"CodeCount" == wsAttributeName)
+				oCGTransform.m_unCodeCount = oLiteReader.GetUInteger(true);
+			else if (L"GlyphCount" == wsAttributeName)
+				oCGTransform.m_unGlyphCount = oLiteReader.GetUInteger(true);
+		} while (oLiteReader.MoveToNextAttribute());
+	}
+
+	oLiteReader.MoveToElement();
+
+	const int nDepth = oLiteReader.GetDepth();
+	unsigned int unCount = 0;
+
+	while (oLiteReader.ReadNextSiblingNode(nDepth) && unCount < oCGTransform.m_unGlyphCount)
+	{
+		if ("ofd:Glyphs" == oLiteReader.GetNameA())
+		{
+			oCGTransform.m_arGlyphs.push_back(oLiteReader.GetUInteger());
+			++unCount;
+		}
+	}
+
+	return oCGTransform;
+}
+
+bool TCGTransform::Draw(IRenderer* pRenderer, const LONG& lUnicode, unsigned int& unIndex, double dX, double dY) const
+{
+	if (m_unCodePosition != unIndex || 0 == m_unCodeCount || 0 == m_unGlyphCount)
+		return false;
+
+	for (unsigned int unGlyphCount = 0; unGlyphCount < m_unGlyphCount; ++unGlyphCount)
+		pRenderer->CommandDrawTextExCHAR(lUnicode, m_arGlyphs[unGlyphCount], dX, dY, 0, 0);
+
+	unIndex += m_unCodeCount;
+
+	return true;
+}
+}

OFDFile/src/Content/TextObject.h

@@ -0,0 +1,65 @@
+#ifndef TEXTOBJECT_H
+#define TEXTOBJECT_H
+
+#include "IPageBlock.h"
+#include "GraphicUnit.h"
+
+#include "../Types/Color.h"
+
+namespace OFD
+{
+struct TCGTransform
+{
+	unsigned int m_unCodePosition;
+	unsigned int m_unCodeCount;
+	unsigned int m_unGlyphCount;
+
+	std::vector<unsigned int> m_arGlyphs;
+
+	static TCGTransform Read(CXmlReader& oLiteReader);
+
+	bool Draw(IRenderer* pRenderer, const LONG& lUnicode, unsigned int& unIndex, double dX, double dY) const;
+};
+
+class CTextCode
+{
+	double m_dX;
+	double m_dY;
+
+	std::vector<double> m_arDeltaX;
+	std::vector<double> m_arDeltaY;
+
+	std::wstring m_wsText;
+public:
+	CTextCode(CXmlReader& oLiteReader);
+
+	void Draw(IRenderer* pRenderer, unsigned int& unIndex, const std::vector<TCGTransform>& arCGTransforms) const;
+};
+
+class CTextObject : public IPageBlock, public CGraphicUnit
+{
+	double m_dSize;
+	bool m_bStroke;
+	bool m_bFill;
+	double m_dHScale;
+	unsigned int m_unReadDirection;
+	unsigned int m_unCharDirection;
+	unsigned int m_unWeight;
+	bool m_bItalic;
+
+	CColor* m_pFillColor;
+	CColor* m_pStrokeColor;
+
+	unsigned int m_unFontID;
+
+	std::vector<const CTextCode*> m_arTextCodes;
+	std::vector<TCGTransform>     m_arCGTransforms;
+public:
+	CTextObject(CXmlReader& oLiteReader);
+	~CTextObject();
+
+	void Draw(IRenderer* pRenderer, const CCommonData& oCommonData) const override;
+};
+}
+
+#endif // TEXTOBJECT_H

OFDFile/src/Document.cpp

@@ -0,0 +1,142 @@
+#include "Document.h"
+
+#include "Utils/Utils.h"
+
+#include "../../DesktopEditor/common/Path.h"
+
+namespace OFD
+{
+CPermission::CPermission()
+	: m_bEdit(true), m_bAnnot(true), m_bExport(true),
+	  m_bSignature(true), m_bWatermark(true), m_bPrintScreen(true)
+{}
+
+bool CPermission::Read(CXmlReader& oLiteReader)
+{
+	if (L"ofd:Permission" != oLiteReader.GetName())
+		return false;
+
+	const int nDepth = oLiteReader.GetDepth();
+	std::wstring wsNodeName;
+
+	while (oLiteReader.ReadNextSiblingNode(nDepth))
+	{
+		wsNodeName = oLiteReader.GetName();
+
+		if (L"ofd:Edit" == wsNodeName)
+			m_bEdit = oLiteReader.GetBoolean();
+	}
+
+	return true;
+}
+
+CDocument::CDocument()
+{}
+
+CDocument::~CDocument()
+{
+	for (std::pair<int, CPage*> oElement : m_mPages)
+		delete oElement.second;
+}
+
+bool CDocument::Empty() const
+{
+	return m_mPages.empty();
+}
+
+bool CDocument::Read(const std::wstring& wsFilePath, IFolder* pFolder)
+{
+	if (wsFilePath.empty() || !CanUseThisPath(wsFilePath, pFolder->getFullFilePath(L"")))
+		return false;
+
+	CXmlReader oLiteReader;
+	if (!oLiteReader.FromFile(pFolder->getFullFilePath(wsFilePath)) || !oLiteReader.ReadNextNode() || L"ofd:Document" != oLiteReader.GetName())
+		return false;
+
+	const std::wstring wsCoreDirectory{pFolder->getFullFilePath(NSSystemPath::GetDirectoryName(wsFilePath))};
+	const int nDepth = oLiteReader.GetDepth();
+	std::wstring wsNodeName;
+
+	while (oLiteReader.ReadNextSiblingNode(nDepth))
+	{
+		wsNodeName = oLiteReader.GetName();
+
+		if (L"ofd:CommonData" == wsNodeName)
+			m_oCommonData.Read(oLiteReader, wsCoreDirectory);
+		else if (L"ofd:Pages" == wsNodeName)
+		{
+			const int nPagesDepth = oLiteReader.GetDepth();
+
+			int nID = -1;
+			std::wstring wsBaseLoc;
+
+
+			while (oLiteReader.ReadNextSiblingNode(nPagesDepth))
+			{
+				if (L"ofd:Page" != oLiteReader.GetName() || 2 > oLiteReader.GetAttributesCount() || !oLiteReader.MoveToFirstAttribute())
+					continue;
+
+				do
+				{
+					if (L"ID" == oLiteReader.GetName())
+						nID = oLiteReader.GetInteger(true);
+					else if (L"BaseLoc" == oLiteReader.GetName())
+						wsBaseLoc = oLiteReader.GetText();
+				}while (oLiteReader.MoveToNextAttribute());
+
+				if (wsBaseLoc.empty())
+					continue;
+
+				if (-1 == nID)
+					nID = m_mPages.size() + 1;
+
+				CPage* pPage = CPage::Read(wsBaseLoc, wsCoreDirectory);
+
+				if (nullptr != pPage)
+					m_mPages.insert(std::make_pair(m_mPages.size(), pPage));
+
+				wsBaseLoc.clear();
+				oLiteReader.MoveToElement();
+			}
+		}
+		else if (L"ofd:Permissions" == wsNodeName)
+			m_oPermission.Read(oLiteReader);
+	}
+
+	return false;
+}
+
+bool CDocument::DrawPage(IRenderer* pRenderer, int nPageIndex) const
+{
+	if (nullptr == pRenderer)
+		return false;
+
+	std::map<unsigned int, CPage*>::const_iterator itFound = m_mPages.find(nPageIndex);
+
+	if (itFound == m_mPages.cend())
+		return false;
+
+	itFound->second->Draw(pRenderer, m_oCommonData);
+
+	return true;
+}
+
+unsigned int CDocument::GetPageCount() const
+{
+	return m_mPages.size();
+}
+
+bool CDocument::GetPageSize(int nPageIndex, double& dWidth, double& dHeight) const
+{
+	m_oCommonData.GetPageSize(dWidth, dHeight);
+
+	std::map<unsigned int, CPage*>::const_iterator itFound = m_mPages.find(nPageIndex);
+
+	if (itFound == m_mPages.cend())
+		return false;
+
+	itFound->second->GetPageSize(dWidth, dHeight);
+
+	return true;
+}
+}

OFDFile/src/Document.h

@@ -0,0 +1,46 @@
+#ifndef DOCUMENT_H
+#define DOCUMENT_H
+
+#include "Page.h"
+
+#include "../../DesktopEditor/graphics/IRenderer.h"
+#include "../../OfficeUtils/src/ZipFolder.h"
+
+namespace OFD
+{
+class CPermission
+{
+	bool m_bEdit;
+	bool m_bAnnot;
+	bool m_bExport;
+	bool m_bSignature;
+	bool m_bWatermark;
+	bool m_bPrintScreen;
+public:
+	CPermission();
+
+	bool Read(CXmlReader& oLiteReader);
+};
+
+class CDocument
+{
+	CCommonData m_oCommonData;
+	CPermission m_oPermission;
+
+	std::map<unsigned int, CPage*> m_mPages;
+public:
+	CDocument();
+	~CDocument();
+
+	bool Empty() const;
+
+	bool Read(const std::wstring& wsFilePath, IFolder* pFolder);
+
+	bool DrawPage(IRenderer* pRenderer, int nPageIndex) const;
+
+	unsigned int GetPageCount() const;
+	bool GetPageSize(int nPageIndex, double& dWidth, double &dHeight) const;
+};
+}
+
+#endif // DOCUMENT_H

OFDFile/src/IOFDElement.h

@@ -0,0 +1,35 @@
+#ifndef IOFDELEMENT_H
+#define IOFDELEMENT_H
+
+#include "Utils/XmlReader.h"
+
+namespace OFD
+{
+class IOFDElement
+{
+	unsigned int m_unID;
+public:
+	IOFDElement(CXmlReader& oLiteReader)
+		: m_unID(0)
+	{
+		if (0 != oLiteReader.GetAttributesCount() && oLiteReader.MoveToFirstAttribute())
+		{
+			do
+			{
+				if (L"ID" == oLiteReader.GetName())
+					m_unID = oLiteReader.GetUInteger(true);
+			} while (oLiteReader.MoveToNextAttribute());
+
+			oLiteReader.MoveToElement();
+		}
+	};
+	virtual ~IOFDElement(){};
+
+	unsigned int GetID() const
+	{
+		return m_unID;
+	}
+};
+}
+
+#endif // IOFDELEMENT_H