Merge pull request 'Fix hwp conversion' (#217) from fix/hwp into release/v8.3.0

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

Apple/IWork.cpp

@@ -0,0 +1,141 @@
+#include "IWork.h"
+#include "../DesktopEditor/common/File.h"
+#include "../DesktopEditor/common/Directory.h"
+
+#include <libetonyek/libetonyek.h>
+#include <libodfgen/OdtGenerator.hxx>
+#include <libodfgen/OdsGenerator.hxx>
+#include <libodfgen/OdpGenerator.hxx>
+#include <libodfgen/test/StringDocumentHandler.hxx>
+
+#include <memory>
+#include <fstream>
+
+class CIWorkFile_Private
+{
+public:
+	std::wstring m_sTempDirectory;
+
+public:
+	CIWorkFile_Private()
+	{
+	}
+	~CIWorkFile_Private()
+	{
+	}
+};
+
+CIWorkFile::CIWorkFile()
+{
+	m_internal = new CIWorkFile_Private();
+}
+
+CIWorkFile::~CIWorkFile()
+{
+	delete m_internal;
+}
+
+#if !defined(_WIN32) && !defined(_WIN64)
+	#define DATA_TYPE_INPUTFILE std::string
+#else
+	#define DATA_TYPE_INPUTFILE std::wstring
+#endif
+
+bool GetRVNGInputStream(const DATA_TYPE_INPUTFILE& sFile, std::shared_ptr<librevenge::RVNGInputStream>& oRVNGInputStream, libetonyek::EtonyekDocument::Type& oDocumentType)
+{
+	oRVNGInputStream.reset(new librevenge::RVNGFileStream(sFile.c_str()));
+
+	oDocumentType = libetonyek::EtonyekDocument::TYPE_UNKNOWN;
+	const libetonyek::EtonyekDocument::Confidence confidence = libetonyek::EtonyekDocument::isSupported(oRVNGInputStream.get(), &oDocumentType);
+
+	return libetonyek::EtonyekDocument::CONFIDENCE_NONE != confidence;
+}
+
+IWorkFileType CIWorkFile::GetType(const std::wstring& sFile) const
+{
+	//TODO:: так как на данный момент мы работает только напрямую с файлом, то работа с директорией нам пока не нужна
+	if (NSDirectory::PathIsDirectory(sFile))
+		return IWorkFileType::None;
+
+	std::shared_ptr<librevenge::RVNGInputStream> input;
+	libetonyek::EtonyekDocument::Type oDocumentType;
+
+	#if !defined(_WIN32) && !defined(_WIN64)
+	std::string sFileA = U_TO_UTF8(sFile);
+	if (!GetRVNGInputStream(sFileA, input, oDocumentType))
+		return IWorkFileType::None;
+	#else
+	if (!GetRVNGInputStream(sFile, input, oDocumentType))
+		return IWorkFileType::None;
+	#endif
+
+	switch (oDocumentType)
+	{
+	case libetonyek::EtonyekDocument::TYPE_PAGES:
+		return IWorkFileType::Pages;
+	case libetonyek::EtonyekDocument::TYPE_NUMBERS:
+		return IWorkFileType::Numbers;
+	case libetonyek::EtonyekDocument::TYPE_KEYNOTE:
+		return IWorkFileType::Keynote;
+	default:
+		break;
+	}
+
+	return IWorkFileType::None;
+}
+
+template<class Generator>
+int Convert(const std::wstring& wsOutputFile, std::shared_ptr<librevenge::RVNGInputStream>& ptrInput, const std::wstring& wsPassword = L"", const std::wstring& wsTempDirectory = L"")
+{
+	StringDocumentHandler content;
+	Generator generator;
+	generator.addDocumentHandler(&content, ODF_FLAT_XML);
+
+	bool bRes = libetonyek::EtonyekDocument::parse(ptrInput.get(), &generator);
+	if (!bRes)
+		return 1;
+
+	const std::string sOutputFileA = U_TO_UTF8(wsOutputFile);
+	std::ofstream output(sOutputFileA.c_str());
+	output << content.cstr();
+
+	if (output.bad())
+		return -1;
+
+	return 0;
+}
+
+int CIWorkFile::Convert2Odf(const std::wstring& sFile, const std::wstring& sOutputFile) const
+{
+	//TODO:: так как на данный момент мы работает только напрямую с файлом, то работа с директорией нам пока не нужна
+	if (NSDirectory::PathIsDirectory(sFile))
+		return -1;
+
+	std::shared_ptr<librevenge::RVNGInputStream> input;
+	libetonyek::EtonyekDocument::Type oDocumentType;
+
+	#if !defined(_WIN32) && !defined(_WIN64)
+		std::string sFileA = U_TO_UTF8(sFile);
+		if (!GetRVNGInputStream(sFileA, input, oDocumentType))
+			return -1;
+	#else
+		if (!GetRVNGInputStream(sFile, input, oDocumentType))
+			return -1;
+	#endif
+
+	switch (oDocumentType)
+	{
+	case libetonyek::EtonyekDocument::TYPE_PAGES:   return Convert<OdtGenerator>(sOutputFile, input);
+	case libetonyek::EtonyekDocument::TYPE_NUMBERS: return Convert<OdsGenerator>(sOutputFile, input);
+	case libetonyek::EtonyekDocument::TYPE_KEYNOTE: return Convert<OdpGenerator>(sOutputFile, input);
+	default:
+		break;
+	}
+
+	return -1;
+}
+
+void CIWorkFile::SetTmpDirectory(const std::wstring& sFolder)
+{
+	m_internal->m_sTempDirectory = sFolder;
+}

Apple/IWork.h

@@ -0,0 +1,36 @@
+#ifndef _IWORKFILE_IWORKFILE_H
+#define _IWORKFILE_IWORKFILE_H
+
+#include <string>
+
+#ifndef IWORK_USE_DYNAMIC_LIBRARY
+#define IWORK_FILE_DECL_EXPORT
+#else
+#include "../DesktopEditor/common/base_export.h"
+#define IWORK_FILE_DECL_EXPORT Q_DECL_EXPORT
+#endif
+
+enum class IWorkFileType
+{
+	Pages   = 0,
+	Numbers = 1,
+	Keynote = 2,
+
+	None    = 255
+};
+
+class CIWorkFile_Private;
+class IWORK_FILE_DECL_EXPORT CIWorkFile
+{
+private:
+	CIWorkFile_Private* m_internal;
+public:
+	CIWorkFile();
+	~CIWorkFile();
+
+	IWorkFileType GetType(const std::wstring& sFile) const;
+	int Convert2Odf(const std::wstring& sFile, const std::wstring& sOutputFile) const;
+	void SetTmpDirectory(const std::wstring& sFolder);
+};
+
+#endif // _IWORKFILE_IWORKFILE_H

Apple/IWork.pro

@@ -0,0 +1,46 @@
+QT -= core
+QT -= gui
+
+VERSION = 0.0.0.1
+TARGET = IWorkFile
+TEMPLATE = lib
+
+CONFIG += shared
+CONFIG += plugin
+
+DEFINES += IWORK_USE_DYNAMIC_LIBRARY
+
+CORE_ROOT_DIR = $$PWD/..
+PWD_ROOT_DIR = $$PWD
+include($$CORE_ROOT_DIR/Common/base.pri)
+
+ADD_DEPENDENCY(kernel, UnicodeConverter)
+
+INCLUDEPATH += \
+	$$PWD
+
+core_android:DEFINES += NOT_USE_PTHREAD_CANCEL USE_FILE32API
+
+# BOOST
+CONFIG += core_boost_regex
+include($$CORE_ROOT_DIR/Common/3dParty/boost/boost.pri)
+
+# ZLIB
+CONFIG += build_all_zlib build_zlib_as_sources
+include($$PWD/../OfficeUtils/OfficeUtils.pri)
+
+# LIBXML
+CONFIG += core_static_link_xml_full
+CONFIG += core_only_libxml
+include($$PWD/../DesktopEditor/xml/build/qt/libxml2.pri)
+
+#
+include($$CORE_ROOT_DIR/Common/3dParty/apple/apple.pri)
+
+# TEST
+HEADERS += $$ODF_LIB_ROOT/test/StringDocumentHandler.h
+SOURCES += $$ODF_LIB_ROOT/test/StringDocumentHandler.cxx
+
+SOURCES += IWork.cpp
+
+HEADERS += IWork.h

Apple/test/main.cpp

@@ -0,0 +1,45 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2023
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
+ * street, Riga, Latvia, EU, LV-1050.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+
+#include "../IWork.h"
+#include "../../DesktopEditor/common/File.h"
+
+int main(int argc, char *argv[])
+{
+	CIWorkFile oFile;
+
+	std::wstring sExamplesDir = NSFile::GetProcessDirectory() + L"/../examples";
+	oFile.Convert2Odf(sExamplesDir + L"/new.pages", sExamplesDir + L"/out_new.odt");
+	oFile.Convert2Odf(sExamplesDir + L"/old.pages", sExamplesDir + L"/out_old.odt");
+
+	return 0;
+}

Apple/test/test.pro

@@ -0,0 +1,20 @@
+CONFIG -= qt
+QT -= core gui
+
+TARGET = test
+CONFIG   += console
+CONFIG   -= app_bundle
+TEMPLATE = app
+
+CORE_ROOT_DIR = $$PWD/../..
+PWD_ROOT_DIR = $$PWD
+include($$CORE_ROOT_DIR/Common/base.pri)
+
+ADD_DEPENDENCY(UnicodeConverter, kernel, IWorkFile)
+
+core_linux:include($$PWD/../../Common/3dParty/icu/icu.pri)
+core_windows:LIBS += -lgdi32 -ladvapi32 -luser32 -lshell32
+
+SOURCES += main.cpp
+
+DESTDIR = $$PWD/build

Common/3dParty/apple/.gitignore

@@ -0,0 +1,8 @@
+# Ignore everything in this directory
+glm
+mdds
+librevenge
+libodfgen
+libetonyek
+# Except this file
+!.gitignore

Common/3dParty/apple/apple.pri

@@ -0,0 +1,36 @@
+INCLUDEPATH += $$PWD
+
+# LIBREVENGE
+REVENGE_LIB_ROOT = $$PWD/librevenge
+
+INCLUDEPATH += \
+	$$REVENGE_LIB_ROOT/inc
+
+HEADERS += $$files($$REVENGE_LIB_ROOT/inc/*.h, true)
+HEADERS += $$files($$REVENGE_LIB_ROOT/src/lib/*.h, true)
+SOURCES += $$files($$REVENGE_LIB_ROOT/src/lib/*.cpp, true)
+
+# LIBODFGEN
+ODF_LIB_ROOT = $$PWD/libodfgen
+
+INCLUDEPATH += \
+	$$ODF_LIB_ROOT/inc
+
+HEADERS += $$files($$ODF_LIB_ROOT/inc/libodfgen/*.hxx, true)
+HEADERS += $$files($$ODF_LIB_ROOT/src/*.hxx, true)
+SOURCES += $$files($$ODF_LIB_ROOT/src/*.cxx, true)
+
+# LIBETONYEK
+ETONYEK_LIB_ROOT = $$PWD/libetonyek
+
+INCLUDEPATH += \
+	$$ETONYEK_LIB_ROOT/inc \
+	$$ETONYEK_LIB_ROOT/src/lib \
+	$$ETONYEK_LIB_ROOT/src/lib/contexts \
+	$$PWD/mdds/include \
+	$$PWD/glm
+
+HEADERS += $$files($$ETONYEK_LIB_ROOT/inc/libetonyek/*.h, true)
+HEADERS += $$files($$ETONYEK_LIB_ROOT/src/lib/*.h, true)
+SOURCES += $$files($$ETONYEK_LIB_ROOT/src/lib/*.cpp, true)
+

Common/3dParty/apple/fetch.py

@@ -0,0 +1,121 @@
+import sys
+sys.path.append('../../../../build_tools/scripts')
+import base
+import os
+
+if not base.is_dir("glm"):
+    base.cmd("git", ["clone", "https://github.com/g-truc/glm.git"])
+    base.cmd_in_dir("glm", "git", ["checkout", "33b4a621a697a305bc3a7610d290677b96beb181", "--quiet"])
+
+if not base.is_dir("mdds"):
+    base.cmd("git", ["clone", "https://github.com/kohei-us/mdds.git"])
+    base.cmd_in_dir("mdds", "git", ["checkout", "0783158939c6ce4b0b1b89e345ab983ccb0f0ad0"], "--quiet")
+
+    fix_cpp_version  = "#if __cplusplus < 201402L\n"
+    fix_cpp_version += "#ifndef _MSC_VER\n"
+    fix_cpp_version += "namespace std {\n"
+    fix_cpp_version += "  template<bool __v>\n"
+    fix_cpp_version += "  using bool_constant = integral_constant<bool, __v>;\n\n"
+    fix_cpp_version += "  template <class... _Types>\n"
+    fix_cpp_version += "  using void_t = void;\n"
+    fix_cpp_version += "}\n#endif\n"
+    fix_cpp_version += "#endif\n\n"
+    fix_cpp_version += "namespace mdds {"
+
+    base.replaceInFile("./mdds/include/mdds/global.hpp", "namespace mdds {", fix_cpp_version)
+
+if not base.is_dir("librevenge"):
+    base.cmd("git", ["clone", "https://github.com/Distrotech/librevenge.git"])
+    base.cmd_in_dir("librevenge", "git", ["checkout", "becd044b519ab83893ad6398e3cbb499a7f0aaf4", "--quiet"])
+
+    stat_windows = ""
+    stat_windows += "#if !defined(S_ISREG) && defined(S_IFMT) && defined(S_IFREG)\n"
+    stat_windows += "#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)\n"
+    stat_windows += "#endif\n"
+    stat_windows += "#if !defined(S_ISDIR) && defined(S_IFMT) && defined(S_IFDIR)\n"
+    stat_windows += "#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)\n"
+    stat_windows += "#endif\n"
+
+    base.replaceInFile("./librevenge/src/lib/RVNGDirectoryStream.cpp", "#include <librevenge-stream/librevenge-stream.h>", 
+                       "#include <librevenge-stream/librevenge-stream.h>\n\n" + stat_windows)
+
+    fix_RVNG_H  = "explicit RVNGFileStream(const char *filename);\n"
+    fix_RVNG_H += "	#if defined(_WIN32) || defined(_WIN64)\n"
+    fix_RVNG_H += "	explicit RVNGFileStream(const wchar_t *filename);\n"
+    fix_RVNG_H += "	#endif\n"
+
+    base.replaceInFile("./librevenge/inc/librevenge-stream/RVNGStreamImplementation.h", "explicit RVNGFileStream(const char *filename);", fix_RVNG_H)
+    
+    fix_RVNG_CPP_include  = "#if defined(_WIN32) || defined(_WIN64)\n"
+    fix_RVNG_CPP_include += "#include <sys/stat.h>\n\n"
+    fix_RVNG_CPP_include += "static __inline int wstat(wchar_t const* const _FileName, struct stat* const _Stat)\n"
+    fix_RVNG_CPP_include += "{\n"
+    fix_RVNG_CPP_include += "	_STATIC_ASSERT(sizeof(struct stat) == sizeof(struct _stat64i32));\n";
+    fix_RVNG_CPP_include += "	return _wstat64i32(_FileName, (struct _stat64i32*)_Stat);\n";
+    fix_RVNG_CPP_include += "}\n"
+    fix_RVNG_CPP_include += "#endif\n\n"
+    fix_RVNG_CPP_include += "namespace librevenge"
+
+    base.replaceInFile("./librevenge/src/lib/RVNGStreamImplementation.cpp", "namespace librevenge", fix_RVNG_CPP_include)
+
+    fix_RVNG_CPP  = "#if defined(_WIN32) || defined(_WIN64)\n"
+    fix_RVNG_CPP += "RVNGFileStream::RVNGFileStream(const wchar_t *filename) :\n"
+    fix_RVNG_CPP += "	RVNGInputStream(),\n"
+    fix_RVNG_CPP += "	d(new RVNGFileStreamPrivate())\n"
+    fix_RVNG_CPP += "{\n"
+    fix_RVNG_CPP += "	d->file = _wfopen(filename, L\"rb\");\n"
+    fix_RVNG_CPP += "	if (!d->file || ferror(d->file))\n"
+    fix_RVNG_CPP += "	{\n"
+    fix_RVNG_CPP += "		delete d;\n"
+    fix_RVNG_CPP += "		d = 0;\n"
+    fix_RVNG_CPP += "		return;\n"
+    fix_RVNG_CPP += "	}\n\n"
+    fix_RVNG_CPP += "	struct stat status;\n"
+    fix_RVNG_CPP += "	const int retval = wstat(filename, &status);\n"
+    fix_RVNG_CPP += "	if ((0 != retval) || !S_ISREG(status.st_mode))\n"
+    fix_RVNG_CPP += "	{\n"
+    fix_RVNG_CPP += "		delete d;\n"
+    fix_RVNG_CPP += "		d = 0;\n"
+    fix_RVNG_CPP += "		return;\n"
+    fix_RVNG_CPP += "	}\n\n"
+    fix_RVNG_CPP += "	fseek(d->file, 0, SEEK_END);\n\n"
+    fix_RVNG_CPP += "	d->streamSize = (unsigned long) ftell(d->file);\n"
+    fix_RVNG_CPP += "	if (d->streamSize == (unsigned long)-1)\n"
+    fix_RVNG_CPP += "		d->streamSize = 0;\n"
+    fix_RVNG_CPP += "	if (d->streamSize > (std::numeric_limits<unsigned long>::max)() / 2)\n"
+    fix_RVNG_CPP += "		d->streamSize = (std::numeric_limits<unsigned long>::max)() / 2;\n"
+    fix_RVNG_CPP += "	fseek(d->file, 0, SEEK_SET);\n"
+    fix_RVNG_CPP += "}\n"
+    fix_RVNG_CPP += "#endif\n\n"
+    fix_RVNG_CPP += "RVNGFileStream::~RVNGFileStream()"
+    
+    base.replaceInFile("./librevenge/src/lib/RVNGStreamImplementation.cpp", "RVNGFileStream::~RVNGFileStream()", fix_RVNG_CPP)
+
+if not base.is_dir("libodfgen"):
+    base.cmd("git", ["clone", "https://github.com/Distrotech/libodfgen.git"])
+    base.cmd_in_dir("libodfgen", "git", ["checkout", "8ef8c171ebe3c5daebdce80ee422cf7bb96aa3bc", "--quiet"])
+
+if not base.is_dir("libetonyek"):
+    base.cmd("git", ["clone", "https://github.com/LibreOffice/libetonyek.git"])
+    base.cmd_in_dir("libetonyek", "git", ["checkout", "cb396b4a9453a457469b62a740d8fb933c9442c3", "--quiet"])
+
+    base.replaceInFile("./libetonyek/src/lib/IWORKTable.cpp", "is_tree_valid", "valid_tree")
+
+cmd_args  = sys.argv[1:]
+use_gperf = False
+
+for arg in cmd_args:
+    if '--gperf' == arg:
+        use_gperf = True
+
+if use_gperf:
+    base_gperf_args = ["--compare-strncmp", "--enum", "--null-strings", "--readonly-tables", "--language", "C++"]
+    base_gperf_files = ["IWORKToken.gperf", "KEY1Token.gperf", "KEY2Token.gperf", "NUM1Token.gperf", "PAG1Token.gperf"]
+
+    for file in base_gperf_files:
+        base.cmd_in_dir("./libetonyek/src/lib", "gperf", base_gperf_args + [file, "--output-file", file[0:file.find(".")] + ".inc"])
+else:
+    base.copy_dir_content("./headers", "./libetonyek/src/lib")
+
+
+

Common/3dParty/apple/headers/KEY1Token.inc

@@ -0,0 +1,727 @@
+/* C++ code produced by gperf version 3.0.1 */
+/* Command-line: gperf --compare-strncmp --enum --null-strings --readonly-tables --language C++ --output-file KEY1Token.inc KEY1Token.gperf  */
+/* Computed positions: -k'1,3,6,9,14,$' */
+
+#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
+      && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
+      && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
+      && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
+      && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
+      && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
+      && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
+      && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
+      && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
+      && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
+      && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
+      && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
+      && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
+      && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
+      && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
+      && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
+      && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
+      && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
+      && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
+      && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
+      && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
+      && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
+      && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))
+/* The character set is not based on ISO-646.  */
+#error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gnu-gperf@gnu.org>."
+#endif
+
+#line 10 "KEY1Token.gperf"
+
+#if defined __GNUC__
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+using namespace KEY1Token;
+#line 18 "KEY1Token.gperf"
+struct Token
+{
+  const char *name;
+  int id;
+};
+#include <string.h>
+/* maximum key range = 602, duplicates = 0 */
+
+class Perfect_Hash
+{
+private:
+  static inline unsigned int hash (const char *str, unsigned int len);
+public:
+  static const struct Token *in_word_set (const char *str, unsigned int len);
+};
+
+inline unsigned int
+Perfect_Hash::hash (register const char *str, register unsigned int len)
+{
+  static const unsigned short asso_values[] =
+    {
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 220, 612,   0, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612,   0,   0,   0,   0,
+        0,   0,  10, 612, 612, 612,   0, 612,  30,  15,
+       55, 612,   5,  60,   5, 612,  10, 612, 612, 612,
+      612, 612, 612, 612, 612,   0, 612,  20, 165, 115,
+       65,   0, 105, 135, 175,  60,   0,   0,  30, 145,
+       10,   5, 155,  10,   5,  30,   5, 200,  15,  20,
+        0, 190,   0, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612, 612, 612, 612, 612,
+      612, 612, 612, 612, 612, 612
+    };
+  register int hval = len;
+
+  switch (hval)
+    {
+      default:
+        hval += asso_values[(unsigned char)str[13]];
+      /*FALLTHROUGH*/
+      case 13:
+      case 12:
+      case 11:
+      case 10:
+      case 9:
+        hval += asso_values[(unsigned char)str[8]];
+      /*FALLTHROUGH*/
+      case 8:
+      case 7:
+      case 6:
+        hval += asso_values[(unsigned char)str[5]];
+      /*FALLTHROUGH*/
+      case 5:
+      case 4:
+      case 3:
+        hval += asso_values[(unsigned char)str[2]];
+      /*FALLTHROUGH*/
+      case 2:
+      case 1:
+        hval += asso_values[(unsigned char)str[0]];
+        break;
+    }
+  return hval + asso_values[(unsigned char)str[len - 1]];
+}
+
+const struct Token *
+Perfect_Hash::in_word_set (register const char *str, register unsigned int len)
+{
+  enum
+    {
+      TOTAL_KEYWORDS = 203,
+      MIN_WORD_LENGTH = 1,
+      MAX_WORD_LENGTH = 39,
+      MIN_HASH_VALUE = 10,
+      MAX_HASH_VALUE = 611
+    };
+
+  static const struct Token wordlist[] =
+    {
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0},
+#line 199 "KEY1Token.gperf"
+      {"theme",theme},
+      {(char*)0},
+#line 211 "KEY1Token.gperf"
+      {"tr",tr},
+      {(char*)0},
+#line 196 "KEY1Token.gperf"
+      {"text",text},
+#line 207 "KEY1Token.gperf"
+      {"title",title},
+      {(char*)0},
+#line 198 "KEY1Token.gperf"
+      {"textbox",textbox},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 65 "KEY1Token.gperf"
+      {"element",element},
+      {(char*)0},
+#line 132 "KEY1Token.gperf"
+      {"none",none},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0},
+#line 175 "KEY1Token.gperf"
+      {"size",size},
+      {(char*)0}, {(char*)0},
+#line 209 "KEY1Token.gperf"
+      {"tl",tl},
+      {(char*)0},
+#line 206 "KEY1Token.gperf"
+      {"tile",tile},
+#line 168 "KEY1Token.gperf"
+      {"serie",serie},
+      {(char*)0},
+#line 221 "KEY1Token.gperf"
+      {"version",version},
+      {(char*)0},
+#line 112 "KEY1Token.gperf"
+      {"line",line},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 174 "KEY1Token.gperf"
+      {"showZero",showZero},
+      {(char*)0},
+#line 133 "KEY1Token.gperf"
+      {"notes",notes},
+      {(char*)0},
+#line 188 "KEY1Token.gperf"
+      {"stroke-style",stroke_style},
+      {(char*)0},
+#line 32 "KEY1Token.gperf"
+      {"axes",axes},
+#line 172 "KEY1Token.gperf"
+      {"shape",shape},
+      {(char*)0},
+#line 187 "KEY1Token.gperf"
+      {"stroke-color",stroke_color},
+#line 166 "KEY1Token.gperf"
+      {"sequence",sequence},
+      {(char*)0},
+#line 183 "KEY1Token.gperf"
+      {"start",start},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 182 "KEY1Token.gperf"
+      {"span",span},
+#line 185 "KEY1Token.gperf"
+      {"steps",steps},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 93 "KEY1Token.gperf"
+      {"ident",ident},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 134 "KEY1Token.gperf"
+      {"null",null},
+#line 197 "KEY1Token.gperf"
+      {"text-attributes",text_attributes},
+      {(char*)0},
+#line 130 "KEY1Token.gperf"
+      {"natural-size",natural_size},
+      {(char*)0},
+#line 131 "KEY1Token.gperf"
+      {"node",node},
+#line 111 "KEY1Token.gperf"
+      {"level",level},
+      {(char*)0},
+#line 225 "KEY1Token.gperf"
+      {"visible",visible},
+      {(char*)0}, {(char*)0},
+#line 95 "KEY1Token.gperf"
+      {"image",image},
+      {(char*)0},
+#line 171 "KEY1Token.gperf"
+      {"shadow-style",shadow_style},
+      {(char*)0},
+#line 67 "KEY1Token.gperf"
+      {"end-color",end_color},
+      {(char*)0}, {(char*)0},
+#line 208 "KEY1Token.gperf"
+      {"titleVisible",titleVisible},
+#line 212 "KEY1Token.gperf"
+      {"tracks-master",tracks_master},
+#line 53 "KEY1Token.gperf"
+      {"data",data},
+#line 177 "KEY1Token.gperf"
+      {"slide",slide},
+      {(char*)0}, {(char*)0},
+#line 62 "KEY1Token.gperf"
+      {"div",div},
+#line 195 "KEY1Token.gperf"
+      {"tail",tail},
+#line 170 "KEY1Token.gperf"
+      {"seriesDirection",seriesDirection},
+#line 169 "KEY1Token.gperf"
+      {"series",series},
+      {(char*)0},
+#line 162 "KEY1Token.gperf"
+      {"relative",relative},
+#line 60 "KEY1Token.gperf"
+      {"direction",direction},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 27 "KEY1Token.gperf"
+      {"altLineVisible",altLineVisible},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 173 "KEY1Token.gperf"
+      {"showGrid",showGrid},
+#line 33 "KEY1Token.gperf"
+      {"axis",axis},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 161 "KEY1Token.gperf"
+      {"reference",reference},
+#line 114 "KEY1Token.gperf"
+      {"line-tail-style",line_tail_style},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 73 "KEY1Token.gperf"
+      {"font",font},
+      {(char*)0},
+#line 137 "KEY1Token.gperf"
+      {"offset",offset},
+#line 92 "KEY1Token.gperf"
+      {"id",id},
+      {(char*)0},
+#line 160 "KEY1Token.gperf"
+      {"rect",rect},
+#line 180 "KEY1Token.gperf"
+      {"solid",solid},
+      {(char*)0}, {(char*)0},
+#line 66 "KEY1Token.gperf"
+      {"end",end},
+#line 77 "KEY1Token.gperf"
+      {"font-name",font_name},
+      {(char*)0},
+#line 159 "KEY1Token.gperf"
+      {"radius",radius},
+#line 61 "KEY1Token.gperf"
+      {"display-name",display_name},
+      {(char*)0},
+#line 68 "KEY1Token.gperf"
+      {"file",file},
+      {(char*)0},
+#line 45 "KEY1Token.gperf"
+      {"center",center},
+      {(char*)0}, {(char*)0},
+#line 109 "KEY1Token.gperf"
+      {"left",left},
+      {(char*)0}, {(char*)0},
+#line 51 "KEY1Token.gperf"
+      {"content",content},
+#line 64 "KEY1Token.gperf"
+      {"duration",duration},
+#line 71 "KEY1Token.gperf"
+      {"fill-type",fill_type},
+#line 163 "KEY1Token.gperf"
+      {"right",right},
+#line 139 "KEY1Token.gperf"
+      {"orientation",orientation},
+      {(char*)0}, {(char*)0},
+#line 78 "KEY1Token.gperf"
+      {"font-size",font_size},
+#line 50 "KEY1Token.gperf"
+      {"color",color},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 129 "KEY1Token.gperf"
+      {"name",name},
+#line 28 "KEY1Token.gperf"
+      {"angle",angle},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 215 "KEY1Token.gperf"
+      {"type",type},
+#line 52 "KEY1Token.gperf"
+      {"dash-style",dash_style},
+      {(char*)0}, {(char*)0},
+#line 82 "KEY1Token.gperf"
+      {"gradient",gradient},
+#line 56 "KEY1Token.gperf"
+      {"dataFormatterPrefix",dataFormatterPrefix},
+#line 54 "KEY1Token.gperf"
+      {"dataFormatterHasThousandsSeparators",dataFormatterHasThousandsSeparators},
+#line 135 "KEY1Token.gperf"
+      {"number",number},
+#line 38 "KEY1Token.gperf"
+      {"br",br},
+#line 222 "KEY1Token.gperf"
+      {"vertical",vertical},
+#line 57 "KEY1Token.gperf"
+      {"dataFormatterSuffix",dataFormatterSuffix},
+#line 193 "KEY1Token.gperf"
+      {"table",table},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 24 "KEY1Token.gperf"
+      {"DefaultLegendRelativePosition",DefaultLegendRelativePosition},
+      {(char*)0}, {(char*)0},
+#line 146 "KEY1Token.gperf"
+      {"pattern",pattern},
+      {(char*)0},
+#line 55 "KEY1Token.gperf"
+      {"dataFormatterNumberOfDecimals",dataFormatterNumberOfDecimals},
+      {(char*)0}, {(char*)0},
+#line 165 "KEY1Token.gperf"
+      {"segment",segment},
+      {(char*)0},
+#line 59 "KEY1Token.gperf"
+      {"dict",dict},
+      {(char*)0}, {(char*)0},
+#line 153 "KEY1Token.gperf"
+      {"presentation",presentation},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 35 "KEY1Token.gperf"
+      {"bl",bl},
+#line 126 "KEY1Token.gperf"
+      {"metadata",metadata},
+      {(char*)0},
+#line 86 "KEY1Token.gperf"
+      {"guide",guide},
+      {(char*)0},
+#line 181 "KEY1Token.gperf"
+      {"spacing",spacing},
+#line 120 "KEY1Token.gperf"
+      {"majorTickPositions",majorTickPositions},
+      {(char*)0},
+#line 70 "KEY1Token.gperf"
+      {"fill-style",fill_style},
+      {(char*)0},
+#line 118 "KEY1Token.gperf"
+      {"lock-aspect-ratio",lock_aspect_ratio},
+      {(char*)0},
+#line 44 "KEY1Token.gperf"
+      {"byte-size",byte_size},
+      {(char*)0},
+#line 40 "KEY1Token.gperf"
+      {"bullet",bullet},
+#line 25 "KEY1Token.gperf"
+      {"DefaultLegendSize",DefaultLegendSize},
+#line 128 "KEY1Token.gperf"
+      {"minorTickPositions",minorTickPositions},
+      {(char*)0},
+#line 202 "KEY1Token.gperf"
+      {"tickLabelsAngle",tickLabelsAngle},
+#line 127 "KEY1Token.gperf"
+      {"middle",middle},
+      {(char*)0},
+#line 152 "KEY1Token.gperf"
+      {"pos",pos},
+#line 155 "KEY1Token.gperf"
+      {"prototype-data",prototype_data},
+#line 31 "KEY1Token.gperf"
+      {"array",array},
+      {(char*)0},
+#line 122 "KEY1Token.gperf"
+      {"master-slide",master_slide},
+#line 117 "KEY1Token.gperf"
+      {"location",location},
+#line 176 "KEY1Token.gperf"
+      {"size-technique",size_technique},
+      {(char*)0},
+#line 79 "KEY1Token.gperf"
+      {"font-superscript",font_superscript},
+#line 138 "KEY1Token.gperf"
+      {"opacity",opacity},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 100 "KEY1Token.gperf"
+      {"interBarGap",interBarGap},
+      {(char*)0}, {(char*)0},
+#line 156 "KEY1Token.gperf"
+      {"prototype-drawables",prototype_drawables},
+      {(char*)0},
+#line 58 "KEY1Token.gperf"
+      {"description",description},
+#line 43 "KEY1Token.gperf"
+      {"bullets",bullets},
+      {(char*)0},
+#line 76 "KEY1Token.gperf"
+      {"font-ligatures",font_ligatures},
+      {(char*)0},
+#line 191 "KEY1Token.gperf"
+      {"symbol",symbol},
+#line 154 "KEY1Token.gperf"
+      {"prototype-bullets",prototype_bullets},
+      {(char*)0},
+#line 194 "KEY1Token.gperf"
+      {"tab-stops",tab_stops},
+#line 90 "KEY1Token.gperf"
+      {"horizontal",horizontal},
+      {(char*)0},
+#line 204 "KEY1Token.gperf"
+      {"tickLabelsVisible",tickLabelsVisible},
+      {(char*)0},
+#line 192 "KEY1Token.gperf"
+      {"symbolFillMode",symbolFillMode},
+#line 74 "KEY1Token.gperf"
+      {"font-color",font_color},
+      {(char*)0}, {(char*)0},
+#line 124 "KEY1Token.gperf"
+      {"master-slides",master_slides},
+#line 147 "KEY1Token.gperf"
+      {"pieSliceOffset",pieSliceOffset},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 42 "KEY1Token.gperf"
+      {"bullet-indentation",bullet_indentation},
+      {(char*)0}, {(char*)0},
+#line 87 "KEY1Token.gperf"
+      {"guides",guides},
+      {(char*)0}, {(char*)0},
+#line 88 "KEY1Token.gperf"
+      {"head",head},
+#line 226 "KEY1Token.gperf"
+      {"width",width},
+#line 89 "KEY1Token.gperf"
+      {"hidden",hidden},
+      {(char*)0}, {(char*)0},
+#line 46 "KEY1Token.gperf"
+      {"character",character},
+#line 69 "KEY1Token.gperf"
+      {"fill-color",fill_color},
+#line 81 "KEY1Token.gperf"
+      {"g",g},
+#line 75 "KEY1Token.gperf"
+      {"font-kerning",font_kerning},
+      {(char*)0},
+#line 103 "KEY1Token.gperf"
+      {"justified",justified},
+      {(char*)0},
+#line 116 "KEY1Token.gperf"
+      {"lineVisible",lineVisible},
+#line 107 "KEY1Token.gperf"
+      {"labelVisible",labelVisible},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 119 "KEY1Token.gperf"
+      {"locked",locked},
+#line 189 "KEY1Token.gperf"
+      {"stroke-width",stroke_width},
+      {(char*)0},
+#line 200 "KEY1Token.gperf"
+      {"thumbnail",thumbnail},
+#line 201 "KEY1Token.gperf"
+      {"thumbnails",thumbnails},
+#line 190 "KEY1Token.gperf"
+      {"styles",styles},
+      {(char*)0}, {(char*)0},
+#line 136 "KEY1Token.gperf"
+      {"numberOfPoints",numberOfPoints},
+#line 49 "KEY1Token.gperf"
+      {"chartFrame",chartFrame},
+#line 167 "KEY1Token.gperf"
+      {"sequence-bullet-style",sequence_bullet_style},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 214 "KEY1Token.gperf"
+      {"transition-style",transition_style},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 110 "KEY1Token.gperf"
+      {"legend",legend},
+#line 148 "KEY1Token.gperf"
+      {"pieSlicePercentVisible",pieSlicePercentVisible},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 47 "KEY1Token.gperf"
+      {"character-bullet-style",character_bullet_style},
+      {(char*)0},
+#line 213 "KEY1Token.gperf"
+      {"transformation",transformation},
+#line 224 "KEY1Token.gperf"
+      {"visibility",visibility},
+#line 186 "KEY1Token.gperf"
+      {"string",string},
+      {(char*)0},
+#line 39 "KEY1Token.gperf"
+      {"buildChunkingStyle",buildChunkingStyle},
+      {(char*)0}, {(char*)0},
+#line 184 "KEY1Token.gperf"
+      {"start-color",start_color},
+      {(char*)0},
+#line 210 "KEY1Token.gperf"
+      {"top",top},
+#line 63 "KEY1Token.gperf"
+      {"drawables",drawables},
+#line 179 "KEY1Token.gperf"
+      {"slide-size",slide_size},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 113 "KEY1Token.gperf"
+      {"line-head-style",line_head_style},
+#line 157 "KEY1Token.gperf"
+      {"prototype-plugin",prototype_plugin},
+      {(char*)0}, {(char*)0},
+#line 80 "KEY1Token.gperf"
+      {"font-underline",font_underline},
+      {(char*)0},
+#line 97 "KEY1Token.gperf"
+      {"image-scale",image_scale},
+      {(char*)0},
+#line 106 "KEY1Token.gperf"
+      {"labelPosition",labelPosition},
+      {(char*)0},
+#line 96 "KEY1Token.gperf"
+      {"image-data",image_data},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 145 "KEY1Token.gperf"
+      {"path",path},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0},
+#line 34 "KEY1Token.gperf"
+      {"background-fill-style",background_fill_style},
+#line 158 "KEY1Token.gperf"
+      {"prototype-plugins",prototype_plugins},
+      {(char*)0}, {(char*)0},
+#line 123 "KEY1Token.gperf"
+      {"master-slide-id",master_slide_id},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 178 "KEY1Token.gperf"
+      {"slide-list",slide_list},
+#line 121 "KEY1Token.gperf"
+      {"marker-type",marker_type},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0},
+#line 91 "KEY1Token.gperf"
+      {"http://developer.apple.com/schemas/APXL",NS_URI_KEY},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 98 "KEY1Token.gperf"
+      {"image-bullet-style",image_bullet_style},
+#line 30 "KEY1Token.gperf"
+      {"application-version",application_version},
+      {(char*)0},
+#line 149 "KEY1Token.gperf"
+      {"plugin",plugin},
+#line 151 "KEY1Token.gperf"
+      {"point_at_top",point_at_top},
+#line 104 "KEY1Token.gperf"
+      {"key",key},
+      {(char*)0}, {(char*)0},
+#line 29 "KEY1Token.gperf"
+      {"application-name",application_name},
+      {(char*)0},
+#line 223 "KEY1Token.gperf"
+      {"vertical-alignment",vertical_alignment},
+#line 83 "KEY1Token.gperf"
+      {"gradient-angle",gradient_angle},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0},
+#line 144 "KEY1Token.gperf"
+      {"paragraph-tail-indent",paragraph_tail_indent},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0},
+#line 142 "KEY1Token.gperf"
+      {"paragraph-first-line-indent",paragraph_first_line_indent},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 72 "KEY1Token.gperf"
+      {"floating-content",floating_content},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 150 "KEY1Token.gperf"
+      {"plugin-data",plugin_data},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 36 "KEY1Token.gperf"
+      {"body",body},
+      {(char*)0}, {(char*)0},
+#line 41 "KEY1Token.gperf"
+      {"bullet-characters",bullet_characters},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 143 "KEY1Token.gperf"
+      {"paragraph-head-indent",paragraph_head_indent},
+      {(char*)0}, {(char*)0},
+#line 99 "KEY1Token.gperf"
+      {"inherited",inherited},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 125 "KEY1Token.gperf"
+      {"match-point",match_point},
+      {(char*)0},
+#line 216 "KEY1Token.gperf"
+      {"ui-state",ui_state},
+#line 102 "KEY1Token.gperf"
+      {"is-filled",is_filled},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0},
+#line 115 "KEY1Token.gperf"
+      {"lineOpacity",lineOpacity},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0},
+#line 37 "KEY1Token.gperf"
+      {"bottom",bottom},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0},
+#line 140 "KEY1Token.gperf"
+      {"page-number",page_number},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 205 "KEY1Token.gperf"
+      {"time-stamp",time_stamp},
+      {(char*)0},
+#line 203 "KEY1Token.gperf"
+      {"tickLabelsOpacity",tickLabelsOpacity},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 94 "KEY1Token.gperf"
+      {"id-ref",id_ref},
+      {(char*)0}, {(char*)0},
+#line 141 "KEY1Token.gperf"
+      {"paragraph-alignment",paragraph_alignment},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 164 "KEY1Token.gperf"
+      {"scale-to-fit",scale_to_fit},
+      {(char*)0},
+#line 101 "KEY1Token.gperf"
+      {"interSeriesGap",interSeriesGap},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 219 "KEY1Token.gperf"
+      {"userMaximum",userMaximum},
+      {(char*)0}, {(char*)0},
+#line 217 "KEY1Token.gperf"
+      {"useUserMaximum",useUserMaximum},
+#line 108 "KEY1Token.gperf"
+      {"layerElementsForShadowing",layerElementsForShadowing},
+      {(char*)0},
+#line 105 "KEY1Token.gperf"
+      {"labelOpacity",labelOpacity},
+      {(char*)0}, {(char*)0},
+#line 48 "KEY1Token.gperf"
+      {"chart-prototype",chart_prototype},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0},
+#line 220 "KEY1Token.gperf"
+      {"userMinimum",userMinimum},
+      {(char*)0}, {(char*)0},
+#line 218 "KEY1Token.gperf"
+      {"useUserMinimum",useUserMinimum},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 26 "KEY1Token.gperf"
+      {"altLineOpacity",altLineOpacity},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0},
+#line 85 "KEY1Token.gperf"
+      {"grow-horizontally",grow_horizontally},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 84 "KEY1Token.gperf"
+      {"gridOpacity",gridOpacity}
+    };
+
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
+      register int key = hash (str, len);
+
+      if (key <= MAX_HASH_VALUE && key >= 0)
+        {
+          register const char *s = wordlist[key].name;
+
+          if (s && *str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
+            return &wordlist[key];
+        }
+    }
+  return 0;
+}
+#line 227 "KEY1Token.gperf"
+

Common/3dParty/apple/headers/KEY2Token.inc

@@ -0,0 +1,300 @@
+/* C++ code produced by gperf version 3.0.1 */
+/* Command-line: gperf --compare-strncmp --enum --null-strings --readonly-tables --language C++ --output-file KEY2Token.inc KEY2Token.gperf  */
+/* Computed positions: -k'1,4,$' */
+
+#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
+      && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
+      && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
+      && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
+      && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
+      && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
+      && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
+      && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
+      && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
+      && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
+      && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
+      && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
+      && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
+      && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
+      && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
+      && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
+      && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
+      && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
+      && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
+      && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
+      && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
+      && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
+      && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))
+/* The character set is not based on ISO-646.  */
+#error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gnu-gperf@gnu.org>."
+#endif
+
+#line 10 "KEY2Token.gperf"
+
+#if defined __GNUC__
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+using namespace KEY2Token;
+#line 18 "KEY2Token.gperf"
+struct Token
+{
+  const char *name;
+  int id;
+};
+#include <string.h>
+/* maximum key range = 140, duplicates = 0 */
+
+class Perfect_Hash
+{
+private:
+  static inline unsigned int hash (const char *str, unsigned int len);
+public:
+  static const struct Token *in_word_set (const char *str, unsigned int len);
+};
+
+inline unsigned int
+Perfect_Hash::hash (register const char *str, register unsigned int len)
+{
+  static const unsigned char asso_values[] =
+    {
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141,   5,  65,
+        0, 141,  35,   0, 141,   5, 141,   0, 141, 141,
+      141, 141, 141, 141, 141, 141,   0, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141,   0,  25,   0,
+       15,   0,  55,  10,  10,   5, 141,  15,  20,   0,
+       10,  25,  40, 141,  25,  25,   5,   0,  30,   5,
+      141,  40, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
+      141, 141, 141, 141, 141, 141
+    };
+  register int hval = len;
+
+  switch (hval)
+    {
+      default:
+        hval += asso_values[(unsigned char)str[3]];
+      /*FALLTHROUGH*/
+      case 3:
+      case 2:
+      case 1:
+        hval += asso_values[(unsigned char)str[0]];
+        break;
+    }
+  return hval + asso_values[(unsigned char)str[len - 1]];
+}
+
+const struct Token *
+Perfect_Hash::in_word_set (register const char *str, register unsigned int len)
+{
+  enum
+    {
+      TOTAL_KEYWORDS = 67,
+      MIN_WORD_LENGTH = 1,
+      MAX_WORD_LENGTH = 46,
+      MIN_HASH_VALUE = 1,
+      MAX_HASH_VALUE = 140
+    };
+
+  static const struct Token wordlist[] =
+    {
+      {(char*)0},
+#line 49 "KEY2Token.gperf"
+      {"c",c},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0},
+#line 65 "KEY2Token.gperf"
+      {"metadata",metadata},
+#line 89 "KEY2Token.gperf"
+      {"type",type},
+#line 84 "KEY2Token.gperf"
+      {"theme",theme},
+#line 58 "KEY2Token.gperf"
+      {"i",i},
+#line 50 "KEY2Token.gperf"
+      {"comment",comment},
+#line 41 "KEY2Token.gperf"
+      {"animationType",animationType},
+#line 66 "KEY2Token.gperf"
+      {"name",name},
+#line 26 "KEY2Token.gperf"
+      {"2005112100",VERSION_STR_3},
+      {(char*)0},
+#line 62 "KEY2Token.gperf"
+      {"master-slide",master_slide},
+      {(char*)0},
+#line 83 "KEY2Token.gperf"
+      {"text",text},
+#line 85 "KEY2Token.gperf"
+      {"theme-list",theme_list},
+#line 28 "KEY2Token.gperf"
+      {"92008102400",VERSION_STR_5},
+      {(char*)0},
+#line 36 "KEY2Token.gperf"
+      {"animationEndOffset",animationEndOffset},
+      {(char*)0},
+#line 39 "KEY2Token.gperf"
+      {"animationStartOffset",animationStartOffset},
+#line 27 "KEY2Token.gperf"
+      {"72007061400",VERSION_STR_4},
+#line 35 "KEY2Token.gperf"
+      {"animationDuration",animationDuration},
+#line 40 "KEY2Token.gperf"
+      {"animationTimingReferent",animationTimingReferent},
+#line 73 "KEY2Token.gperf"
+      {"size",size},
+#line 86 "KEY2Token.gperf"
+      {"title",title},
+      {(char*)0}, {(char*)0},
+#line 55 "KEY2Token.gperf"
+      {"headline",headline},
+#line 53 "KEY2Token.gperf"
+      {"direction",direction},
+#line 52 "KEY2Token.gperf"
+      {"depth",depth},
+#line 78 "KEY2Token.gperf"
+      {"sticky-note",sticky_note},
+#line 34 "KEY2Token.gperf"
+      {"animationDelayAutomaticWith",animationDelayAutomaticWith},
+#line 30 "KEY2Token.gperf"
+      {"animationAuto",animationAuto},
+      {(char*)0},
+#line 67 "KEY2Token.gperf"
+      {"notes",notes},
+#line 54 "KEY2Token.gperf"
+      {"events",events},
+#line 42 "KEY2Token.gperf"
+      {"authors",authors},
+#line 63 "KEY2Token.gperf"
+      {"master-slides",master_slides},
+#line 70 "KEY2Token.gperf"
+      {"page",page},
+#line 74 "KEY2Token.gperf"
+      {"slide",slide},
+#line 80 "KEY2Token.gperf"
+      {"string",string},
+#line 56 "KEY2Token.gperf"
+      {"headlineParagraphStyle",headlineParagraphStyle},
+#line 37 "KEY2Token.gperf"
+      {"animationInterchunkAuto",animationInterchunkAuto},
+      {(char*)0},
+#line 24 "KEY2Token.gperf"
+      {"2004102100",VERSION_STR_2},
+#line 77 "KEY2Token.gperf"
+      {"slide-style",slide_style},
+#line 33 "KEY2Token.gperf"
+      {"animationDelayAutmaticAfter",animationDelayAutomaticAfter},
+#line 61 "KEY2Token.gperf"
+      {"keywords",keywords},
+#line 32 "KEY2Token.gperf"
+      {"animationDelay",animationDelay},
+#line 75 "KEY2Token.gperf"
+      {"slide-list",slide_list},
+      {(char*)0},
+#line 31 "KEY2Token.gperf"
+      {"animationAutoPlay",animationAutoPlay},
+#line 60 "KEY2Token.gperf"
+      {"key",key},
+#line 51 "KEY2Token.gperf"
+      {"decimal-number",number},
+#line 82 "KEY2Token.gperf"
+      {"stylesheet",stylesheet},
+      {(char*)0},
+#line 79 "KEY2Token.gperf"
+      {"sticky-notes",sticky_notes},
+#line 29 "KEY2Token.gperf"
+      {"BGBuildDurationProperty",BGBuildDurationProperty},
+#line 38 "KEY2Token.gperf"
+      {"animationInterchunkDelay",animationInterchunkDelay},
+#line 45 "KEY2Token.gperf"
+      {"build",build},
+#line 68 "KEY2Token.gperf"
+      {"number",number},
+#line 87 "KEY2Token.gperf"
+      {"title-placeholder",title_placeholder},
+#line 69 "KEY2Token.gperf"
+      {"object-placeholder",object_placeholder},
+      {(char*)0},
+#line 64 "KEY2Token.gperf"
+      {"master-ref",master_ref},
+#line 46 "KEY2Token.gperf"
+      {"build-chunk",build_chunk},
+#line 90 "KEY2Token.gperf"
+      {"version",version},
+      {(char*)0}, {(char*)0},
+#line 25 "KEY2Token.gperf"
+      {"2005092101",COMPATIBLE_VERSION_STR_3,},
+      {(char*)0},
+#line 48 "KEY2Token.gperf"
+      {"bullets",bullets},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 47 "KEY2Token.gperf"
+      {"build-chunks",build_chunks},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 72 "KEY2Token.gperf"
+      {"presentation",presentation},
+      {(char*)0},
+#line 76 "KEY2Token.gperf"
+      {"slide-number-placeholder",slide_number_placeholder},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 59 "KEY2Token.gperf"
+      {"info-ref",info_ref},
+      {(char*)0}, {(char*)0},
+#line 57 "KEY2Token.gperf"
+      {"http://developer.apple.com/namespaces/keynote2",NS_URI_KEY},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 88 "KEY2Token.gperf"
+      {"title-placeholder-ref",title_placeholder_ref},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 43 "KEY2Token.gperf"
+      {"body-placeholder",body_placeholder},
+      {(char*)0}, {(char*)0},
+#line 81 "KEY2Token.gperf"
+      {"style-ref",style_ref},
+      {(char*)0},
+#line 71 "KEY2Token.gperf"
+      {"parent-build-ref",parent_build_ref},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 44 "KEY2Token.gperf"
+      {"body-placeholder-ref",body_placeholder_ref}
+    };
+
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
+      register int key = hash (str, len);
+
+      if (key <= MAX_HASH_VALUE && key >= 0)
+        {
+          register const char *s = wordlist[key].name;
+
+          if (s && *str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
+            return &wordlist[key];
+        }
+    }
+  return 0;
+}
+#line 91 "KEY2Token.gperf"
+

Common/3dParty/apple/headers/NUM1Token.inc

@@ -0,0 +1,151 @@
+/* C++ code produced by gperf version 3.0.1 */
+/* Command-line: gperf --compare-strncmp --enum --null-strings --readonly-tables --language C++ --output-file NUM1Token.inc NUM1Token.gperf  */
+/* Computed positions: -k'$' */
+
+#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
+      && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
+      && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
+      && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
+      && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
+      && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
+      && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
+      && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
+      && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
+      && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
+      && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
+      && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
+      && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
+      && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
+      && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
+      && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
+      && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
+      && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
+      && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
+      && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
+      && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
+      && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
+      && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))
+/* The character set is not based on ISO-646.  */
+#error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gnu-gperf@gnu.org>."
+#endif
+
+#line 10 "NUM1Token.gperf"
+
+#if defined __GNUC__
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+using namespace NUM1Token;
+#line 18 "NUM1Token.gperf"
+struct Token
+{
+  const char *name;
+  int id;
+};
+#include <string.h>
+/* maximum key range = 34, duplicates = 0 */
+
+class Perfect_Hash
+{
+private:
+  static inline unsigned int hash (const char *str, unsigned int len);
+public:
+  static const struct Token *in_word_set (const char *str, unsigned int len);
+};
+
+inline unsigned int
+Perfect_Hash::hash (register const char *str, register unsigned int len)
+{
+  static const unsigned char asso_values[] =
+    {
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41,  0, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41,  0, 41, 41, 41, 41, 41, 41, 41, 41,
+       0, 10, 41, 41, 41,  0,  0, 41, 41, 41,
+      41,  5, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+      41, 41, 41, 41, 41, 41
+    };
+  return len + asso_values[(unsigned char)str[len - 1]];
+}
+
+const struct Token *
+Perfect_Hash::in_word_set (register const char *str, register unsigned int len)
+{
+  enum
+    {
+      TOTAL_KEYWORDS = 10,
+      MIN_WORD_LENGTH = 7,
+      MAX_WORD_LENGTH = 40,
+      MIN_HASH_VALUE = 7,
+      MAX_HASH_VALUE = 40
+    };
+
+  static const struct Token wordlist[] =
+    {
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 29 "NUM1Token.gperf"
+      {"version",version},
+#line 25 "NUM1Token.gperf"
+      {"document",document},
+#line 30 "NUM1Token.gperf"
+      {"workspace",workspace},
+#line 28 "NUM1Token.gperf"
+      {"stylesheet",stylesheet},
+#line 24 "NUM1Token.gperf"
+      {"92008102400",VERSION_STR_2},
+      {(char*)0}, {(char*)0},
+#line 32 "NUM1Token.gperf"
+      {"workspace-name",workspace_name},
+#line 33 "NUM1Token.gperf"
+      {"workspace-style",workspace_style},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 27 "NUM1Token.gperf"
+      {"page-info",page_info},
+#line 31 "NUM1Token.gperf"
+      {"workspace-array",workspace_array},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 26 "NUM1Token.gperf"
+      {"http://developer.apple.com/namespaces/ls",NS_URI_LS}
+    };
+
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
+      register int key = hash (str, len);
+
+      if (key <= MAX_HASH_VALUE && key >= 0)
+        {
+          register const char *s = wordlist[key].name;
+
+          if (s && *str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
+            return &wordlist[key];
+        }
+    }
+  return 0;
+}
+#line 34 "NUM1Token.gperf"
+

Common/3dParty/apple/headers/PAG1Token.inc

@@ -0,0 +1,209 @@
+/* C++ code produced by gperf version 3.0.1 */
+/* Command-line: gperf --compare-strncmp --enum --null-strings --readonly-tables --language C++ --output-file PAG1Token.inc PAG1Token.gperf  */
+/* Computed positions: -k'1,6' */
+
+#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
+      && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
+      && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
+      && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
+      && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
+      && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
+      && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
+      && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
+      && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
+      && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
+      && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
+      && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
+      && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
+      && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
+      && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
+      && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
+      && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
+      && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
+      && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
+      && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
+      && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
+      && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
+      && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))
+/* The character set is not based on ISO-646.  */
+#error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gnu-gperf@gnu.org>."
+#endif
+
+#line 10 "PAG1Token.gperf"
+
+#if defined __GNUC__
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+using namespace PAG1Token;
+#line 18 "PAG1Token.gperf"
+struct Token
+{
+  const char *name;
+  int id;
+};
+#include <string.h>
+/* maximum key range = 51, duplicates = 0 */
+
+class Perfect_Hash
+{
+private:
+  static inline unsigned int hash (const char *str, unsigned int len);
+public:
+  static const struct Token *in_word_set (const char *str, unsigned int len);
+};
+
+inline unsigned int
+Perfect_Hash::hash (register const char *str, register unsigned int len)
+{
+  static const unsigned char asso_values[] =
+    {
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 25, 55,  0, 55, 10,
+      55, 55, 55, 55, 55, 55, 55, 10, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+       5, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55,  5, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55,  5, 25, 15,
+      20,  0, 20, 15,  5, 55, 55,  5, 10, 55,
+       0, 15,  5, 55,  0,  0,  0, 55,  5, 10,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+      55, 55, 55, 55, 55, 55
+    };
+  register int hval = len;
+
+  switch (hval)
+    {
+      default:
+        hval += asso_values[(unsigned char)str[5]];
+      /*FALLTHROUGH*/
+      case 5:
+      case 4:
+      case 3:
+      case 2:
+      case 1:
+        hval += asso_values[(unsigned char)str[0]];
+        break;
+    }
+  return hval;
+}
+
+const struct Token *
+Perfect_Hash::in_word_set (register const char *str, register unsigned int len)
+{
+  enum
+    {
+      TOTAL_KEYWORDS = 31,
+      MIN_WORD_LENGTH = 4,
+      MAX_WORD_LENGTH = 40,
+      MIN_HASH_VALUE = 4,
+      MAX_HASH_VALUE = 54
+    };
+
+  static const struct Token wordlist[] =
+    {
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 38 "PAG1Token.gperf"
+      {"note",note},
+#line 49 "PAG1Token.gperf"
+      {"rpage",rpage},
+#line 39 "PAG1Token.gperf"
+      {"number",number},
+      {(char*)0}, {(char*)0},
+#line 41 "PAG1Token.gperf"
+      {"page",page},
+#line 52 "PAG1Token.gperf"
+      {"stylesheet",stylesheet},
+#line 33 "PAG1Token.gperf"
+      {"header",header},
+#line 51 "PAG1Token.gperf"
+      {"slprint-info",slprint_info},
+      {(char*)0},
+#line 47 "PAG1Token.gperf"
+      {"prototype",prototype},
+#line 44 "PAG1Token.gperf"
+      {"page-scale",page_scale},
+#line 37 "PAG1Token.gperf"
+      {"layout",layout},
+      {(char*)0}, {(char*)0},
+#line 27 "PAG1Token.gperf"
+      {"cell",cell},
+#line 40 "PAG1Token.gperf"
+      {"order",order},
+#line 43 "PAG1Token.gperf"
+      {"page-height",page_height},
+#line 53 "PAG1Token.gperf"
+      {"textbox",textbox},
+      {(char*)0},
+#line 28 "PAG1Token.gperf"
+      {"date",date},
+#line 45 "PAG1Token.gperf"
+      {"page-width",page_width},
+#line 31 "PAG1Token.gperf"
+      {"footer",footer},
+#line 54 "PAG1Token.gperf"
+      {"version",version},
+#line 29 "PAG1Token.gperf"
+      {"document",document},
+#line 26 "PAG1Token.gperf"
+      {"body",body},
+#line 42 "PAG1Token.gperf"
+      {"page-group",page_group},
+#line 24 "PAG1Token.gperf"
+      {"92008102400",VERSION_STR_4},
+#line 25 "PAG1Token.gperf"
+      {"SLCreationDateProperty",SLCreationDateProperty},
+#line 50 "PAG1Token.gperf"
+      {"section-prototypes",section_prototypes},
+#line 35 "PAG1Token.gperf"
+      {"kSFWPFootnoteGapProperty",kSFWPFootnoteGapProperty},
+#line 36 "PAG1Token.gperf"
+      {"kSFWPFootnoteKindProperty",kSFWPFootnoteKindProperty},
+#line 48 "PAG1Token.gperf"
+      {"publication-info",publication_info},
+      {(char*)0}, {(char*)0}, {(char*)0},
+#line 46 "PAG1Token.gperf"
+      {"print-info",print_info},
+      {(char*)0}, {(char*)0},
+#line 32 "PAG1Token.gperf"
+      {"footnote",footnote},
+      {(char*)0},
+#line 34 "PAG1Token.gperf"
+      {"http://developer.apple.com/namespaces/sl",NS_URI_SL},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+      {(char*)0}, {(char*)0}, {(char*)0}, {(char*)0},
+#line 30 "PAG1Token.gperf"
+      {"drawables",drawables}
+    };
+
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
+      register int key = hash (str, len);
+
+      if (key <= MAX_HASH_VALUE && key >= 0)
+        {
+          register const char *s = wordlist[key].name;
+
+          if (s && *str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
+            return &wordlist[key];
+        }
+    }
+  return 0;
+}
+#line 55 "PAG1Token.gperf"
+

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

@@ -25,7 +25,7 @@ namespace NSCSS
 		m_arParentsStyles(oStyle.m_arParentsStyles), m_sId(oStyle.m_sId),
 		m_nDpi(oStyle.m_nDpi), m_UnitMeasure(oStyle.m_UnitMeasure), m_dCoreFontSize(oStyle.m_dCoreFontSize),
 		m_oFont(oStyle.m_oFont), m_oMargin(oStyle.m_oMargin), m_oPadding(oStyle.m_oPadding), m_oBackground(oStyle.m_oBackground),
-		m_oText(oStyle.m_oText), m_oBorder(oStyle.m_oBorder), m_oDisplay(oStyle.m_oDisplay){}
+		m_oText(oStyle.m_oText), m_oBorder(oStyle.m_oBorder), m_oDisplay(oStyle.m_oDisplay), m_oTransform(oStyle.m_oTransform){}
 
 	CCompiledStyle::~CCompiledStyle()
 	{
@@ -44,6 +44,7 @@ namespace NSCSS
 		m_oPadding      += oElement.m_oPadding;
 		m_oText         += oElement.m_oText;
 		m_oDisplay      += oElement.m_oDisplay;
+		m_oTransform    += oElement.m_oTransform;
 
 		if (!oElement.m_sId.empty())
 			m_sId += L'+' + oElement.m_sId;
@@ -66,6 +67,7 @@ namespace NSCSS
 		m_oPadding      = oElement.m_oPadding;
 		m_oText         = oElement.m_oText;
 		m_oDisplay      = oElement.m_oDisplay;
+		m_oTransform    = oElement.m_oTransform;
 
 		return *this;
 	}
@@ -78,7 +80,8 @@ namespace NSCSS
 		       m_oMargin         == oStyle.m_oMargin         &&
 		       m_oPadding        == oStyle.m_oPadding        &&
 		       m_oText           == oStyle.m_oText           &&
-		       m_oDisplay        == oStyle.m_oDisplay;
+		       m_oDisplay        == oStyle.m_oDisplay        &&
+		       m_oTransform      == oStyle.m_oTransform;
 	}
 
 	void CCompiledStyle::StyleEquation(CCompiledStyle &oFirstStyle, CCompiledStyle &oSecondStyle)
@@ -90,6 +93,7 @@ namespace NSCSS
 		NSProperties::CText      ::Equation(oFirstStyle.m_oText,       oSecondStyle.m_oText);
 		NSProperties::CBorder    ::Equation(oFirstStyle.m_oBorder,     oSecondStyle.m_oBorder);
 		NSProperties::CDisplay   ::Equation(oFirstStyle.m_oDisplay,    oSecondStyle.m_oDisplay);
+		NSProperties::CTransform ::Equation(oFirstStyle.m_oTransform,  oSecondStyle.m_oTransform);
 	}
 
 	void CCompiledStyle::SetDpi(const unsigned short &uiDpi)
@@ -431,6 +435,12 @@ namespace NSCSS
 					m_oDisplay.SetVAlign(pPropertie.second, unLevel, bHardMode);
 					break;
 				}
+				//TRANSFORM
+				CASE(L"transform"):
+				{
+					m_oTransform.SetMatrix(pPropertie.second, unLevel, bHardMode);
+					break;
+				}
 				default: AddOtherStyle(pPropertie, unLevel, bHardMode);
 			}
 		}

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

@@ -31,11 +31,12 @@ namespace NSCSS
 		NSProperties::CText       m_oText;
 		NSProperties::CBorder     m_oBorder;
 		NSProperties::CDisplay    m_oDisplay;
+		NSProperties::CTransform  m_oTransform;
 
 		CCompiledStyle();
 		CCompiledStyle(const CCompiledStyle& oStyle);
 
-		~CCompiledStyle();
+		virtual ~CCompiledStyle();
 
 		void SetDpi(const unsigned short& uiDpi);
 		void SetUnitMeasure(const UnitMeasure& enUnitMeasure);

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

@@ -13,14 +13,14 @@ namespace NSCSS
 		delete m_pInternal;
 	}
 
-	CCompiledStyle CCssCalculator::GetCompiledStyle(const std::vector<CNode> &arSelectors, const bool& bIsSettings, const UnitMeasure& unitMeasure) const
+	CCompiledStyle CCssCalculator::GetCompiledStyle(const std::vector<CNode> &arSelectors) const
 	{
-		return m_pInternal->GetCompiledStyle(arSelectors, bIsSettings, unitMeasure);
+		return m_pInternal->GetCompiledStyle(arSelectors);
 	}
 
-	bool CCssCalculator::GetCompiledStyle(CCompiledStyle &oStyle, const std::vector<CNode> &arSelectors, const bool &bIsSettings, const UnitMeasure &unitMeasure) const
+	bool CCssCalculator::GetCompiledStyle(CCompiledStyle &oStyle, const std::vector<CNode> &arSelectors) const
 	{
-		return m_pInternal->GetCompiledStyle(oStyle, arSelectors, bIsSettings, unitMeasure);
+		return m_pInternal->GetCompiledStyle(oStyle, arSelectors);
 	}
 
 	std::wstring CCssCalculator::CalculateStyleId(const CNode& oNode)
@@ -48,26 +48,11 @@ namespace NSCSS
 		m_pInternal->AddStylesFromFile(wsFileName);
 	}
 
-	void CCssCalculator::SetUnitMeasure(const UnitMeasure& nType)
-	{
-		m_pInternal->SetUnitMeasure(nType);
-	}
-
 	void CCssCalculator::SetDpi(const unsigned short int& nValue)
 	{
 		m_pInternal->SetDpi(nValue);
 	}
 
-	void CCssCalculator::SetBodyTree(const CTree &oTree)
-	{
-		m_pInternal->SetBodyTree(oTree);
-	}
-
-	UnitMeasure CCssCalculator::GetUnitMeasure() const
-	{
-		return m_pInternal->GetUnitMeasure();
-	}
-
 	std::wstring CCssCalculator::GetEncoding() const
 	{
 		return m_pInternal->GetEncoding();
@@ -78,6 +63,26 @@ namespace NSCSS
 		return m_pInternal->GetDpi();
 	}
 
+	void CCssCalculator::ClearPageData()
+	{
+		m_pInternal->ClearPageData();
+	}
+
+	void CCssCalculator::ClearEmbeddedStyles()
+	{
+		m_pInternal->ClearEmbeddedStyles();
+	}
+
+	void CCssCalculator::ClearAllowedStyleFiles()
+	{
+		m_pInternal->ClearAllowedStyleFiles();
+	}
+
+	void CCssCalculator::ClearStylesFromFile(const std::wstring& wsFilePath)
+	{
+		m_pInternal->ClearStylesFromFile(wsFilePath);
+	}
+
 	void CCssCalculator::Clear()
 	{
 		m_pInternal->Clear();

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

@@ -19,8 +19,8 @@ namespace NSCSS
 		CCssCalculator();
 		~CCssCalculator();
 
-		CCompiledStyle GetCompiledStyle(const std::vector<CNode> &arSelectors, const bool& bIsSettings = false, const UnitMeasure& unitMeasure = Point) const;
-		bool GetCompiledStyle(CCompiledStyle& oStyle, const std::vector<CNode> &arSelectors, const bool& bIsSettings = false, const UnitMeasure& unitMeasure = Point) const;
+		CCompiledStyle GetCompiledStyle(const std::vector<CNode> &arSelectors) const;
+		bool GetCompiledStyle(CCompiledStyle& oStyle, const std::vector<CNode> &arSelectors) const;
 
 		std::wstring CalculateStyleId(const CNode& oNode);
 		bool CalculatePageStyle(NSProperties::CPage& oPageData, const std::vector<CNode> &arSelectors);
@@ -30,14 +30,15 @@ namespace NSCSS
 		void AddStyles        (const std::wstring& wsStyle);
 		void AddStylesFromFile(const std::wstring& wsFileName);
 
-		void SetUnitMeasure(const UnitMeasure& nType);
 		void SetDpi(const unsigned short int& nValue);
-		void SetBodyTree(const CTree &oTree);
 
-		UnitMeasure GetUnitMeasure() const;
 		std::wstring GetEncoding()   const;
 		unsigned short int GetDpi()  const;
 
+		void ClearPageData();
+		void ClearEmbeddedStyles();
+		void ClearAllowedStyleFiles();
+		void ClearStylesFromFile(const std::wstring& wsFilePath);
 		void Clear();
 	};
 }

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

@@ -5,12 +5,9 @@
 #include <fstream>
 #include <cmath>
 #include <algorithm>
-#include <iostream>
 #include <numeric>
 
 #include "../../katana-parser/src/selector.h"
-#include "../../../../../UnicodeConverter/UnicodeConverter.h"
-#include "ConstValues.h"
 #include "../../../../../DesktopEditor/common/File.h"
 #include "StaticFunctions.h"
 
@@ -41,61 +38,120 @@ bool operator<(const std::vector<NSCSS::CNode> &arLeftSelectors, const std::vect
 
 namespace NSCSS
 {
-	CCssCalculator_Private::CCssCalculator_Private() : m_nDpi(96), m_nCountNodes(0), m_UnitMeasure(Point), m_mStatictics(NULL), m_sEncoding(L"UTF-8"){}
+	CStyleStorage::CStyleStorage()
+	{}
 
-	CCssCalculator_Private::~CCssCalculator_Private()
+	CStyleStorage::~CStyleStorage()
 	{
-		m_arFiles.clear();
-
-		for (std::map<std::wstring, CElement*>::iterator oIter = m_mData.begin(); oIter != m_mData.end(); ++oIter)
-			if (oIter->second != NULL)
-				delete oIter->second;
-
-		m_mData.clear();
-
-		if (NULL != m_mStatictics)
-			delete m_mStatictics;
+		Clear();
 	}
 
-	inline void CCssCalculator_Private::GetOutputData(KatanaOutput *oOutput)
+	void CStyleStorage::Clear()
 	{
-		if ( NULL == oOutput )
-			return;
+		for (TStyleFileData* pStyleFileData : m_arStyleFiles)
+		{
+			if (nullptr == pStyleFileData)
+				continue;
 
-		switch (oOutput->mode) {
-			case KatanaParserModeStylesheet:
-				GetStylesheet(oOutput->stylesheet);
-				break;
-			case KatanaParserModeRule:
-				GetRule(oOutput->rule);
-				break;
-			case KatanaParserModeKeyframeRule:
-			case KatanaParserModeKeyframeKeyList:
-			case KatanaParserModeMediaList:
-			case KatanaParserModeValue:
-			case KatanaParserModeSelector:
-			case KatanaParserModeDeclarationList:
-				break;
+			for (std::map<std::wstring, CElement*>::iterator oIter = pStyleFileData->m_mStyleData.begin(); oIter != pStyleFileData->m_mStyleData.end(); ++oIter)
+				if (oIter->second != nullptr)
+					delete oIter->second;
+
+			delete pStyleFileData;
 		}
 
+		m_arStyleFiles.clear();
+		m_arEmptyStyleFiles.clear();
+
+		ClearEmbeddedStyles();
+		ClearAllowedStyleFiles();
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		ClearPageData();
+		#endif
+	}
+
+	void CStyleStorage::AddStyles(const std::string& sStyle)
+	{
+		if (sStyle.empty())
+			return;
+
+		KatanaOutput *output = katana_parse(sStyle.c_str(), sStyle.length(), KatanaParserModeStylesheet);
+		this->GetOutputData(output, m_mEmbeddedStyleData);
+		katana_destroy_output(output);
+	}
+
+	void CStyleStorage::AddStyles(const std::wstring& wsStyle)
+	{
+		if (wsStyle.empty())
+			return;
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		std::wregex oRegex(L"@page\\s*([^{]*)(\\{[^}]*\\})");
+		std::wsmatch oMatch;
+		std::wstring::const_iterator oSearchStart(wsStyle.cbegin());
+
+		while (std::regex_search(oSearchStart, wsStyle.cend(), oMatch, oRegex))
+		{
+			AddPageData(oMatch[1].str(), oMatch[2].str());
+			oSearchStart = oMatch.suffix().first;
+		}
+		#endif
+
+		AddStyles(U_TO_UTF8(wsStyle));
+	}
+
+	void CStyleStorage::AddStylesFromFile(const std::wstring& wsFileName)
+	{
+		std::set<std::wstring>::const_iterator itEmptyFileFound = m_arEmptyStyleFiles.find(wsFileName);
+
+		if (m_arEmptyStyleFiles.cend() != itEmptyFileFound)
+			return;
+
+		std::vector<TStyleFileData*>::const_iterator itFound = std::find_if(m_arStyleFiles.cbegin(), m_arStyleFiles.cend(),
+		                                                                    [wsFileName](const TStyleFileData* pStyleFileData)
+		                                                                    { return wsFileName == pStyleFileData->m_wsStyleFilepath; });
+
+		m_arAllowedStyleFiles.insert(wsFileName);
+
+		if (m_arStyleFiles.cend() != itFound)
+			return;
+
+		TStyleFileData *pStyleFileData = new TStyleFileData();
+
+		pStyleFileData->m_wsStyleFilepath = wsFileName;
+
+		AddStyles(NS_STATIC_FUNCTIONS::GetContentAsUTF8(wsFileName), pStyleFileData->m_mStyleData);
+
+		if (!pStyleFileData->m_mStyleData.empty())
+			m_arStyleFiles.push_back(pStyleFileData);
+		else
+		{
+			m_arEmptyStyleFiles.insert(wsFileName);
+			delete pStyleFileData;
+		}
+	}
+
+	void CStyleStorage::ClearStylesFromFile(const std::wstring& wsFileName)
+	{
+		std::vector<TStyleFileData*>::const_iterator itFound = std::find_if(m_arStyleFiles.cbegin(), m_arStyleFiles.cend(),
+																			[wsFileName](const TStyleFileData* pStyleFileData)
+																			{ return wsFileName == pStyleFileData->m_wsStyleFilepath; });
+
+		if (m_arStyleFiles.cend() != itFound)
+		{
+			m_arStyleFiles.erase(itFound);
+			delete *itFound;
+		}
 	}
 
 	#ifdef CSS_CALCULATOR_WITH_XHTML
-	std::map<std::wstring, std::wstring> CCssCalculator_Private::GetPageData(const std::wstring &wsPageName)
+	void CStyleStorage::AddPageData(const std::wstring& wsPageName, const std::wstring& wsStyles)
 	{
-		if (m_arPageDatas.empty())
-			return {};
-
-		for (const TPageData& oPageData : m_arPageDatas)
-		{
-			if (std::find(oPageData.m_wsNames.begin(), oPageData.m_wsNames.end(), wsPageName) != oPageData.m_wsNames.end())
-				return oPageData.m_mData;
-		}
-
-		return {};
+		m_arPageDatas.push_back({NS_STATIC_FUNCTIONS::GetWordsW(wsPageName), NS_STATIC_FUNCTIONS::GetRules(wsStyles)});
 	}
-	
-	void CCssCalculator_Private::SetPageData(NSProperties::CPage &oPage, const std::map<std::wstring, std::wstring> &mData, unsigned int unLevel, bool bHardMode)
+
+	void CStyleStorage::SetPageData(NSProperties::CPage& oPage, const std::map<std::wstring, std::wstring>& mData, unsigned int unLevel, bool bHardMode)
 	{
 		for (const std::pair<std::wstring, std::wstring> &oData : mData)
 		{
@@ -110,162 +166,84 @@ namespace NSCSS
 		}
 	}
 
-	std::vector<std::wstring> CCssCalculator_Private::CalculateAllNodes(const std::vector<CNode> &arSelectors)
+	std::map<std::wstring, std::wstring> CStyleStorage::GetPageData(const std::wstring& wsPageName)
 	{
-		std::vector<std::wstring> arNodes;
-		
-		for (std::vector<CNode>::const_reverse_iterator oNode = arSelectors.rbegin(); oNode != arSelectors.rend(); ++oNode)
-		{
-			if (!oNode->m_wsName.empty())
-				arNodes.push_back(oNode->m_wsName);
-
-			if (!oNode->m_wsClass.empty())
-			{
-				if (oNode->m_wsClass.find(L' ') != std::wstring::npos)
-				{
-					std::vector<std::wstring> arClasses = NS_STATIC_FUNCTIONS::GetWordsW(oNode->m_wsClass, false, L" ");
-
-					arNodes.push_back(std::accumulate(arClasses.begin(), arClasses.end(), std::wstring(),
-													  [](std::wstring sRes, const std::wstring& sClass)
-														{return sRes += L'.' + sClass + L' ';}));
-				}
-				else
-					arNodes.push_back(L'.' + oNode->m_wsClass);
-			}
-
-			if (!oNode->m_wsId.empty())
-				arNodes.push_back(L'#' + oNode->m_wsId);
-		}
-
-		return arNodes;
-	}
-
-	void CCssCalculator_Private::FindPrevAndKindElements(const CElement *pElement, const std::vector<std::wstring> &arNextNodes, std::vector<CElement*>& arFindedElements, const std::wstring &wsName, const std::vector<std::wstring> &arClasses)
-	{
-		if (arNextNodes.empty())
-			return;
-
-		const std::vector<CElement*> arTempPrev = pElement->GetPrevElements(arNextNodes.crbegin() + 1, arNextNodes.crend());
-		const std::vector<CElement*> arTempKins = pElement->GetNextOfKin(wsName, arClasses);
-
-		if (!arTempPrev.empty())
-			arFindedElements.insert(arFindedElements.end(), arTempPrev.begin(), arTempPrev.end());
-
-		if (!arTempKins.empty())
-			arFindedElements.insert(arFindedElements.end(), arTempKins.begin(), arTempKins.end());
-	}
-
-	std::vector<CElement*> CCssCalculator_Private::FindElements(std::vector<std::wstring> &arNodes, std::vector<std::wstring> &arNextNodes, bool bIsSettings)
-	{
-		if (arNodes.empty())
+		if (m_arPageDatas.empty())
 			return {};
 
-		std::vector<CElement*> arFindedElements;
-
-		std::wstring wsName, wsId;
-		std::vector<std::wstring> arClasses;
-
-		if (!arNodes.empty() && arNodes.back()[0] == L'#')
+		for (const TPageData& oPageData : m_arPageDatas)
 		{
-			wsId = arNodes.back();
-			arNodes.pop_back();
-			arNextNodes.push_back(wsId);
+			if (std::find(oPageData.m_wsNames.begin(), oPageData.m_wsNames.end(), wsPageName) != oPageData.m_wsNames.end())
+				return oPageData.m_mData;
 		}
 
-		if (!arNodes.empty() && arNodes.back()[0] == L'.')
-		{
-			arClasses = NS_STATIC_FUNCTIONS::GetWordsW(arNodes.back(), false, L" ");
-			arNextNodes.push_back(arNodes.back());
-			arNodes.pop_back();
-		}
+		return {};
+	}
 
-		if (!arNodes.empty())
-		{
-			wsName = arNodes.back();
-			arNodes.pop_back();
-			arNextNodes.push_back(wsName);
-		}
-
-		const std::map<std::wstring, CElement*>::const_iterator oFindName = m_mData.find(wsName);
-		std::map<std::wstring, CElement*>::const_iterator oFindId;
-
-		if (!wsId.empty())
-		{
-			oFindId = m_mData.find(wsId);
-
-			if (oFindId != m_mData.end() && NULL != m_mStatictics)
-			{
-				std::map<StatistickElement, unsigned int>::const_iterator oFindCountId = m_mStatictics->find(StatistickElement{StatistickElement::IsId, wsId});
-
-				if ((m_mStatictics->end() != oFindCountId) &&
-				   (((bIsSettings && oFindCountId->second < MaxNumberRepetitions) ||
-					 (!bIsSettings && oFindCountId->second >= MaxNumberRepetitions))))
-				{
-					if (!oFindId->second->Empty())
-						arFindedElements.push_back(oFindId->second);
-				}
-
-				FindPrevAndKindElements(oFindId->second, arNextNodes, arFindedElements, wsName);
-			}
-		}
-
-		if (!arClasses.empty())
-		{
-			if (!bIsSettings)
-			{
-				for (std::vector<std::wstring>::const_reverse_iterator iClass = arClasses.rbegin(); iClass != arClasses.rend(); ++iClass)
-				{
-					const std::map<std::wstring, CElement*>::const_iterator oFindClass = m_mData.find(*iClass);
-					if (oFindClass != m_mData.end())
-					{
-						if (!oFindClass->second->Empty())
-							arFindedElements.push_back(oFindClass->second);
-
-						FindPrevAndKindElements(oFindClass->second, arNextNodes, arFindedElements, wsName);
-					}
-				}
-			}
-		}
-
-		if (oFindName != m_mData.end())
-		{
-			if (!bIsSettings)
-			{
-				if (!oFindName->second->Empty())
-					arFindedElements.push_back(oFindName->second);
-
-				FindPrevAndKindElements(oFindName->second, arNextNodes, arFindedElements, wsName, arClasses);
-			}
-		}
-
-		if (arFindedElements.size() > 1)
-		{
-			std::sort(arFindedElements.rbegin(), arFindedElements.rend(),
-					  [](CElement* oFirstElement, CElement* oSecondElement)
-					  {
-						  return oFirstElement->GetWeight() > oSecondElement->GetWeight();
-					  });
-		}
-
-		return arFindedElements;
+	void CStyleStorage::ClearPageData()
+	{
+		m_arPageDatas.clear();
 	}
 	#endif
 
-	void CCssCalculator_Private::AddPageData(const std::wstring &wsPageNames, const std::wstring &wsStyles)
+	const CElement* CStyleStorage::FindElement(const std::wstring& wsSelector)
 	{
-		m_arPageDatas.push_back({NS_STATIC_FUNCTIONS::GetWordsW(wsPageNames), NS_STATIC_FUNCTIONS::GetRules(wsStyles)});
+		if (wsSelector.empty())
+			return nullptr;
+
+		const CElement* pFoundElement = FindSelectorFromStyleData(wsSelector, m_mEmbeddedStyleData);
+
+		if (nullptr != pFoundElement)
+			return pFoundElement;
+
+		for (std::vector<TStyleFileData*>::const_reverse_iterator itIter = m_arStyleFiles.crbegin(); itIter < m_arStyleFiles.crend(); ++itIter)
+		{
+			if (m_arAllowedStyleFiles.cend() == std::find(m_arAllowedStyleFiles.cbegin(), m_arAllowedStyleFiles.cend(), (*itIter)->m_wsStyleFilepath))
+				continue;
+
+			pFoundElement = FindSelectorFromStyleData(wsSelector, (*itIter)->m_mStyleData);
+
+			if (nullptr != pFoundElement)
+				return pFoundElement;
+		}
+
+		return nullptr;
 	}
-	
-	inline void CCssCalculator_Private::GetStylesheet(const KatanaStylesheet *oStylesheet)
+
+	void CStyleStorage::AddStyles(const std::string& sStyle, std::map<std::wstring, CElement*>& mStyleData)
+	{
+		if (sStyle.empty())
+			return;
+
+		KatanaOutput *output = katana_parse(sStyle.c_str(), sStyle.length(), KatanaParserModeStylesheet);
+		this->GetOutputData(output, mStyleData);
+		katana_destroy_output(output);
+	}
+
+	void CStyleStorage::ClearEmbeddedStyles()
+	{
+		for (std::map<std::wstring, CElement*>::iterator oIter = m_mEmbeddedStyleData.begin(); oIter != m_mEmbeddedStyleData.end(); ++oIter)
+			if (oIter->second != nullptr)
+				delete oIter->second;
+
+		m_mEmbeddedStyleData.clear();
+	}
+
+	void CStyleStorage::ClearAllowedStyleFiles()
+	{
+		m_arAllowedStyleFiles.clear();
+	}
+
+	void CStyleStorage::GetStylesheet(const KatanaStylesheet* oStylesheet, std::map<std::wstring, CElement*>& mStyleData)
 	{
 		for (size_t i = 0; i < oStylesheet->imports.length; ++i)
-			GetRule((KatanaRule*)oStylesheet->imports.data[i]);
+			GetRule((KatanaRule*)oStylesheet->imports.data[i], mStyleData);
 
 		for (size_t i = 0; i < oStylesheet->rules.length; ++i)
-			GetRule((KatanaRule*)oStylesheet->rules.data[i]);
+			GetRule((KatanaRule*)oStylesheet->rules.data[i], mStyleData);
 	}
 
-	inline void CCssCalculator_Private::GetRule(const KatanaRule *oRule)
+	void CStyleStorage::GetRule(const KatanaRule* oRule, std::map<std::wstring, CElement*>& mStyleData)
 	{
 		if ( NULL == oRule )
 			return;
@@ -273,7 +251,7 @@ namespace NSCSS
 		switch (oRule->type) {
 			case KatanaRuleStyle:
 			{
-				GetStyleRule((KatanaStyleRule*)oRule);
+				GetStyleRule((KatanaStyleRule*)oRule, mStyleData);
 				break;
 			}
 			default:
@@ -281,7 +259,7 @@ namespace NSCSS
 		}
 	}
 
-	inline void CCssCalculator_Private::GetStyleRule(const KatanaStyleRule *oRule)
+	void CStyleStorage::GetStyleRule(const KatanaStyleRule* oRule, std::map<std::wstring, CElement*>& mStyleData)
 	{
 		if (oRule->declarations->length == 0)
 			return;
@@ -297,7 +275,7 @@ namespace NSCSS
 
 			for (std::vector<std::wstring>::reverse_iterator oWord = arWords.rbegin(); oWord != arWords.rend(); ++oWord)
 			{
-				    const size_t posPoint = oWord->find(L'.');
+					const size_t posPoint = oWord->find(L'.');
 					const size_t posLattice = oWord->find(L'#');
 
 					const std::wstring sName = (posPoint != std::wstring::npos) ? oWord->substr(0, posPoint) : (posLattice != std::wstring::npos) ? oWord->substr(0, posLattice) : *oWord;
@@ -313,8 +291,8 @@ namespace NSCSS
 					{
 						if (NULL == oFirstElement && bCreateFirst)
 						{
-							const std::map<std::wstring, CElement*>::const_iterator& oFindId = m_mData.find(sId);
-							if (oFindId != m_mData.end())
+							const std::map<std::wstring, CElement*>::const_iterator& oFindId = mStyleData.find(sId);
+							if (oFindId != mStyleData.end())
 							{
 								oIdElement = oFindId->second;
 								bCreateFirst = false;
@@ -342,8 +320,8 @@ namespace NSCSS
 					{
 						if (NULL == oFirstElement && bCreateFirst)
 						{
-							const std::map<std::wstring, CElement*>::const_iterator& oFindClass = m_mData.find(sClass);
-							if (oFindClass != m_mData.end())
+							const std::map<std::wstring, CElement*>::const_iterator& oFindClass = mStyleData.find(sClass);
+							if (oFindClass != mStyleData.end())
 							{
 								oClassElement = oFindClass->second;
 								bCreateFirst = false;
@@ -375,8 +353,8 @@ namespace NSCSS
 					{
 						if (NULL == oFirstElement && bCreateFirst)
 						{
-							const std::map<std::wstring, CElement*>::const_iterator& oFindName = m_mData.find(sName);
-							if (oFindName != m_mData.end())
+							const std::map<std::wstring, CElement*>::const_iterator& oFindName = mStyleData.find(sName);
+							if (oFindName != mStyleData.end())
 							{
 								oNameElement = oFindName->second;
 								bCreateFirst = false;
@@ -408,11 +386,16 @@ namespace NSCSS
 				oLastElement->AddProperties(mStyle);
 
 			if (NULL != oFirstElement)
-				m_mData[oFirstElement->GetSelector()] = oFirstElement;
+				mStyleData[oFirstElement->GetSelector()] = oFirstElement;
 		}
 	}
 
-	inline std::vector<std::wstring> CCssCalculator_Private::GetSelectorList(const KatanaArray* oSelectors) const
+	std::wstring CStyleStorage::GetValueList(const KatanaArray* oValues)
+	{
+		return StringifyValueList(oValues);
+	}
+
+	std::vector<std::wstring> CStyleStorage::GetSelectorList(const KatanaArray* oSelectors) const
 	{
 		if (oSelectors->length == 0)
 			return std::vector<std::wstring>();
@@ -425,7 +408,7 @@ namespace NSCSS
 		return arSelectors;
 	}
 
-	inline std::wstring CCssCalculator_Private::GetSelector(const KatanaSelector *oSelector) const
+	std::wstring CStyleStorage::GetSelector(const KatanaSelector* oSelector) const
 	{
 		KatanaParser oParser;
 		oParser.options = &kKatanaDefaultOptions;
@@ -444,7 +427,7 @@ namespace NSCSS
 		return wsText;
 	}
 
-	inline std::map<std::wstring, std::wstring> CCssCalculator_Private::GetDeclarationList(const KatanaArray* oDeclarations) const
+	std::map<std::wstring, std::wstring> CStyleStorage::GetDeclarationList(const KatanaArray* oDeclarations) const
 	{
 		if(oDeclarations->length == 0)
 			return std::map<std::wstring, std::wstring>();
@@ -457,7 +440,7 @@ namespace NSCSS
 		return arDeclarations;
 	}
 
-	inline std::pair<std::wstring, std::wstring> CCssCalculator_Private::GetDeclaration(const KatanaDeclaration* oDecl) const
+	std::pair<std::wstring, std::wstring> CStyleStorage::GetDeclaration(const KatanaDeclaration* oDecl) const
 	{
 		std::wstring sValueList = StringifyValueList(oDecl->values);
 
@@ -467,52 +450,213 @@ namespace NSCSS
 		return std::make_pair(UTF8_TO_U(std::string(oDecl->property)), sValueList);
 	}
 
-	inline std::wstring CCssCalculator_Private::GetValueList(const KatanaArray *oValues)
+	void CStyleStorage::GetOutputData(KatanaOutput* oOutput, std::map<std::wstring, CElement*>& mStyleData)
 	{
-		return StringifyValueList(oValues);
+		if ( NULL == oOutput )
+			return;
+
+		switch (oOutput->mode) {
+			case KatanaParserModeStylesheet:
+				GetStylesheet(oOutput->stylesheet, mStyleData);
+				break;
+			case KatanaParserModeRule:
+				GetRule(oOutput->rule, mStyleData);
+				break;
+			case KatanaParserModeKeyframeRule:
+			case KatanaParserModeKeyframeKeyList:
+			case KatanaParserModeMediaList:
+			case KatanaParserModeValue:
+			case KatanaParserModeSelector:
+			case KatanaParserModeDeclarationList:
+				break;
+		}
+	}
+
+	const CElement* CStyleStorage::FindSelectorFromStyleData(const std::wstring& wsSelector, const std::map<std::wstring, CElement*>& mStyleData)
+	{
+		std::map<std::wstring, CElement*>::const_iterator itFound = mStyleData.find(wsSelector);
+
+		if (mStyleData.cend() != itFound)
+			return itFound->second;
+
+		return nullptr;
+	}
+
+	CCssCalculator_Private::CCssCalculator_Private() : m_nDpi(96), m_nCountNodes(0), m_sEncoding(L"UTF-8"){}
+
+	CCssCalculator_Private::~CCssCalculator_Private()
+	{}
+
+	#ifdef CSS_CALCULATOR_WITH_XHTML
+	void CCssCalculator_Private::SetPageData(NSProperties::CPage &oPage, const std::map<std::wstring, std::wstring> &mData, unsigned int unLevel, bool bHardMode)
+	{
+		//TODO:: пересмотреть данный метод
+		m_oStyleStorage.SetPageData(oPage, mData, unLevel, bHardMode);
+	}
+
+	std::map<std::wstring, std::wstring> CCssCalculator_Private::GetPageData(const std::wstring &wsPageName)
+	{
+		return m_oStyleStorage.GetPageData(wsPageName);
+	}
+
+	void CCssCalculator_Private::ClearPageData()
+	{
+		m_oStyleStorage.ClearPageData();
+	}
+	#endif
+
+	std::vector<std::wstring> CCssCalculator_Private::CalculateAllNodes(const std::vector<CNode> &arSelectors)
+	{
+		std::vector<std::wstring> arNodes;
+		
+		for (std::vector<CNode>::const_reverse_iterator oNode = arSelectors.rbegin(); oNode != arSelectors.rend(); ++oNode)
+		{
+			if (!oNode->m_wsName.empty())
+				arNodes.push_back(oNode->m_wsName);
+
+			if (!oNode->m_wsClass.empty())
+			{
+				if (oNode->m_wsClass.find(L' ') != std::wstring::npos)
+				{
+					std::vector<std::wstring> arClasses = NS_STATIC_FUNCTIONS::GetWordsW(oNode->m_wsClass, false, L" ");
+
+					arNodes.push_back(std::accumulate(arClasses.begin(), arClasses.end(), std::wstring(),
+													  [](std::wstring sRes, const std::wstring& sClass)
+														{return sRes += L'.' + sClass + L' ';}));
+				}
+				else
+					arNodes.push_back(L'.' + oNode->m_wsClass);
+			}
+
+			if (!oNode->m_wsId.empty())
+				arNodes.push_back(L'#' + oNode->m_wsId);
+		}
+
+		return arNodes;
+	}
+
+	void CCssCalculator_Private::FindPrevAndKindElements(const CElement *pElement, const std::vector<std::wstring> &arNextNodes, std::vector<const CElement*>& arFindedElements, const std::wstring &wsName, const std::vector<std::wstring> &arClasses)
+	{
+		if (arNextNodes.empty())
+			return;
+
+		const std::vector<CElement*> arTempPrev = pElement->GetPrevElements(arNextNodes.crbegin() + 1, arNextNodes.crend());
+		const std::vector<CElement*> arTempKins = pElement->GetNextOfKin(wsName, arClasses);
+
+		if (!arTempPrev.empty())
+			arFindedElements.insert(arFindedElements.end(), arTempPrev.begin(), arTempPrev.end());
+
+		if (!arTempKins.empty())
+			arFindedElements.insert(arFindedElements.end(), arTempKins.begin(), arTempKins.end());
+	}
+
+	std::vector<const CElement*> CCssCalculator_Private::FindElements(std::vector<std::wstring> &arNodes, std::vector<std::wstring> &arNextNodes)
+	{
+		if (arNodes.empty())
+			return {};
+
+		std::vector<const CElement*> arFindedElements;
+
+		std::wstring wsName, wsId;
+		std::vector<std::wstring> arClasses;
+
+		if (!arNodes.empty() && arNodes.back()[0] == L'#')
+		{
+			wsId = arNodes.back();
+			arNodes.pop_back();
+			arNextNodes.push_back(wsId);
+		}
+
+		if (!arNodes.empty() && arNodes.back()[0] == L'.')
+		{
+			arClasses = NS_STATIC_FUNCTIONS::GetWordsW(arNodes.back(), false, L" ");
+			arNextNodes.push_back(arNodes.back());
+			arNodes.pop_back();
+		}
+
+		if (!arNodes.empty())
+		{
+			wsName = arNodes.back();
+			arNodes.pop_back();
+			arNextNodes.push_back(wsName);
+		}
+
+		if (!wsId.empty())
+		{
+			const CElement* pFoundId = m_oStyleStorage.FindElement(wsId);
+
+			if(nullptr != pFoundId)
+			{
+				if (!pFoundId->Empty())
+					arFindedElements.push_back(pFoundId);
+
+				FindPrevAndKindElements(pFoundId, arNextNodes, arFindedElements, wsName);
+			}
+		}
+
+		if (!arClasses.empty())
+		{
+			for (std::vector<std::wstring>::const_reverse_iterator iClass = arClasses.rbegin(); iClass != arClasses.rend(); ++iClass)
+			{
+				const CElement* pFoundClass = m_oStyleStorage.FindElement(*iClass);
+
+				if (nullptr != pFoundClass)
+				{
+					if (!pFoundClass->Empty())
+						arFindedElements.push_back(pFoundClass);
+
+					FindPrevAndKindElements(pFoundClass, arNextNodes, arFindedElements, wsName);
+				}
+			}
+		}
+
+		const CElement* pFoundName = m_oStyleStorage.FindElement(wsName);
+
+		if (nullptr != pFoundName)
+		{
+			if (!pFoundName->Empty())
+				arFindedElements.push_back(pFoundName);
+
+			FindPrevAndKindElements(pFoundName, arNextNodes, arFindedElements, wsName, arClasses);
+		}
+
+		if (arFindedElements.size() > 1)
+		{
+			std::sort(arFindedElements.rbegin(), arFindedElements.rend(),
+			          [](const CElement* oFirstElement, const CElement* oSecondElement)
+			          { return oFirstElement->GetWeight() > oSecondElement->GetWeight(); });
+		}
+
+		return arFindedElements;
 	}
 
 	#ifdef CSS_CALCULATOR_WITH_XHTML
-	CCompiledStyle CCssCalculator_Private::GetCompiledStyle(const std::vector<CNode>& arSelectors, const bool& bIsSettings, const UnitMeasure& unitMeasure)
+	CCompiledStyle CCssCalculator_Private::GetCompiledStyle(const std::vector<CNode>& arSelectors)
 	{
 		if (arSelectors.empty())
 			return CCompiledStyle();
 
 		CCompiledStyle oStyle;
 
-		GetCompiledStyle(oStyle, arSelectors, bIsSettings, unitMeasure);
+		GetCompiledStyle(oStyle, arSelectors);
 
 		return oStyle;
 	}
 
-	bool CCssCalculator_Private::GetCompiledStyle(CCompiledStyle &oStyle, const std::vector<CNode> &arSelectors, const bool &bIsSettings, const UnitMeasure &unitMeasure)
+	bool CCssCalculator_Private::GetCompiledStyle(CCompiledStyle &oStyle, const std::vector<CNode> &arSelectors)
 	{
 		if (arSelectors.empty())
 			return false;
 
-		SetUnitMeasure(unitMeasure);
+		const std::map<std::vector<CNode>, CCompiledStyle>::iterator oItem = m_mUsedStyles.find(arSelectors);
 
-		if (!bIsSettings)
+		if (oItem != m_mUsedStyles.end())
 		{
-			const std::map<std::vector<CNode>, CCompiledStyle>::iterator oItem = m_mUsedStyles.find(arSelectors);
-
-			if (oItem != m_mUsedStyles.end())
-			{
-				oStyle = oItem->second;
-				return true;
-			}
-		}
-		else if (NULL == m_mStatictics || m_mStatictics->empty())
-		{
-			oStyle.SetDpi(m_nDpi);
-			oStyle.SetUnitMeasure(m_UnitMeasure);
-			oStyle.SetID(arSelectors.back().m_wsName + ((!arSelectors.back().m_wsClass.empty()) ? L'.' + arSelectors.back().m_wsClass : L"") + ((arSelectors.back().m_wsId.empty()) ? L"" : L'#' + arSelectors.back().m_wsId) + L'-' + std::to_wstring(++m_nCountNodes));
-
-			return false;
+			oStyle = oItem->second;
+			return true;
 		}
 
 		oStyle.SetDpi(m_nDpi);
-		oStyle.SetUnitMeasure(m_UnitMeasure);
 
 		std::vector<std::wstring> arNodes = CalculateAllNodes(arSelectors);
 		std::vector<std::wstring> arPrevNodes;
@@ -535,25 +679,10 @@ namespace NSCSS
 
 			oTempStyle.AddStyle(arSelectors[i].m_mAttributes, i + 1);
 
-			for (const CElement* oElement : FindElements(arNodes, arPrevNodes, bIsSettings))
+			for (const CElement* oElement : FindElements(arNodes, arPrevNodes))
 				oTempStyle.AddStyle(oElement->GetStyle(), i + 1);
 
-			if (NULL != m_mStatictics)
-			{
-				std::map<StatistickElement, unsigned int>::const_iterator oFindCountStyle = m_mStatictics->find(StatistickElement{StatistickElement::IsStyle, arSelectors[i].m_wsStyle});
-
-				if (oFindCountStyle != m_mStatictics->end())
-				{
-					if ((bIsSettings && oFindCountStyle->second <  MaxNumberRepetitions) ||
-					   (!bIsSettings && oFindCountStyle->second >= MaxNumberRepetitions))
-						oTempStyle.AddStyle(arSelectors[i].m_wsStyle, i + 1,  true);
-					else if (!bIsSettings)
-						oTempStyle.AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
-				}
-				else /*if (bIsSettings)*/
-					oTempStyle.AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
-			}
-			else
+			if (!arSelectors[i].m_wsStyle.empty())
 				oTempStyle.AddStyle(arSelectors[i].m_wsStyle, i + 1, true);
 
 			oStyle += oTempStyle;
@@ -569,7 +698,7 @@ namespace NSCSS
 
 		oStyle.SetID(CalculateStyleId(arSelectors.back()));
 
-		if (!bIsSettings && !oStyle.Empty())
+		if (!oStyle.Empty())
 			m_mUsedStyles[arSelectors] = oStyle;
 
 		return true;
@@ -597,7 +726,7 @@ namespace NSCSS
 					SetPageData(oPageData, GetPageData(mRules[L"page"]), i + 1, true);
 			}
 
-			for (const CElement* oElement : FindElements(arNodes, arNextNodes, false))
+			for (const CElement* oElement : FindElements(arNodes, arNextNodes))
 			{
 				std::map<std::wstring, std::wstring> mRules = oElement->GetStyle();
 				if (mRules.end() != mRules.find(L"page"))
@@ -611,42 +740,20 @@ namespace NSCSS
 		return true;
 	}
 	#endif
-	void CCssCalculator_Private::AddStyles(const std::string &sStyle)
-	{
-		if (sStyle.empty())
-			return;
 
-		KatanaOutput *output = katana_parse(sStyle.c_str(), sStyle.length(), KatanaParserModeStylesheet);
-		this->GetOutputData(output);
-		katana_destroy_output(output);
+	void CCssCalculator_Private::AddStyles(const std::string& sStyle)
+	{
+		m_oStyleStorage.AddStyles(sStyle);
 	}
 
-	void CCssCalculator_Private::AddStyles(const std::wstring &wsStyle)
+	void CCssCalculator_Private::AddStyles(const std::wstring& wsStyle)
 	{
-		if (wsStyle.empty())
-			return;
-
-		std::wregex oRegex(L"@page\\s*([^{]*)(\\{[^}]*\\})");
-		std::wsmatch oMatch;
-		std::wstring::const_iterator oSearchStart(wsStyle.cbegin());
-		
-		while (std::regex_search(oSearchStart, wsStyle.cend(), oMatch, oRegex))
-		{
-			AddPageData(oMatch[1].str(), oMatch[2].str());
-			oSearchStart = oMatch.suffix().first;
-		}
-
-		AddStyles(U_TO_UTF8(wsStyle));
+		m_oStyleStorage.AddStyles(wsStyle);
 	}
 
 	void CCssCalculator_Private::AddStylesFromFile(const std::wstring& wsFileName)
 	{
-		if (std::find(m_arFiles.begin(), m_arFiles.end(), wsFileName) != m_arFiles.end())
-			return;
-
-		m_arFiles.push_back(wsFileName);
-
-		AddStyles(NS_STATIC_FUNCTIONS::GetContentAsUTF8(wsFileName));
+		m_oStyleStorage.AddStylesFromFile(wsFileName);
 	}
 
 	void CCssCalculator_Private::SetDpi(unsigned short int nValue)
@@ -654,32 +761,28 @@ namespace NSCSS
 		m_nDpi = nValue;
 	}
 
-	void CCssCalculator_Private::SetBodyTree(const CTree &oTree)
-	{
-		if (NULL == m_mStatictics)
-			m_mStatictics = new std::map<StatistickElement, unsigned int>();
-
-		CTree::CountingNumberRepetitions(oTree, *m_mStatictics);
-	}
-
-	void CCssCalculator_Private::SetUnitMeasure(const UnitMeasure& nType)
-	{
-		m_UnitMeasure = nType;
-	}
-
 	unsigned short int CCssCalculator_Private::GetDpi() const
 	{
 		return m_nDpi;
 	}
 
-	const std::map<std::wstring, CElement *> *CCssCalculator_Private::GetData() const
+	void CCssCalculator_Private::ClearEmbeddedStyles()
 	{
-		return &m_mData;
+		m_oStyleStorage.ClearEmbeddedStyles();
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		m_mUsedStyles.clear();
+		#endif
 	}
 
-	UnitMeasure CCssCalculator_Private::GetUnitMeasure() const
+	void CCssCalculator_Private::ClearAllowedStyleFiles()
 	{
-		return m_UnitMeasure;
+		m_oStyleStorage.ClearAllowedStyleFiles();
+	}
+
+	void CCssCalculator_Private::ClearStylesFromFile(const std::wstring& wsFilePath)
+	{
+		m_oStyleStorage.ClearStylesFromFile(wsFilePath);
 	}
 
 	std::wstring CCssCalculator_Private::GetEncoding() const
@@ -691,12 +794,22 @@ namespace NSCSS
 	{
 		m_sEncoding     = L"UTF-8";
 		m_nDpi          = 96;
-		m_UnitMeasure   = Point;
 
-		m_mData.clear();
-		m_arFiles.clear();
+		m_oStyleStorage.Clear();
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		m_mUsedStyles.clear();
+		#endif
+	}
+
+	bool IsTableElement(const std::wstring& wsNameTag)
+	{
+		return  L"td" == wsNameTag || L"tr" == wsNameTag || L"table" == wsNameTag ||
+		        L"tbody" == wsNameTag || L"thead" == wsNameTag || L"tfoot" == wsNameTag ||
+		        L"th" == wsNameTag;
 	}
 }
+
 inline static std::wstring StringifyValueList(const KatanaArray* oValues)
 {
 	if (NULL == oValues)
@@ -797,11 +910,4 @@ inline static std::wstring StringifyValue(const KatanaValue* oValue)
 	return str;
 }
 
-inline static bool IsTableElement(const std::wstring& wsNameTag)
-{
-	return  L"td" == wsNameTag || L"tr" == wsNameTag || L"table" == wsNameTag || 
-	        L"tbody" == wsNameTag || L"thead" == wsNameTag || L"tfoot" == wsNameTag ||
-	        L"th" == wsNameTag;
-}
-
 

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

@@ -3,11 +3,9 @@
 
 #include <vector>
 #include <map>
-#include <list>
-#include <functional>
+#include <set>
 #include "CElement.h"
-#include "ConstValues.h"
-#include "CUnitMeasureConverter.h"
+#include "StyleProperties.h"
 #include "../../katana-parser/src/katana.h"
 
 #ifdef CSS_CALCULATOR_WITH_XHTML
@@ -16,16 +14,43 @@
 
 namespace NSCSS
 {
-	class CCssCalculator_Private
+	class CStyleStorage
 	{
-		unsigned short int m_nDpi;
-		unsigned short int m_nCountNodes;
-		UnitMeasure m_UnitMeasure;
+	public:
+		CStyleStorage();
+		~CStyleStorage();
 
-		std::list<std::wstring> m_arFiles;
+		void Clear();
 
-		std::map<std::wstring, CElement*> m_mData;
+		void AddStyles(const std::string& sStyle);
+		void AddStyles(const std::wstring& wsStyle);
+		void AddStylesFromFile(const std::wstring& wsFileName);
 
+		void ClearEmbeddedStyles();
+		void ClearAllowedStyleFiles();
+		void ClearStylesFromFile(const std::wstring& wsFileName);
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		void AddPageData(const std::wstring& wsPageName, const std::wstring& wsStyles);
+		void SetPageData(NSProperties::CPage& oPage, const std::map<std::wstring, std::wstring>& mData, unsigned int unLevel, bool bHardMode = false);
+		std::map<std::wstring, std::wstring> GetPageData(const std::wstring& wsPageName);
+		void ClearPageData();
+		#endif
+
+		const CElement* FindElement(const std::wstring& wsSelector);
+	private:
+		typedef struct
+		{
+			std::wstring m_wsStyleFilepath;
+			std::map<std::wstring, CElement*> m_mStyleData;
+		} TStyleFileData;
+
+		std::set<std::wstring> m_arEmptyStyleFiles;
+		std::set<std::wstring> m_arAllowedStyleFiles;
+		std::vector<TStyleFileData*> m_arStyleFiles;
+		std::map<std::wstring, CElement*> m_mEmbeddedStyleData;
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
 		typedef struct
 		{
 			std::vector<std::wstring>            m_wsNames;
@@ -33,29 +58,14 @@ namespace NSCSS
 		} TPageData;
 
 		std::vector<TPageData> m_arPageDatas;
-
-		std::map<StatistickElement, unsigned int> *m_mStatictics; // Количество повторений свойств id и style у селекторов
-
-		#ifdef CSS_CALCULATOR_WITH_XHTML
-		std::map<std::vector<CNode>, CCompiledStyle> m_mUsedStyles;
-		
-		std::map<std::wstring, std::wstring> GetPageData(const std::wstring& wsPageName);
-		void SetPageData(NSProperties::CPage& oPage, const std::map<std::wstring, std::wstring>& mData, unsigned int unLevel, bool bHardMode = false);
-
-		std::vector<std::wstring> CalculateAllNodes(const std::vector<CNode>& arSelectors);
-
-		void FindPrevAndKindElements(const CElement* pElement, const std::vector<std::wstring>& arNextNodes, std::vector<CElement*>& arFindedElements, const std::wstring& wsName, const std::vector<std::wstring>& arClasses = {});
-		std::vector<CElement*> FindElements(std::vector<std::wstring>& arNodes, std::vector<std::wstring>& arNextNodes, bool bIsSettings);
 		#endif
+	private:
+		void AddStyles(const std::string& sStyle, std::map<std::wstring, CElement*>& mStyleData);
 
-		std::wstring m_sEncoding;
+		void GetStylesheet(const KatanaStylesheet* oStylesheet, std::map<std::wstring, CElement*>& mStyleData);
+		void GetRule(const KatanaRule* oRule, std::map<std::wstring, CElement*>& mStyleData);
 
-		void AddPageData(const std::wstring& wsPageName, const std::wstring& wsStyles);
-
-		void GetStylesheet(const KatanaStylesheet* oStylesheet);
-		void GetRule(const KatanaRule* oRule);
-
-		void GetStyleRule(const KatanaStyleRule* oRule);
+		void GetStyleRule(const KatanaStyleRule* oRule, std::map<std::wstring, CElement*>& mStyleData);
 
 		std::wstring GetValueList(const KatanaArray* oValues);
 
@@ -65,36 +75,60 @@ namespace NSCSS
 		std::map<std::wstring, std::wstring> GetDeclarationList(const KatanaArray* oDeclarations) const;
 		std::pair<std::wstring, std::wstring> GetDeclaration(const KatanaDeclaration* oDecl) const;
 
-		void GetOutputData(KatanaOutput* oOutput);
+		void GetOutputData(KatanaOutput* oOutput, std::map<std::wstring, CElement*>& mStyleData);
 
+		const CElement* FindSelectorFromStyleData(const std::wstring& wsSelector, const std::map<std::wstring, CElement*>& mStyleData);
+	};
+
+	class CCssCalculator_Private
+	{
+		unsigned short int m_nDpi;
+		unsigned short int m_nCountNodes;
+
+		CStyleStorage m_oStyleStorage;
+
+		#ifdef CSS_CALCULATOR_WITH_XHTML
+		std::map<std::vector<CNode>, CCompiledStyle> m_mUsedStyles;
+
+		void SetPageData(NSProperties::CPage& oPage, const std::map<std::wstring, std::wstring>& mData, unsigned int unLevel, bool bHardMode = false);
+		std::map<std::wstring, std::wstring> GetPageData(const std::wstring &wsPageName);
+		#endif
+
+		void FindPrevAndKindElements(const CElement* pElement, const std::vector<std::wstring>& arNextNodes, std::vector<const CElement*>& arFindedElements, const std::wstring& wsName, const std::vector<std::wstring>& arClasses = {});
+
+		std::wstring m_sEncoding;
 	public:
 		CCssCalculator_Private();
 		~CCssCalculator_Private();
 
 		#ifdef CSS_CALCULATOR_WITH_XHTML
-		CCompiledStyle GetCompiledStyle(const std::vector<CNode> &arSelectors, const bool& bIsSettings = false, const UnitMeasure& unitMeasure = Point);
-		bool GetCompiledStyle(CCompiledStyle& oStyle, const std::vector<CNode> &arSelectors, const bool& bIsSettings = false, const UnitMeasure& unitMeasure = Point);
+		CCompiledStyle GetCompiledStyle(const std::vector<CNode> &arSelectors);
+		bool GetCompiledStyle(CCompiledStyle& oStyle, const std::vector<CNode> &arSelectors);
 
 		std::wstring CalculateStyleId(const CNode& oNode);
 		bool CalculatePageStyle(NSProperties::CPage& oPageData, const std::vector<CNode> &arSelectors);
+
+		void ClearPageData();
 		#endif
 
+		std::vector<std::wstring> CalculateAllNodes(const std::vector<CNode>& arSelectors);
+		std::vector<const CElement*> FindElements(std::vector<std::wstring>& arNodes, std::vector<std::wstring>& arNextNodes);
+
 		void AddStyles(const std::string& sStyle);
 		void AddStyles(const std::wstring& wsStyle);
 		void AddStylesFromFile(const std::wstring& wsFileName);
 
-		void SetUnitMeasure(const UnitMeasure& nType);
 		void SetDpi(unsigned short int nValue);
-		void SetBodyTree(const CTree &oTree);
 
-		UnitMeasure GetUnitMeasure() const;
 		std::wstring GetEncoding() const;
 		unsigned short int GetDpi() const;
 
-		const std::map<std::wstring, CElement*>* GetData() const;
-
+		void ClearEmbeddedStyles();
+		void ClearAllowedStyleFiles();
+		void ClearStylesFromFile(const std::wstring& wsFilePath);
 		void Clear();
-
 	};
+
+	inline bool IsTableElement(const std::wstring& wsNameTag);
 }
 #endif // CCSSCALCULATOR_PRIVATE_H

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

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

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

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

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

@@ -2,29 +2,6 @@
 
 namespace NSCSS
 {
-	bool StatistickElement::operator<(const StatistickElement &oStatistickElement) const
-	{
-		return sValue < oStatistickElement.sValue;
-	}
-
-	void CTree::Clear()
-	{
-		m_arrChild.clear();
-		m_oNode.Clear();
-	}
-
-	void CTree::CountingNumberRepetitions(const CTree &oTree, std::map<StatistickElement, unsigned int> &mStatictics)
-	{
-		if (!oTree.m_oNode.m_wsId.empty())
-			++mStatictics[StatistickElement{StatistickElement::IsId, L'#' + oTree.m_oNode.m_wsId}];
-				if (!oTree.m_oNode.m_wsStyle.empty())
-					++mStatictics[StatistickElement{StatistickElement::IsStyle, oTree.m_oNode.m_wsStyle}];
-
-		if (!oTree.m_arrChild.empty())
-			for (const CTree& oChildren : oTree.m_arrChild)
-				CountingNumberRepetitions(oChildren, mStatictics);
-	}
-
 	namespace NSConstValues
 	{
 		const std::map<std::wstring, std::wstring> COLORS

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

@@ -16,28 +16,6 @@ namespace NSCSS
 		ScalingDirectionY = 2
 	} ScalingDirection;
 
-	struct StatistickElement
-	{
-		enum TypeElement
-		{
-			IsStyle = 0,
-			IsId
-		} m_enType;
-		std::wstring sValue;
-
-		bool operator<(const StatistickElement& oStatistickElement) const;
-	};
-
-	struct CTree
-	{
-		NSCSS::CNode m_oNode;
-		std::vector<CTree> m_arrChild;
-
-		void Clear();
-
-		static void CountingNumberRepetitions(const CTree &oTree, std::map<StatistickElement, unsigned int> &mStatictics);
-	};
-
 	namespace NSConstValues
 	{
 		extern const std::map<std::wstring, std::wstring> COLORS;

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

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

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

@@ -513,6 +513,9 @@ namespace NSCSS
 				return (*static_cast<std::wstring*>(m_oValue)) == (*static_cast<std::wstring*>(oColor.m_oValue));
 			case ColorUrl:
 				return (*static_cast<CURL*>(m_oValue)) == (*static_cast<CURL*>(oColor.m_oValue));
+			case ColorContextStroke:
+			case ColorContextFill:
+				return false;
 		}
 	}
 
@@ -532,6 +535,9 @@ namespace NSCSS
 				return (*static_cast<std::wstring*>(m_oValue)) != (*static_cast<std::wstring*>(oColor.m_oValue));
 			case ColorUrl:
 				return (*static_cast<CURL*>(m_oValue)) != (*static_cast<CURL*>(oColor.m_oValue));
+			case ColorContextStroke:
+			case ColorContextFill:
+				return false;
 		}
 	}
 
@@ -561,6 +567,9 @@ namespace NSCSS
 				m_oValue = new CURL(*static_cast<CURL*>(oColor.m_oValue));
 				break;
 			}
+			case ColorContextStroke:
+			case ColorContextFill:
+				break;
 		}
 
 		return *this;
@@ -580,6 +589,39 @@ namespace NSCSS
 		: CValue(NULL, 0, false), m_oOpacity(1.), m_enType(ColorEmpty)
 	{}
 
+	CColor::CColor(const CColor& oColor)
+		: CValue(NULL, 0, false), m_oOpacity(oColor.m_oOpacity), m_enType(oColor.m_enType)
+	{
+		switch (m_enType)
+		{
+			case ColorRGB:
+			{
+				TRGB *pRGB = static_cast<TRGB*>(oColor.m_oValue);
+				m_oValue = new TRGB(*pRGB);
+				break;
+			}
+			case ColorHEX:
+			{
+				std::wstring* pValue = static_cast<std::wstring*>(oColor.m_oValue);
+				m_oValue = new std::wstring(*pValue);
+				break;
+			}
+			case ColorUrl:
+			{
+				CURL *pURL = static_cast<CURL*>(oColor.m_oValue);
+				m_oValue = new CURL(*pURL);
+				break;
+			}
+			default:
+			break;
+		}
+	}
+
+	CColor::~CColor()
+	{
+		Clear();
+	}
+
 	void CColor::SetEmpty(unsigned int unLevel)
 	{
 		Clear();
@@ -875,6 +917,25 @@ namespace NSCSS
 		}
 	}
 
+	std::wstring CColor::ToHEX() const
+	{
+		switch(m_enType)
+		{
+			case ColorRGB:
+			{
+				TRGB* pRGB = static_cast<TRGB*>(m_oValue);
+				return ConvertRGBtoHEX(*pRGB);
+			}
+			case ColorHEX:
+			{
+				std::wstring *pValue = static_cast<std::wstring*>(m_oValue);
+				return *pValue;
+			}
+			default:
+				return std::wstring();
+		}
+	}
+
 	std::wstring CColor::EquateToColor(const std::vector<std::pair<TRGB, std::wstring>> &arColors) const
 	{
 		if (arColors.empty())

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

@@ -224,6 +224,8 @@ namespace NSCSS
 	{
 	public:
 		CColor();
+		CColor(const CColor& oColor);
+		~CColor();
 
 		bool SetValue(const std::wstring& wsValue, unsigned int unLevel = 0, bool bHardMode = true) override;
 		bool SetOpacity(const std::wstring& wsValue, unsigned int unLevel = 0, bool bHardMode = true);
@@ -240,6 +242,7 @@ namespace NSCSS
 		int ToInt() const override;
 		double ToDouble() const override;
 		std::wstring ToWString() const override;
+		std::wstring ToHEX() const;
 		std::wstring EquateToColor(const std::vector<std::pair<TRGB, std::wstring>>& arColors) const;
 		TRGB ToRGB() const;
 

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

@@ -316,7 +316,7 @@ namespace NSCSS
 
 		std::wstring wsTextAlign{oStyle.m_oText.GetAlign().ToWString()};
 
-		if (wsTextAlign.empty() && bInTable)
+		if (wsTextAlign.empty())
 			wsTextAlign = oStyle.m_oDisplay.GetHAlign().ToWString();
 
 		oXmlElement.AddPropertiesInP(PProperties::P_Jc, wsTextAlign);
@@ -485,7 +485,7 @@ namespace NSCSS
 			return;
 
 		if (!oStyle.m_oFont.GetSize().Empty())
-			oXmlElement.AddPropertiesInR(RProperties::R_Sz, std::to_wstring(static_cast<int>(oStyle.m_oFont.GetSize().ToDouble(NSCSS::Point) * 2. + 0.5))); // Значения шрифта увеличивает на 2
+			oXmlElement.AddPropertiesInR(RProperties::R_Sz, std::to_wstring(static_cast<int>(oStyle.m_oFont.GetSize().ToDouble(NSCSS::Point) * 2. * oStyle.m_oTransform.GetMatrix().GetFinalValue().sy() + 0.5))); // Значения шрифта увеличивает на 2
 
 		if (oStyle.m_oText.GetDecoration().m_oLine.Underline())
 			oXmlElement.AddPropertiesInR(RProperties::R_U, (!oStyle.m_oText.GetDecoration().m_oStyle.Empty()) ? oStyle.m_oText.GetDecoration().m_oStyle.ToWString() : L"single");

Common/OfficeFileErrorDescription.h

@@ -244,3 +244,4 @@
 #define AVS_FILEUTILS_ERROR_CONVERT_LIMITS								(AVS_ERROR_FIRST + AVS_FILEUTILS_ERROR_FIRST + 0x005d)
 #define AVS_FILEUTILS_ERROR_CONVERT_ROWLIMITS							(AVS_ERROR_FIRST + AVS_FILEUTILS_ERROR_FIRST + 0x005e)
 #define AVS_FILEUTILS_ERROR_CONVERT_DETECT								(AVS_ERROR_FIRST + AVS_FILEUTILS_ERROR_FIRST + 0x005f)
+#define AVS_FILEUTILS_ERROR_CONVERT_CELLLIMITS							(AVS_ERROR_FIRST + AVS_FILEUTILS_ERROR_FIRST + 0x0060)

Common/OfficeFileFormatChecker2.cpp

@@ -740,13 +740,33 @@ bool COfficeFileFormatChecker::isOfficeFile(const std::wstring &_fileName)
 	if (OfficeUtils.IsArchive(fileName) == S_OK && (false == isPdfFormatFile(bufferDetect, dwDetectdBytes, sDocumentID)))
 	{
 		if (isOOXFormatFile(fileName))
+        {
+            if (bufferDetect)
+                delete[] bufferDetect;
+            bufferDetect = NULL;
 			return true;
+        }
 		else if (isOpenOfficeFormatFile(fileName, sDocumentID))
-			return true;
+        {
+            if (bufferDetect)
+                delete[] bufferDetect;
+            bufferDetect = NULL;
+            return true;
+        }
 		else if (isOnlyOfficeFormatFile(fileName))
-			return true;
+        {
+            if (bufferDetect)
+                delete[] bufferDetect;
+            bufferDetect = NULL;
+            return true;
+        }
 		else if (isXpsFile(fileName))
-			return true;
+        {
+            if (bufferDetect)
+                delete[] bufferDetect;
+            bufferDetect = NULL;
+            return true;
+        }
 	}
 
 	//-----------------------------------------------------------------------------------------------
@@ -879,6 +899,16 @@ bool COfficeFileFormatChecker::isOfficeFile(const std::wstring &_fileName)
 		nFileType = AVS_OFFICESTUDIO_FILE_TEAMLAB_DOCY;
 	else if (0 == sExt.compare(L".txt") || 0 == sExt.compare(L".xml") || 0 == sExt.compare(L".rtf")	|| 0 == sExt.compare(L".doc") || 0 == sExt.compare(L".docx") || 0 == sExt.compare(L".md"))
 		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_TXT;
+	else 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 if (0 == sExt.compare(L".hwp"))
+		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HWP;
+	else if (0 == sExt.compare(L".hwpx"))
+		nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_HWPX;
 
 	if (nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN)
 		return true;
@@ -1345,6 +1375,7 @@ std::wstring COfficeFileFormatChecker::GetExtensionByType(int type)
 	case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTM:
 		return L".dotm";
 	case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC:
+	case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC_FLAT:
 		return L".doc";
 	case AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT:
 		return L".odt";

Common/OfficeFileFormats.h

@@ -56,6 +56,9 @@
 #define AVS_OFFICESTUDIO_FILE_DOCUMENT_OFORM			AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x0015
 #define AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCXF			AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x0016
 #define AVS_OFFICESTUDIO_FILE_DOCUMENT_OFORM_PDF		AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x0017
+#define AVS_OFFICESTUDIO_FILE_DOCUMENT_PAGES			AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x0018
+#define AVS_OFFICESTUDIO_FILE_DOCUMENT_HWP				AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x0019
+#define AVS_OFFICESTUDIO_FILE_DOCUMENT_HWPX				AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x0020
 
 #define AVS_OFFICESTUDIO_FILE_DOCUMENT_XML				AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x0030
 
@@ -72,6 +75,7 @@
 #define AVS_OFFICESTUDIO_FILE_PRESENTATION_OTP			AVS_OFFICESTUDIO_FILE_PRESENTATION + 0x000a
 #define AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX_PACKAGE	AVS_OFFICESTUDIO_FILE_PRESENTATION + 0x000b
 #define AVS_OFFICESTUDIO_FILE_PRESENTATION_ODG			AVS_OFFICESTUDIO_FILE_PRESENTATION + 0x000c
+#define AVS_OFFICESTUDIO_FILE_PRESENTATION_KEY			AVS_OFFICESTUDIO_FILE_PRESENTATION + 0x000d
 
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET				0x0100
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0001
@@ -87,6 +91,7 @@
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_OTS			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x000a
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX_FLAT		AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x000b
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX_PACKAGE	AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x000c
+#define AVS_OFFICESTUDIO_FILE_SPREADSHEET_NUMBERS		AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x000d
 
 #define AVS_OFFICESTUDIO_FILE_CROSSPLATFORM				0x0200
 #define AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF			AVS_OFFICESTUDIO_FILE_CROSSPLATFORM + 0x0001

Common/js/logging.h

@@ -4,6 +4,7 @@
 #include <stdio.h>
 #define LOG_BUFFER_SIZE 1000
 
+// not intended for use in production. only for testing/debugging purposes
 namespace Logging
 {
 void logBytes(char* name, unsigned char* str, int len)

DesktopEditor/doctrenderer/config.h

@@ -38,6 +38,9 @@
 #include "../xml/include/xmlutils.h"
 #include "../fontengine/TextHyphen.h"
 
+#define VALUE_TO_STRING(x) #x
+#define VALUE(x) VALUE_TO_STRING(x)
+
 namespace NSDoctRenderer
 {
 	class CAdditionalData
@@ -203,28 +206,14 @@ namespace NSDoctRenderer
 
 		char* GetVersion()
 		{
-			std::wstring sFile = m_strSdkPath + L"/word/sdk-all-min.js";
+			std::string sVersion = VALUE(INTVER);
 
-			std::string sData;
-			if (!NSFile::CFileBinary::ReadAllTextUtf8A(sFile, sData))
-				return NULL;
-
-			std::string::size_type startPos = sData.find("Version:");
-			if (std::string::npos == startPos)
-				return NULL;
-
-			startPos += 8;
-
-			std::string::size_type endPos = sData.find(')', startPos);
-			if (std::string::npos == endPos)
-				return NULL;
-
-			size_t sSrcLen = endPos - startPos + 1;
+			size_t sSrcLen = sVersion.size();
 			if (sSrcLen == 0)
 				return NULL;
 
 			char* sRet = new char[sSrcLen + 1];
-			memcpy(sRet, sData.c_str() + startPos, sSrcLen);
+			memcpy(sRet, sVersion.c_str(), sSrcLen);
 			sRet[sSrcLen] = '\0';
 			return sRet;
 		}

DesktopEditor/doctrenderer/docbuilder_p.cpp

@@ -240,6 +240,14 @@ bool CV8RealTimeWorker::InitVariables()
 		if (try_catch->Check())
 			return false;
 	}
+
+	if (!m_sJSCodeStart.empty())
+	{
+		m_context->runScript(m_sJSCodeStart, try_catch);
+		if (try_catch->Check())
+			return false;
+	}
+
 	return true;
 }
 
@@ -296,7 +304,7 @@ bool CV8RealTimeWorker::OpenFile(const std::wstring& sBasePath, const std::wstri
 		else if (1 == m_nFileType)
 			pNative->m_strEditorType = L"presentation";
 		else if (7 == m_nFileType)
-			pNative->m_strEditorType = L"draw";
+			pNative->m_strEditorType = L"visio";
 		else
 			pNative->m_strEditorType = L"spreadsheet";
 

DesktopEditor/doctrenderer/docbuilder_p.h

@@ -422,6 +422,7 @@ public:
 	int m_nFileType;
 	std::string m_sUtf8ArgumentJSON;
 	std::string m_sGlobalVariable;
+	std::string m_sJSCodeStart;
 
 	CJSContextData m_oContextData;
 
@@ -455,7 +456,8 @@ namespace NSDoctRenderer
 		std::wstring m_sTmpFolder;
 		std::wstring m_sFileDir;
 		int m_nFileType;
-		bool m_bJavascriptBeforeEditor;
+
+		std::wstring m_sCommandsBeforeContextCreated;
 
 		std::wstring m_sX2tPath;
 
@@ -478,7 +480,7 @@ namespace NSDoctRenderer
 	public:
 		CDocBuilder_Private() : CDoctRendererConfig(), m_sTmpFolder(NSFile::CFileBinary::GetTempPath()), m_nFileType(-1),
 			m_pWorker(NULL), m_pAdditionalData(NULL), m_bIsInit(false), m_bIsServerSafeVersion(false),
-			m_sGlobalVariable(""), m_bIsGlobalVariableUse(false), m_pParent(NULL), m_bJavascriptBeforeEditor(false)
+			m_sGlobalVariable(""), m_bIsGlobalVariableUse(false), m_pParent(NULL), m_sCommandsBeforeContextCreated(L"")
 		{
 		}
 
@@ -639,9 +641,6 @@ namespace NSDoctRenderer
 				NSDirectory::CreateDirectory(m_sFileDir + L"/changes");
 			}
 
-			if (m_bJavascriptBeforeEditor)
-				CheckWorkerAfterOpen();
-
 			return bRet;
 #else
 			std::wstring sPath = m_sX2tPath + L"/empty/new.";
@@ -930,11 +929,7 @@ namespace NSDoctRenderer
 			LOGGER_SPEED_LAP("open_convert");
 
 			if (0 == nReturnCode)
-			{
-				if (m_bJavascriptBeforeEditor)
-					CheckWorkerAfterOpen();
 				return 0;
-			}
 
 			NSDirectory::DeleteDirectory(m_sFileDir);
 			m_sFileDir = L"";
@@ -1220,36 +1215,27 @@ namespace NSDoctRenderer
 		{
 			if (NULL == m_pWorker)
 			{
-				m_pWorker = new CV8RealTimeWorker(m_pParent, GetEditorType(), this);
+				NSDoctRenderer::DoctRendererEditorType editorType = GetEditorType();
+				if (NSDoctRenderer::DoctRendererEditorType::INVALID == editorType)
+					return false;
+
+				m_pWorker = new CV8RealTimeWorker(m_pParent, editorType, this);
 				m_pWorker->m_sUtf8ArgumentJSON = m_oParams.m_sArgumentJSON;
 				m_pWorker->m_sGlobalVariable = m_sGlobalVariable;
+				m_pWorker->m_sJSCodeStart = U_TO_UTF8(m_sCommandsBeforeContextCreated);
+				m_sCommandsBeforeContextCreated = L"";
 
-				return CheckWorkerAfterOpen();
+				m_pWorker->m_nFileType = m_nFileType;
+
+				CV8Params oParams;
+				oParams.IsServerSaveVersion = m_bIsServerSafeVersion;
+				oParams.DocumentDirectory = m_sFileDir;
+
+				return m_pWorker->OpenFile(m_sX2tPath, m_sFileDir, editorType, this, &oParams);
 			}
 			return true;
 		}
 
-		bool CheckWorkerAfterOpen()
-		{
-			if (!m_pWorker)
-				return false;
-
-			m_pWorker->m_nFileType = m_nFileType;
-			if (-1 == m_nFileType)
-			{
-				m_bJavascriptBeforeEditor = true;
-				return false;
-			}
-
-			m_bJavascriptBeforeEditor = false;
-
-			CV8Params oParams;
-			oParams.IsServerSaveVersion = m_bIsServerSafeVersion;
-			oParams.DocumentDirectory = m_sFileDir;
-
-			return m_pWorker->OpenFile(m_sX2tPath, m_sFileDir, GetEditorType(), this, &oParams);
-		}
-
 		int SaveFile(const std::wstring& ext, const std::wstring& path, const wchar_t* params = NULL)
 		{
 			int nType = GetFormatByTexExtention(ext);
@@ -1261,21 +1247,26 @@ namespace NSDoctRenderer
 			if (command.length() < 7 && !retValue) // minimum command (!!!)
 				return true;
 
+			if (m_nFileType == -1)
+			{
+				m_sCommandsBeforeContextCreated += command;
+				return true;
+			}
+
 			Init();
 
-			bool bRes = CheckWorker();
+			if (CheckWorker())
+				return m_pWorker->ExecuteCommand(command, retValue);
 
-			if (!bRes && m_pWorker && m_bJavascriptBeforeEditor)
-				m_pWorker->InitVariables();
-
-			return m_pWorker->ExecuteCommand(command, retValue);
+			return false;
 		}
 
 		CDocBuilderContext GetContext(bool enterContext)
 		{
 			CDocBuilderContext ctx;
 
-			CheckWorker();
+			if (!CheckWorker())
+				return ctx;
 
 			ctx.m_internal->m_context = m_pWorker->m_context;
 			ctx.m_internal->m_context_data = &m_pWorker->m_oContextData;

DesktopEditor/doctrenderer/doctrenderer.cpp

@@ -986,7 +986,7 @@ namespace NSDoctRenderer
 			case DoctRendererFormat::IMAGE:
 			{
 				editorType = NSDoctRenderer::DoctRendererEditorType::VISIO;
-				m_pInternal->m_strEditorType = L"draw";
+				m_pInternal->m_strEditorType = L"visio";
 				break;
 			}
 			default:

DesktopEditor/doctrenderer/doctrenderer.pro

@@ -121,7 +121,7 @@ drawingfile_support {
 		embed/DrawingFileEmbed.h
 
 	SOURCES += \
-		../../HtmlRenderer/src/HTMLRendererText.cpp \
+		../graphics/pro/js/wasm/src/HTMLRendererText.cpp \
 		embed/DrawingFileEmbed.cpp
 
 	ADD_FILES_FOR_EMBEDDED_CLASS_HEADER(embed/DrawingFileEmbed.h)

DesktopEditor/doctrenderer/drawingfile.h

@@ -38,8 +38,8 @@
 #include "../../PdfFile/PdfFile.h"
 #include "../../XpsFile/XpsFile.h"
 #include "../../DjVuFile/DjVu.h"
-#include "../../DesktopEditor/graphics/pro/js/wasm/src/serialize.h"
-#include "../../HtmlRenderer/include/HTMLRendererText.h"
+#include "../graphics/pro/js/wasm/src/serialize.h"
+#include "../graphics/pro/js/wasm/src/HTMLRendererText.h"
 #include "../../DocxRenderer/DocxRenderer.h"
 
 #define CHECKER_FILE_BUFFER_LEN 4096
@@ -542,8 +542,8 @@ private:
 		}
 		if (m_nType == 0)
 			nRotate = ((CPdfFile*)m_pFile)->GetRotate(nPageIndex);
-		nWidth    = dWidth;
-		nHeight   = dHeight;
+		nWidth    = round(dWidth);
+		nHeight   = round(dHeight);
 		nPageDpiX = dPageDpiX;
 	}
 

DesktopEditor/doctrenderer/editors.cpp

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

DesktopEditor/doctrenderer/embed/DrawingFileEmbed.cpp

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

DesktopEditor/doctrenderer/embed/ZipEmbed.cpp

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

DesktopEditor/doctrenderer/embed/ZipEmbed.h

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

DesktopEditor/doctrenderer/embed/jsc/jsc_ZipEmbed.mm

@@ -17,6 +17,7 @@
 -(JSValue*) encodeImageData : (JSValue*)typedArray : (JSValue*)w : (JSValue*)h : (JSValue*)stride : (JSValue*)format : (JSValue*)isRgba;
 -(JSValue*) encodeImage : (JSValue*)typedArray : (JSValue*)format;
 -(JSValue*) getImageType : (JSValue*)typedArray;
+-(JSValue*) getImageBuffer : (JSValue*)path;
 @end
 
 @interface CJSCZipEmbed : NSObject<IJSCZipEmbed, JSEmbedObjectProtocol>
@@ -41,6 +42,7 @@ FUNCTION_WRAPPER_JS_2(decodeImage, decodeImage)
 FUNCTION_WRAPPER_JS_6(encodeImageData, encodeImageData)
 FUNCTION_WRAPPER_JS_2(encodeImage, encodeImage)
 FUNCTION_WRAPPER_JS_1(getImageType, getImageType)
+FUNCTION_WRAPPER_JS_1(getImageBuffer, getImageBuffer)
 @end
 
 class CZipEmbedAdapter : public CJSEmbedObjectAdapterJSC

DesktopEditor/doctrenderer/embed/v8/v8_ZipEmbed.cpp

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

DesktopEditor/fontengine/ApplicationFontsWorker.cpp

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

DesktopEditor/fontengine/js/allfonts/module.js

@@ -1,5 +1,5 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * (c) Copyright Ascensio System SIA 2010-2024
  *
  * This program is a free software product. You can redistribute it and/or
  * modify it under the terms of the GNU Affero General Public License (AGPL)

DesktopEditor/fontengine/js/cpp/text.cpp

@@ -1,5 +1,5 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * (c) Copyright Ascensio System SIA 2010-2024
  *
  * This program is a free software product. You can redistribute it and/or
  * modify it under the terms of the GNU Affero General Public License (AGPL)

DesktopEditor/fontengine/js/engine/module_js.js

@@ -1,5 +1,5 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * (c) Copyright Ascensio System SIA 2010-2024
  *
  * This program is a free software product. You can redistribute it and/or
  * modify it under the terms of the GNU Affero General Public License (AGPL)
@@ -531,6 +531,45 @@ ZLib.prototype.getImageAsSvg = function(path)
 
 	return string;
 };
+/**
+ * Get image file raw data. this memory was copied and detach from archive.
+ * @returns {Uint8Array}
+ */
+ZLib.prototype.getImageBuffer = function(path)
+{
+	let result = {
+		type : 0,
+		data : null
+	};
+	result.type = this.getImageType(path);
+	if (result.type === 0)
+		return null;
+
+	let fileData = this.getFile(path);
+	result.data = new Uint8Array(fileData.length);
+	result.data.set(fileData);
+	
+	if (result.type != 10 && 
+		result.type != 21)
+	{
+		return result;
+	}
+
+	result.type = 24;
+	// Source was saved as result.data for using original image in native convertations.
+	// But for js we need svg for metafiles.
+
+	let encodedData = Module["_Raster_Encode"](this.files[path].p + 4, fileData.length, 24);
+	let encodedSize = Module["_Raster_GetEncodedSize"](encodedData);
+	let encodedBuffer = Module["_Raster_GetEncodedBuffer"](encodedData);
+
+	let fileDataEnc = new Uint8Array(Module["HEAP8"].buffer, encodedBuffer, encodedSize);
+	result.dataBlob = new Uint8Array(fileDataEnc.length);
+	result.dataBlob.set(fileDataEnc);
+	
+	Module["_Raster_DestroyEncodedData"](encodedData);
+	return result;
+};
 /**
  * Get image blob for browser
  * @returns {Blob}

DesktopEditor/fontengine/js/engine/module_native.js

@@ -1,5 +1,5 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * (c) Copyright Ascensio System SIA 2010-2024
  *
  * This program is a free software product. You can redistribute it and/or
  * modify it under the terms of the GNU Affero General Public License (AGPL)
@@ -35,7 +35,7 @@
 window['AscFonts'] = window['AscFonts'] || {};
 var AscFonts = window['AscFonts'];
 
-var g_native_engine = CreateEmbedObject("CTextMeasurerEmbed");
+var g_native_engine = null;
 
 function CReturnObject()
 {
@@ -236,4 +236,6 @@ AscFonts.Hyphen_Word = function(lang, word)
 AscFonts.onLoadModule();
 AscFonts.onLoadModule();
 
+window["InitNativeTextMeasurer"] = function() { g_native_engine = CreateEmbedObject("CTextMeasurerEmbed"); };
+
 })(window, undefined);

DesktopEditor/fontengine/js/libfont.json

@@ -100,6 +100,7 @@
 		"FT_CONFIG_OPTION_SYSTEM_ZLIB",
 		"GRAPHICS_NO_USE_DYNAMIC_LIBRARY",
 		"HYPHEN_ENGINE_DISABLE_FILESYSTEM",
+		"METAFILE_DISABLE_FILESYSTEM",
 
 		"HAVE_UNISTD_H", "HAVE_FCNTL_H", "_ARM_ALIGN_",
 		"METAFILE_SUPPORT_WMF_EMF",

DesktopEditor/fontengine/js/module.js

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

DesktopEditor/graphics/BooleanOperations.cpp

@@ -142,6 +142,14 @@ std::vector<double> Curve::GetYValues() const noexcept
 	return {Segment1.P.Y, Segment2.P.Y + Segment2.HI.Y, Segment2.P.Y + Segment2.HO.Y, Segment2.P.Y};
 }
 
+std::vector<double> Curve::GetBound() const noexcept
+{
+	return {min(Segment1.P.X, Segment2.P.X + Segment2.HI.X, Segment2.P.X + Segment2.HO.X, Segment2.P.X),
+			min(Segment1.P.Y, Segment2.P.Y + Segment2.HI.Y, Segment2.P.Y + Segment2.HO.Y, Segment2.P.Y),
+			max(Segment1.P.X, Segment2.P.X + Segment2.HI.X, Segment2.P.X + Segment2.HO.X, Segment2.P.X),
+			max(Segment1.P.Y, Segment2.P.Y + Segment2.HI.Y, Segment2.P.Y + Segment2.HO.Y, Segment2.P.Y)};
+}
+
 std::vector<double> Curve::GetPeeks() const
 {
 	std::vector<double> x = GetXValues(),
@@ -270,8 +278,31 @@ double Curve::GetTimeAt(const double& offset) const noexcept
 			by = 6 * (y[0] + y[2]) - 12 * y[1],
 			cy = 3 * (y[1] - y[0]);
 
-	return findRoot(length, start, offset, ax, bx, cx,
-					ay, by, cy, start + guess, a, b);
+	double vx = start + guess;
+	for (size_t i = 0; i < 32; i++)
+	{
+		length += integrate(ax, bx, cx, ay, by, cy, start, vx, getIterations(start, vx));
+		start = vx;
+
+		double dx = vx - (length - offset) / CurveLength(vx, ax, bx, cx, ay, by, cy);
+		if (fabs(vx - dx) < EPSILON)
+		{
+			vx = dx;
+			break;
+		}
+
+		if (length - offset > 0)
+		{
+			b = vx;
+			vx = dx <= a ? (a + b) * 0.5 : dx;
+		}
+		else{
+			a = vx;
+			vx = dx >= b ? (a + b) * 0.5 : dx;
+		}
+	}
+
+	return clamp(vx, a, b);
 }
 
 PointD Curve::Get(const double& t, const int& type) const noexcept
@@ -408,15 +439,15 @@ std::vector<std::pair<double, double>> Curve::GetOverlaps(const Curve& curve) co
 		std::swap(y1, y2);
 	}
 
-	double	d20 = getDistance(px, py, vx, vy, x2[0], y2[0], true),
-			d23 = getDistance(px, py, vx, vy, x2[3], y2[3], true);
+	double	d20 = fabs(getSignedDistance(px, py, vx, vy, x2[0], y2[0], true)),
+			d23 = fabs(getSignedDistance(px, py, vx, vy, x2[3], y2[3], true));
 
 	if (d20 < GEOMETRIC_EPSILON && d23 < GEOMETRIC_EPSILON)
 	{
-		double	d11 = getDistance(px, py, vx, vy, x1[1], y1[1], true),
-				d12 = getDistance(px, py, vx, vy, x1[2], y1[2], true),
-				d21 = getDistance(px, py, vx, vy, x2[1], y2[1], true),
-				d22 = getDistance(px, py, vx, vy, x2[2], y2[2], true);
+		double	d11 = fabs(getSignedDistance(px, py, vx, vy, x1[1], y1[1], true)),
+				d12 = fabs(getSignedDistance(px, py, vx, vy, x1[2], y1[2], true)),
+				d21 = fabs(getSignedDistance(px, py, vx, vy, x2[1], y2[1], true)),
+				d22 = fabs(getSignedDistance(px, py, vx, vy, x2[2], y2[2], true));
 
 		if (!straightBoth &&
 			d11 < GEOMETRIC_EPSILON &&
@@ -612,10 +643,10 @@ int Curve::SolveCubic(double a, double b, double c, double d,
 		q = c2 * x + d;
 
 		double	t = q / a,
-				r = pow(fabs(t), 1 / 3),
+				r = pow(fabs(t), 1.0 / 3.0),
 				s = t < 0 ? -1 : 1,
 				td = -qd / a,
-				rd = td > 0 ? 1.324717957244746 * std::max(r, sqrt(td)) : r,
+				rd = td > 0 ? 1.324717957244746 * std::max(r, std::sqrt(td)) : r,
 				x0 = x - s * rd;
 
 		if (x0 != x)
@@ -716,9 +747,9 @@ CBooleanOperations::CBooleanOperations(const CGraphicsPath& path1,
 	Op(op),
 	Close1(path1.Is_poly_closed()),
 	Close2(path2.Is_poly_closed()),
+	FillType(fillType),
 	Path1(path1),
-	Path2(path2),
-	FillType(fillType)
+	Path2(path2)
 {
 	TraceBoolean();
 }
@@ -1222,35 +1253,22 @@ void CBooleanOperations::SetVisited(const Segment& segment)
 		Segments2[segment.Index].Visited = true;
 }
 
-std::vector<std::vector<double>> CBooleanOperations::GetBoundsForCurves(const std::vector<Curve>& curves) const noexcept
-{
-	std::vector<std::vector<double>> bounds;
-	for (int i = 0; i < curves.size(); i++)
-	{
-		std::vector<double>	x = curves[i].GetXValues(),
-			y = curves[i].GetYValues();
-		bounds.push_back({min(x[0], x[1], x[2], x[3]),
-						  min(y[0], y[1], y[2], y[3]),
-						  max(x[0], x[1], x[2], x[3]),
-						  max(y[0], y[1], y[2], y[3])});
-	}
-	return bounds;
-}
-
 std::vector<std::vector<int>> CBooleanOperations::FindBoundsCollisions()
 {
-	std::vector<std::vector<double>> bounds1 = GetBoundsForCurves(Curves1);
-	std::vector<std::vector<double>> bounds2 = GetBoundsForCurves(Curves2);
+	std::vector<std::vector<double>> allBounds, bounds2;
+	for (const auto& c : Curves1)
+		allBounds.push_back(c.GetBound());
+	for (const auto& c : Curves2)
+		bounds2.push_back(c.GetBound());
 
-	bool self = bounds1 == bounds2;
+	bool self = allBounds == bounds2;
 
-	std::vector<std::vector<double>> allBounds(bounds1);
 	if (!self)
-		for (auto it = bounds2.begin(); it != bounds2.end(); ++it) // std::copy(bounds2.begin(), bounds2.end(), std::back_inserter(allBounds));
+		for (auto it = bounds2.begin(); it != bounds2.end(); ++it)
 			allBounds.push_back(*it);
 
 	int	allLength = static_cast<int>(allBounds.size()),
-		length1	  = static_cast<int>(bounds1.size());
+		length1	  = static_cast<int>(Curves1.size());
 
 	std::vector<int> allIdicesByPri1(allLength);
 	for (int i = 0; i < allLength; i++)
@@ -1266,56 +1284,47 @@ std::vector<std::vector<int>> CBooleanOperations::FindBoundsCollisions()
 	std::vector<std::vector<int>> allCollisions(length1);
 	for (int i = 0; i < allLength; i++)
 	{
-		int curIndex = allIdicesByPri1[i];
-		std::vector<double>	curBounds = allBounds[curIndex];
 		std::vector<int>	curCollisions;
-		bool isCurrent1 = curIndex < length1,
+		bool isCurrent1 = allIdicesByPri1[i] < length1,
 			 isCurrent2 = self || !isCurrent1;
-		int  origIndex = self ? curIndex : curIndex - length1;
+		int  origIndex = self ? allIdicesByPri1[i] : allIdicesByPri1[i] - length1;
 
 		if (!activeIndicesByPri2.empty())
 		{
 			int pruneCount = binarySearch(allBounds, activeIndicesByPri2, 2,
-										  curBounds[0] - GEOMETRIC_EPSILON) + 1;
+										  allBounds[allIdicesByPri1[i]][0] - GEOMETRIC_EPSILON) + 1;
 
 			activeIndicesByPri2.erase(activeIndicesByPri2.begin(),
 									  activeIndicesByPri2.begin() + pruneCount);
-
-			double	curSec2 = curBounds[3],
-				curSec1 = curBounds[1];
 			for (int j = 0; j < static_cast<int>(activeIndicesByPri2.size()); j++)
 			{
-				int activeIndex = activeIndicesByPri2[j];
-				std::vector<double> activeBounds = allBounds[activeIndex];
-				bool isActive1 = activeIndex < length1,
+				bool isActive1 = activeIndicesByPri2[j] < length1,
 					 isActive2 = self || !isActive1,
 					 isActive1Or2 = (isCurrent1 && isActive2) || (isCurrent2 && isActive1),
-					 inRange1 = curSec1 <= activeBounds[3] + GEOMETRIC_EPSILON,
-					 inRange2 = curSec2 >= activeBounds[1] - GEOMETRIC_EPSILON;
+					 inRange1 = allBounds[allIdicesByPri1[i]][1] <= allBounds[activeIndicesByPri2[j]][3] + GEOMETRIC_EPSILON,
+					 inRange2 = allBounds[allIdicesByPri1[i]][3] >= allBounds[activeIndicesByPri2[j]][1] - GEOMETRIC_EPSILON;
 
 				if (isActive1Or2 && (inRange2 && inRange1))
 				{
 					if (isCurrent1 && isActive2)
-						curCollisions.push_back(self ? activeIndex : activeIndex - length1);
+						curCollisions.push_back(self ? activeIndicesByPri2[j] : activeIndicesByPri2[j] - length1);
 					if (isCurrent2 && isActive1)
-						allCollisions[activeIndex].push_back(origIndex);
+						allCollisions[activeIndicesByPri2[j]].push_back(origIndex);
 				}
 			}
 		}
 		if (isCurrent1)
 		{
-			if (bounds1 == bounds2)
-				curCollisions.push_back(curIndex);
-			allCollisions[curIndex] = curCollisions;
+			if (self) curCollisions.push_back(allIdicesByPri1[i]);
+			allCollisions[allIdicesByPri1[i]] = curCollisions;
 		}
 		if (activeIndicesByPri2.size() > 0)
 		{
-			double curPri2 = curBounds[2];
-			int index = binarySearch(allBounds, activeIndicesByPri2, 2, curPri2);
-			activeIndicesByPri2.insert(activeIndicesByPri2.begin() + (1 + index), curIndex);
+			int index = 1 + binarySearch(allBounds, activeIndicesByPri2, 2, allBounds[allIdicesByPri1[i]][2]);
+			activeIndicesByPri2.insert(activeIndicesByPri2.begin() + index, allIdicesByPri1[i]);
 		}
 		else
-			activeIndicesByPri2.push_back(curIndex);
+			activeIndicesByPri2.push_back(allIdicesByPri1[i]);
 	}
 
 	for (auto& c : allCollisions)
@@ -1388,11 +1397,6 @@ bool CBooleanOperations::IsCrossing(std::shared_ptr<Location> loc) noexcept
 	return t1Inside ? inRange1 : inRange2;
 }
 
-bool CBooleanOperations::FilterIntersections(std::shared_ptr<Location> loc) noexcept
-{
-	return loc->Overlap || IsCrossing(loc);
-}
-
 bool CBooleanOperations::IntersectsBounds() noexcept
 {
 	RectF_T<double> rect1, rect2;
@@ -1407,17 +1411,12 @@ bool CBooleanOperations::IntersectsBounds() noexcept
 
 void CBooleanOperations::GetIntersection()
 {
-	if (!IntersectsBounds())
-		return;
+	if (!IntersectsBounds()) return;
 
 	std::vector<std::vector<int>> boundsCollisions = FindBoundsCollisions();
 	for (int index1 = 0; index1 < Curves1.size(); index1++)
-	{
-		std::vector<int> collisions1 = boundsCollisions[index1];
-		if (!collisions1.empty())
-			for (int j = 0; j < collisions1.size(); j++)
-				GetCurveIntersection(Curves1[index1], Curves2[collisions1[j]]);
-	}
+		for (int j = 0; j < boundsCollisions[index1].size(); j++)
+			GetCurveIntersection(Curves1[index1], Curves2[boundsCollisions[index1][j]]);
 }
 
 void CBooleanOperations::GetCurveIntersection(const Curve& curve1, const Curve& curve2)
@@ -1538,15 +1537,15 @@ int CBooleanOperations::AddCurveIntersection(const Curve& curve1, const Curve& c
 						x2 = curve2.GetXValues(),
 						y2 = curve2.GetYValues();
 
-	double	d1 = getSignedDistance(x2[0], y2[0], x2[3], y2[3], x2[1], y2[1]),
-			d2 = getSignedDistance(x2[0], y2[0], x2[3], y2[3], x2[2], y2[2]),
+	double	d1 = getSignedDistance(x2[0], y2[0], x2[3], y2[3], x2[1], y2[1], false),
+			d2 = getSignedDistance(x2[0], y2[0], x2[3], y2[3], x2[2], y2[2], false),
 			factor = (d1 * d2) > 0 ? 3.0 / 4.0 : 4.0 / 9.0,
 			dMin = factor * min(0, d1, d2),
 			dMax = factor * max(0, d1, d2),
-			dp0 = getSignedDistance(x2[0], y2[0], x2[3], y2[3], x1[0], y1[0]),
-			dp1 = getSignedDistance(x2[0], y2[0], x2[3], y2[3], x1[1], y1[1]),
-			dp2 = getSignedDistance(x2[0], y2[0], x2[3], y2[3], x1[2], y1[2]),
-			dp3 = getSignedDistance(x2[0], y2[0], x2[3], y2[3], x1[3], y1[3]);
+			dp0 = getSignedDistance(x2[0], y2[0], x2[3], y2[3], x1[0], y1[0], false),
+			dp1 = getSignedDistance(x2[0], y2[0], x2[3], y2[3], x1[1], y1[1], false),
+			dp2 = getSignedDistance(x2[0], y2[0], x2[3], y2[3], x1[2], y1[2], false),
+			dp3 = getSignedDistance(x2[0], y2[0], x2[3], y2[3], x1[3], y1[3], false);
 
 	std::vector<PointD> top;
 	std::vector<PointD> bottom;
@@ -1884,7 +1883,7 @@ void CBooleanOperations::AddLocation(Curve curve1, Curve curve2, double t1,
 			loc1->Inters = loc2;
 			loc2->Inters = loc1;
 
-			if (!filter || FilterIntersections(loc1))
+			if (!filter || loc1->Overlap || IsCrossing(loc1))
 				InsertLocation(loc1, overlap);
 		}
 	}

DesktopEditor/graphics/BooleanOperations.h

@@ -54,6 +54,7 @@ namespace Aggplus
 
 		std::vector<double> GetXValues() const noexcept;
 		std::vector<double> GetYValues() const noexcept;
+		std::vector<double> GetBound() const noexcept;
 		std::vector<double> GetPeeks() const;
 		double GetLength(double a = 0, double b = 1) const;
 		double GetSquaredLineLength() const noexcept;
@@ -81,7 +82,6 @@ namespace Aggplus
 		void Flip() noexcept;
 
 		bool IsStraight()	const noexcept;
-		bool HasHandle()	const noexcept;
 		bool operator==(const Curve& other) const noexcept;
 		bool operator!=(const Curve& other) const noexcept;
 	};
@@ -128,12 +128,10 @@ namespace Aggplus
 		void	SetVisited(const Segment& segment);
 
 		// Bounds
-		std::vector<std::vector<double>> GetBoundsForCurves(const std::vector<Curve>& curves) const noexcept;
 		std::vector<std::vector<int>>	 FindBoundsCollisions();
 
 		// Intersection
 		bool IsCrossing(std::shared_ptr<Location> loc) noexcept;
-		bool FilterIntersections(std::shared_ptr<Location> loc) noexcept;
 		bool IntersectsBounds() noexcept;
 		void GetIntersection();
 		void GetCurveIntersection(const Curve& curve1, const Curve& curve2);

DesktopEditor/graphics/Clip.cpp

@@ -191,6 +191,16 @@ namespace Aggplus
 	{
 	}
 
+	CClipMulti::clip_rasterizer* CClipMulti::GetRasterizer()
+	{
+		if (!m_bIsClip)
+		{
+			m_rasterizer.reset();
+			return &m_rasterizer;
+		}
+		return NULL;
+	}
+
 	void CClipMulti::Create(LONG width, LONG height)
 	{
 		m_lWidth = width;
@@ -212,62 +222,52 @@ namespace Aggplus
 
 		typedef agg::conv_curve<trans_type> conv_crv_type;
 		conv_crv_type c_c_path(trans);
-			 
+
 		m_rasterizer.add_path(c_c_path);
-		m_rasterizer.filling_rule(pPath->m_internal->m_bEvenOdd ? agg::fill_even_odd : agg::fill_non_zero);
+
+		GenerateClip2(pPath->m_internal->m_bEvenOdd);
+	}
+
+	void CClipMulti::GenerateClip2(bool bEvenOdd)
+	{
+		m_rasterizer.filling_rule(bEvenOdd ? agg::fill_even_odd : agg::fill_non_zero);
 
 		m_bIsClip = true;
 		m_bIsClip2 = false;
 	}
 	
-	void CClipMulti::Combine(CGraphicsPath* pPath, CMatrix* pMatrix, agg::sbool_op_e op)
+	void CClipMulti::Combine(bool bEvenOdd, agg::sbool_op_e op, clip_rasterizer* pRasterizer)
 	{
+		if (!pRasterizer)
+			return;
+
 		if (!m_bIsClip)
-			return GenerateClip(pPath, pMatrix);
+			return GenerateClip2(bEvenOdd);
 
 		if (!m_bIsClip2)
 		{
 			// смешивать надо с растерайзером
-			agg::rasterizer_scanline_aa<agg::rasterizer_sl_clip_dbl> rasterizer;
-			rasterizer.clip_box(0, 0, m_lWidth, m_lHeight);
-
-			typedef agg::conv_transform<agg::path_storage> trans_type;
-			trans_type trans(pPath->m_internal->m_agg_ps, pMatrix->m_internal->m_agg_mtx);
-
-			typedef agg::conv_curve<trans_type> conv_crv_type;
-			conv_crv_type c_c_path(trans);
-				 
-			rasterizer.add_path(c_c_path);
-			rasterizer.filling_rule(pPath->m_internal->m_bEvenOdd ? agg::fill_even_odd : agg::fill_non_zero);
+			pRasterizer->filling_rule(bEvenOdd ? agg::fill_even_odd : agg::fill_non_zero);
 
 			scanline_type sl1; 
 			scanline_type sl2;
 			scanline_type sl;
 
-			agg::sbool_combine_shapes_aa(op, m_rasterizer, rasterizer, sl1, sl2, sl, m_storage1);
+			agg::sbool_combine_shapes_aa(op, m_rasterizer, *pRasterizer, sl1, sl2, sl, m_storage1);
 
 			m_lCurStorage = 1;
 		}
 		else
 		{
 			// надо смешивать со стораджем
-			agg::rasterizer_scanline_aa<agg::rasterizer_sl_clip_dbl> rasterizer;
-			rasterizer.clip_box(0, 0, m_lWidth, m_lHeight);
 
-			typedef agg::conv_transform<agg::path_storage> trans_type;
-			trans_type trans(pPath->m_internal->m_agg_ps, pMatrix->m_internal->m_agg_mtx);
-
-			typedef agg::conv_curve<trans_type> conv_crv_type;
-			conv_crv_type c_c_path(trans);
-				 
-			rasterizer.add_path(c_c_path);
-			rasterizer.filling_rule(pPath->m_internal->m_bEvenOdd ? agg::fill_even_odd : agg::fill_non_zero);
+			pRasterizer->filling_rule(op ? agg::fill_even_odd : agg::fill_non_zero);
 
 			scanline_type sl1; 
 			scanline_type sl2;
 			scanline_type sl; 
 
-			agg::sbool_combine_shapes_aa(op, rasterizer, (m_lCurStorage == 1) ? m_storage1 : m_storage2, sl1, sl2, sl, 
+			agg::sbool_combine_shapes_aa(op, *pRasterizer, (m_lCurStorage == 1) ? m_storage1 : m_storage2, sl1, sl2, sl,
 														(m_lCurStorage == 1) ? m_storage2 : m_storage1);
 
 			if (1 == m_lCurStorage)

DesktopEditor/graphics/Clip.h

@@ -138,10 +138,11 @@ public:
 
 class CClipMulti
 {
-	typedef agg::scanline_p8 scanline_type;
-
 public:
-	agg::rasterizer_scanline_aa<agg::rasterizer_sl_clip_dbl> m_rasterizer;
+	typedef agg::scanline_p8 scanline_type;
+	typedef agg::rasterizer_scanline_aa<agg::rasterizer_sl_clip_dbl> clip_rasterizer;
+
+	clip_rasterizer m_rasterizer;
 	
 	agg::scanline_storage_aa8 m_storage1;
 	agg::scanline_storage_aa8 m_storage2;
@@ -158,10 +159,13 @@ public:
 	CClipMulti();
 	~CClipMulti();
 
+	clip_rasterizer* GetRasterizer();
+
 	void Create(LONG width, LONG height);
 	void GenerateClip(CGraphicsPath* pPath, CMatrix* pMatrix);
+	void GenerateClip2(bool bEvenOdd);
 	
-	void Combine(CGraphicsPath* pPath, CMatrix* pMatrix, agg::sbool_op_e op);
+	void Combine(bool bEvenOdd, agg::sbool_op_e op, clip_rasterizer* pRasterizer);
 
 	bool IsClip();
 	bool IsClip2();

DesktopEditor/graphics/Graphics.cpp

@@ -502,18 +502,41 @@ namespace Aggplus
 		return Ok;
 	}
 
-	Status CGraphics::CombineClip(CGraphicsPath* pPath, agg::sbool_op_e op)
+	Status CGraphics::CombineClip(CGraphicsPath* pPath, agg::sbool_op_e op, NSStructures::CPen* pPen)
 	{
 		Aggplus::CMatrix m;
-		return InternalClip(pPath, (m_bIntegerGrid || pPath->m_internal->m_pTransform != NULL) ? &m : &m_oFullTransform, op);
+		return InternalClip(pPath, (m_bIntegerGrid || pPath->m_internal->m_pTransform != NULL) ? &m : &m_oFullTransform, op, pPen);
 	}
 
-	Status CGraphics::InternalClip(CGraphicsPath* pPath, CMatrix* pTransform, agg::sbool_op_e op)
+	Status CGraphics::InternalClip(CGraphicsPath* pPath, CMatrix* pTransform, agg::sbool_op_e op, NSStructures::CPen* pPen)
 	{
 		if (NULL == pPath)
 			return InvalidParameter;
 
-		m_oClip.Combine(pPath, pTransform, op);
+		bool bTempRasterizer = false;
+		CClipMulti::clip_rasterizer* pRasterizer = m_oClip.GetRasterizer();
+		if (!pRasterizer)
+		{
+			pRasterizer = new CClipMulti::clip_rasterizer();
+			pRasterizer->clip_box(0, 0, m_oClip.m_lWidth, m_oClip.m_lHeight);
+			bTempRasterizer = true;
+		}
+
+		agg::trans_affine* pAffine = NULL;
+		if (pPen)
+			pAffine = DoStrokePath(pPen, pPath, pRasterizer);
+		else
+		{
+			typedef agg::conv_transform<agg::path_storage> trans_type;
+			trans_type trans(pPath->m_internal->m_agg_ps, pTransform->m_internal->m_agg_mtx);
+
+			typedef agg::conv_curve<trans_type> conv_crv_type;
+			conv_crv_type c_c_path(trans);
+
+			pRasterizer->add_path(c_c_path);
+		}
+
+		m_oClip.Combine(pPath->m_internal->m_bEvenOdd, op, pRasterizer);
 
 		// write to clips history
 		CGraphics_ClipStateRecord* pRecord = new CGraphics_ClipStateRecord();
@@ -522,6 +545,11 @@ namespace Aggplus
 		pRecord->Operation = op;
 		m_oClipState.AddRecord(pRecord);
 
+		if (pAffine)
+			delete pAffine;
+		if (bTempRasterizer)
+			delete pRasterizer;
+
 		return Ok;
 	}
 
@@ -610,180 +638,7 @@ namespace Aggplus
 
 		m_rasterizer.get_rasterizer().reset();
 
-		agg::line_join_e LineJoin = agg::round_join;
-		switch(pPen->LineJoin)
-		{
-		case LineJoinMiter			: LineJoin = agg::miter_join_revert; break;
-		case LineJoinBevel			: LineJoin = agg::bevel_join; break;
-		case LineJoinRound			: LineJoin = agg::round_join; break;
-		case LineJoinMiterClipped	: LineJoin = agg::miter_join_revert; break;
-		default:	break;
-		}
-		agg::line_cap_e LineCap = agg::round_cap;
-		switch(pPen->LineStartCap)
-		{
-		case LineCapFlat         : LineCap = agg::butt_cap; break;
-		case LineCapRound        : LineCap = agg::round_cap; break;
-		case LineCapSquare       : LineCap = agg::square_cap; break;
-		default:	break;
-		}
-
-		double dWidth = pPen->Size;
-		if (!m_bIntegerGrid && m_bIs0PenWidthAs1px)
-		{
-			double dWidthMinSize, dSqrtDet = sqrt(abs(m_oFullTransform.m_internal->m_agg_mtx.determinant()));
-			if (0 == dWidth)
-			{
-				double dX = 0.72, dY = 0.72;
-				agg::trans_affine invert = ~m_oFullTransform.m_internal->m_agg_mtx;
-				invert.transform_2x2(&dX, &dY);
-				dWidth = std::min(abs(dX), abs(dY));
-			}
-			else if (0 != dSqrtDet && dWidth < (dWidthMinSize = 1.0 / dSqrtDet))
-				dWidth = dWidthMinSize;
-		}
-		
-		double dblMiterLimit = pPen->MiterLimit;
-		
-		agg::path_storage path_copy(pPath->m_internal->m_agg_ps);
-		bool bIsUseIdentity = m_bIntegerGrid;
-		if (!bIsUseIdentity)
-		{
-			agg::trans_affine* full_trans = &m_oFullTransform.m_internal->m_agg_mtx;
-			double dDet = full_trans->determinant();
-
-			if (fabs(dDet) < 0.0001)
-			{
-				path_copy.transform_all_paths(m_oFullTransform.m_internal->m_agg_mtx);
-				dWidth *= sqrt(fabs(dDet));
-
-				bIsUseIdentity = true;
-			}
-		}
-
-		typedef agg::conv_curve<agg::path_storage> conv_crv_type;
-
-		conv_crv_type c_c_path(path_copy);
-		c_c_path.approximation_scale(25.0);
-		c_c_path.approximation_method(agg::curve_inc);
-		DashStyle eStyle = (DashStyle)pPen->DashStyle;
-
-		if (DashStyleCustom == eStyle)
-		{
-			if (0 == pPen->Count || NULL == pPen->DashPattern)
-			{
-				eStyle = DashStyleSolid;
-			}
-			else
-			{
-				bool bFoundNormal = false;
-				for (int i = 0; i < pPen->Count; i++)
-				{
-					if (fabs(pPen->DashPattern[i]) > 0.0001)
-					{
-						bFoundNormal = true;
-						break;
-					}
-				}
-				if (!bFoundNormal)
-					eStyle = DashStyleSolid;
-			}
-		}
-
-		agg::trans_affine* pAffine = &m_oFullTransform.m_internal->m_agg_mtx;
-		if (bIsUseIdentity)
-			pAffine = new agg::trans_affine();
-
-		if (DashStyleSolid == eStyle)
-		{
-			typedef agg::conv_stroke<conv_crv_type> Path_Conv_StrokeN;
-			Path_Conv_StrokeN pgN(c_c_path);
-
-			//pgN.line_join(agg::miter_join_revert);
-
-			pgN.line_cap(LineCap);
-			
-			pgN.line_join(LineJoin);
-			pgN.inner_join(agg::inner_round);
-			
-			pgN.miter_limit(dblMiterLimit);
-			pgN.width(dWidth);
-
-			pgN.approximation_scale(25.0);
-
-			typedef agg::conv_transform<Path_Conv_StrokeN> transStroke;
-
-			transStroke trans(pgN, *pAffine);
-			m_rasterizer.get_rasterizer().add_path(trans);
-		}
-		else
-		{
-			typedef agg::conv_dash<conv_crv_type> Path_Conv_Dash;
-			Path_Conv_Dash poly2_dash(c_c_path);
-
-			typedef agg::conv_stroke<Path_Conv_Dash> Path_Conv_StrokeD;
-			Path_Conv_StrokeD pgD(poly2_dash);
-
-			switch (eStyle)
-			{
-			case DashStyleDash:
-				poly2_dash.add_dash(3.00*dWidth, dWidth);
-				break;
-			case DashStyleDot:
-				poly2_dash.add_dash(dWidth, dWidth);
-				break;
-			case DashStyleDashDot:
-				poly2_dash.add_dash(3.00*dWidth, dWidth);
-				poly2_dash.add_dash(dWidth, dWidth);
-				break;
-			case DashStyleDashDotDot:
-				poly2_dash.add_dash(3.00*dWidth, dWidth);
-				poly2_dash.add_dash(dWidth, dWidth);
-				poly2_dash.add_dash(dWidth, dWidth);
-				break;
-			default:
-			case DashStyleCustom:
-			{
-				double offset	= pPen->DashOffset;
-				double* params	= pPen->DashPattern;
-				LONG lCount		= pPen->Count;
-				LONG lCount2	= lCount / 2;
-
-				double dKoef = 1.0;
-
-				for (LONG i = 0; i < lCount2; ++i)
-				{
-					if (0 == i)
-					{
-						poly2_dash.add_dash((params[i * 2]) * dKoef, params[i * 2 + 1] * dKoef);
-					}
-					else
-					{
-						poly2_dash.add_dash(params[i * 2] * dKoef, params[i * 2 + 1] * dKoef);
-					}
-				}
-				if (1 == (lCount % 2))
-				{
-					poly2_dash.add_dash(params[lCount - 1] * dKoef, 0);
-				}
-				poly2_dash.dash_start(offset * dKoef);
-
-				break;
-			}
-			}
-
-			double dWidthMinSize = 1.0 / sqrt(abs(m_oCoordTransform.m_internal->m_agg_mtx.determinant()));
-			if ((0 == dWidth && !m_bIntegerGrid) || dWidth < dWidthMinSize)
-				dWidth = dWidthMinSize;
-
-			pgD.line_cap(LineCap);
-			pgD.line_join(LineJoin);
-			pgD.miter_limit(dblMiterLimit);
-			pgD.width(dWidth);
-
-			agg::conv_transform<Path_Conv_StrokeD> trans(pgD, *pAffine);
-			m_rasterizer.get_rasterizer().add_path(trans);
-		}
+		agg::trans_affine* pAffine = DoStrokePath(pPen, pPath, &m_rasterizer.get_rasterizer());
 
 		CColor oColor((BYTE)(pPen->Alpha * m_dGlobalAlpha), pPen->Color, m_bSwapRGB);
 		CBrushSolid oBrush(oColor);
@@ -798,8 +653,7 @@ namespace Aggplus
 		if (gamma >= 0)
 			m_rasterizer.gamma(1.0);
 
-		if (bIsUseIdentity)
-			RELEASEOBJECT(pAffine);
+		RELEASEOBJECT(pAffine);
 
 		return Ok;
 	}
@@ -2243,6 +2097,186 @@ namespace Aggplus
 			break;
 		}
 	}
+	template<class Rasterizer>
+	agg::trans_affine* CGraphics::DoStrokePath(NSStructures::CPen* pPen, CGraphicsPath* pPath, Rasterizer* pRasterizer)
+	{
+		agg::line_join_e LineJoin = agg::round_join;
+		switch(pPen->LineJoin)
+		{
+		case LineJoinMiter			: LineJoin = agg::miter_join_revert; break;
+		case LineJoinBevel			: LineJoin = agg::bevel_join; break;
+		case LineJoinRound			: LineJoin = agg::round_join; break;
+		case LineJoinMiterClipped	: LineJoin = agg::miter_join_revert; break;
+		default:	break;
+		}
+		agg::line_cap_e LineCap = agg::round_cap;
+		switch(pPen->LineStartCap)
+		{
+		case LineCapFlat         : LineCap = agg::butt_cap; break;
+		case LineCapRound        : LineCap = agg::round_cap; break;
+		case LineCapSquare       : LineCap = agg::square_cap; break;
+		default:	break;
+		}
+
+		double dWidth = pPen->Size;
+		if (!m_bIntegerGrid && m_bIs0PenWidthAs1px)
+		{
+			double dWidthMinSize, dSqrtDet = sqrt(abs(m_oFullTransform.m_internal->m_agg_mtx.determinant()));
+			if (0 == dWidth)
+			{
+				double dX = 0.72, dY = 0.72;
+				agg::trans_affine invert = ~m_oFullTransform.m_internal->m_agg_mtx;
+				invert.transform_2x2(&dX, &dY);
+				dWidth = std::min(abs(dX), abs(dY));
+			}
+			else if (0 != dSqrtDet && dWidth < (dWidthMinSize = 1.0 / dSqrtDet))
+				dWidth = dWidthMinSize;
+		}
+
+		double dblMiterLimit = pPen->MiterLimit;
+
+		agg::path_storage path_copy(pPath->m_internal->m_agg_ps);
+		bool bIsUseIdentity = m_bIntegerGrid;
+		if (!bIsUseIdentity)
+		{
+			agg::trans_affine* full_trans = &m_oFullTransform.m_internal->m_agg_mtx;
+			double dDet = full_trans->determinant();
+
+			if (fabs(dDet) < 0.0001)
+			{
+				path_copy.transform_all_paths(m_oFullTransform.m_internal->m_agg_mtx);
+				dWidth *= sqrt(fabs(dDet));
+
+				bIsUseIdentity = true;
+			}
+		}
+
+		typedef agg::conv_curve<agg::path_storage> conv_crv_type;
+
+		conv_crv_type c_c_path(path_copy);
+		c_c_path.approximation_scale(25.0);
+		c_c_path.approximation_method(agg::curve_inc);
+		DashStyle eStyle = (DashStyle)pPen->DashStyle;
+
+		if (DashStyleCustom == eStyle)
+		{
+			if (0 == pPen->Count || NULL == pPen->DashPattern)
+			{
+				eStyle = DashStyleSolid;
+			}
+			else
+			{
+				bool bFoundNormal = false;
+				for (int i = 0; i < pPen->Count; i++)
+				{
+					if (fabs(pPen->DashPattern[i]) > 0.0001)
+					{
+						bFoundNormal = true;
+						break;
+					}
+				}
+				if (!bFoundNormal)
+					eStyle = DashStyleSolid;
+			}
+		}
+
+		agg::trans_affine* pAffine = &m_oFullTransform.m_internal->m_agg_mtx;
+		if (bIsUseIdentity)
+			pAffine = new agg::trans_affine();
+
+		if (DashStyleSolid == eStyle)
+		{
+			typedef agg::conv_stroke<conv_crv_type> Path_Conv_StrokeN;
+			Path_Conv_StrokeN pgN(c_c_path);
+
+			//pgN.line_join(agg::miter_join_revert);
+
+			pgN.line_cap(LineCap);
+
+			pgN.line_join(LineJoin);
+			pgN.inner_join(agg::inner_round);
+
+			pgN.miter_limit(dblMiterLimit);
+			pgN.width(dWidth);
+
+			pgN.approximation_scale(25.0);
+
+			typedef agg::conv_transform<Path_Conv_StrokeN> transStroke;
+
+			transStroke trans(pgN, *pAffine);
+			pRasterizer->add_path(trans);
+		}
+		else
+		{
+			typedef agg::conv_dash<conv_crv_type> Path_Conv_Dash;
+			Path_Conv_Dash poly2_dash(c_c_path);
+
+			typedef agg::conv_stroke<Path_Conv_Dash> Path_Conv_StrokeD;
+			Path_Conv_StrokeD pgD(poly2_dash);
+
+			switch (eStyle)
+			{
+			case DashStyleDash:
+				poly2_dash.add_dash(3.00*dWidth, dWidth);
+				break;
+			case DashStyleDot:
+				poly2_dash.add_dash(dWidth, dWidth);
+				break;
+			case DashStyleDashDot:
+				poly2_dash.add_dash(3.00*dWidth, dWidth);
+				poly2_dash.add_dash(dWidth, dWidth);
+				break;
+			case DashStyleDashDotDot:
+				poly2_dash.add_dash(3.00*dWidth, dWidth);
+				poly2_dash.add_dash(dWidth, dWidth);
+				poly2_dash.add_dash(dWidth, dWidth);
+				break;
+			default:
+			case DashStyleCustom:
+			{
+				double offset	= pPen->DashOffset;
+				double* params	= pPen->DashPattern;
+				LONG lCount		= pPen->Count;
+				LONG lCount2	= lCount / 2;
+
+				double dKoef = 1.0;
+
+				for (LONG i = 0; i < lCount2; ++i)
+				{
+					if (0 == i)
+					{
+						poly2_dash.add_dash((params[i * 2]) * dKoef, params[i * 2 + 1] * dKoef);
+					}
+					else
+					{
+						poly2_dash.add_dash(params[i * 2] * dKoef, params[i * 2 + 1] * dKoef);
+					}
+				}
+				if (1 == (lCount % 2))
+				{
+					poly2_dash.add_dash(params[lCount - 1] * dKoef, 0);
+				}
+				poly2_dash.dash_start(offset * dKoef);
+
+				break;
+			}
+			}
+
+			double dWidthMinSize = 1.0 / sqrt(abs(m_oCoordTransform.m_internal->m_agg_mtx.determinant()));
+			if ((0 == dWidth && !m_bIntegerGrid) || dWidth < dWidthMinSize)
+				dWidth = dWidthMinSize;
+
+			pgD.line_cap(LineCap);
+			pgD.line_join(LineJoin);
+			pgD.miter_limit(dblMiterLimit);
+			pgD.width(dWidth);
+
+			agg::conv_transform<Path_Conv_StrokeD> trans(pgD, *pAffine);
+			pRasterizer->add_path(trans);
+		}
+
+		return bIsUseIdentity ? pAffine : NULL;
+	}
 	// text methods
 	int CGraphics::FillGlyph2(int nX, int nY, TGlyph* pGlyph, Aggplus::CBrush* pBrush)
 	{

DesktopEditor/graphics/Graphics.h

@@ -360,8 +360,8 @@ public:
 	Status SetClip(CGraphicsPath* pPath);
 	Status ResetClip();
 	Status ExclugeClip(CGraphicsPath* pPath);
-	Status CombineClip(CGraphicsPath* pPath, agg::sbool_op_e op);
-    Status InternalClip(CGraphicsPath* pPath, CMatrix* pTransform, agg::sbool_op_e op);
+	Status CombineClip(CGraphicsPath* pPath, agg::sbool_op_e op, NSStructures::CPen* pPen = NULL);
+    Status InternalClip(CGraphicsPath* pPath, CMatrix* pTransform, agg::sbool_op_e op, NSStructures::CPen* pPen = NULL);
 
 	// измерение текста
 	INT MeasureString(const std::wstring& strText, CFontManager* pManager, double* lWidth, double* lHeight);
@@ -453,6 +453,8 @@ protected:
     void DoFillPathTextureClampSz3(const CMatrix &mImgMtx, const void *pImgBuff, DWORD dwImgWidth, DWORD dwImgHeight, int nImgStride, Aggplus::WrapMode wrapmode, BYTE Alpha = 255);
     
 	void DoFillPath(const CBrush* Brush);
+	template<class Rasterizer>
+	agg::trans_affine* DoStrokePath(NSStructures::CPen* pPen, CGraphicsPath* pPath, Rasterizer* ras);
 
 	// text methods
 	int FillGlyph2(int nX, int nY, TGlyph* pGlyph, Aggplus::CBrush* pBrush);

DesktopEditor/graphics/GraphicsRenderer.cpp

@@ -822,7 +822,8 @@ HRESULT CGraphicsRenderer::EndCommand(const DWORD& lType)
 			m_pPath->SetRuler(bIsIn ? false : true);
 
 			INT bIsIntersect = (c_nClipRegionIntersect == (0x0100 & m_lCurrentClipMode));
-			m_pRenderer->CombineClip(m_pPath, bIsIntersect ? agg::sbool_and : agg::sbool_or);
+			INT bIsStrokePath = (c_nClipToStrokePath == (0x0010 & m_lCurrentClipMode));
+			m_pRenderer->CombineClip(m_pPath, bIsIntersect ? agg::sbool_and : agg::sbool_or, bIsStrokePath ? &m_oPen : NULL);
 
 			//m_pRenderer->SetClip(m_pPath);
 			break;

DesktopEditor/graphics/IRenderer.h

@@ -96,6 +96,9 @@ const long c_nBaselineShift		= 0xa041;
 // типы клипа
 const long c_nClipRegionTypeWinding		= 0x0000;
 const long c_nClipRegionTypeEvenOdd		= 0x0001;
+// тип преобразования пути для клипов
+const long c_nClipToPath				= 0x0000;
+const long c_nClipToStrokePath			= 0x0010;
 // тип объединения клипов
 const long c_nClipRegionIntersect		= 0x0000;
 const long c_nClipRegionUnion			= 0x0100;

DesktopEditor/graphics/Matrix.cpp

@@ -312,14 +312,14 @@ namespace Aggplus
         agg::trans_affine& m1 = mm1->m_internal->m_agg_mtx;
         agg::trans_affine& m2 = mm2->m_internal->m_agg_mtx;
 
-        bool bMain = (fabs(m1.sx  - m2.sx) < eps &&
-                      fabs(m1.sy  - m2.sy) < eps &&
-                      fabs(m1.shx - m2.shx) < eps &&
-                      fabs(m1.shy - m2.shy) < eps) ? true : false;
+        bool bMain = fabs(m1.sx  - m2.sx)  < eps &&
+                     fabs(m1.sy  - m2.sy)  < eps &&
+                     fabs(m1.shx - m2.shx) < eps &&
+                     fabs(m1.shy - m2.shy) < eps;
 
         if (!bMain || bIsOnlyMain)
             return bMain;
 
-        return (fabs(m1.tx - m2.tx) < eps && fabs(m1.ty - m2.ty) < eps) ? true : false;
+        return fabs(m1.tx - m2.tx) < eps && fabs(m1.ty - m2.ty) < eps;
     }
 }

DesktopEditor/graphics/MetafileToRenderer.cpp

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

DesktopEditor/graphics/MetafileToRenderer.h

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

DesktopEditor/graphics/boolean_operations_math.h

@@ -129,9 +129,7 @@ inline bool isCollinear(const Aggplus::PointD& p1, const Aggplus::PointD& p2)
 
 inline int getIterations(const double& a, const double& b)
 {
-	double n1 = 2.0, n2 = 16.0;
-
-	return std::max(n1, std::min(n2, ceil(fabs(b - a) * 32)));
+	return std::max(2, std::min(16, static_cast<int>(ceil(fabs(b - a) * 32))));
 }
 
 inline double CurveLength(const double& t, const double& ax, const double& bx, const double& cx,
@@ -143,64 +141,17 @@ inline double CurveLength(const double& t, const double& ax, const double& bx, c
 inline double integrate(const double& ax, const double& bx, const double& cx, const double& ay,
 						const double& by, const double& cy, const double& a, const double& b, size_t n = 16)
 {
-	std::vector<double> x = ABSCISSAS[n - 2],
-						w = WEIGHT[n - 2];
-
-	double A = (b - a) * 0.5,
-		   B = A + a;
-	double sum = n & 1 ? CurveLength(B, ax, bx, cx, ay, by, cy) : 0.0;
+	double A = (b - a) * 0.5;
+	double sum = n & 1 ? CurveLength(A + a, ax, bx, cx, ay, by, cy) : 0.0;
 
 	for (size_t i = 0; i < (n + 1) >> 1; i++)
-	{
-		double Ax = A * x[i];
-		sum += w[i] * (CurveLength(B + Ax, ax, bx, cx, ay, by, cy) +
-					   CurveLength(B - Ax, ax, bx, cx, ay, by, cy));
-	}
+		sum += WEIGHT[n - 2][i] * (CurveLength(A + a + A * ABSCISSAS[n - 2][i], ax, bx, cx, ay, by, cy) +
+								   CurveLength(A + a - A * ABSCISSAS[n - 2][i], ax, bx, cx, ay, by, cy));
 
 	return A * sum;
 }
 
-double fLength(const double& t, double& length, double& start, const double& offset,
-			   const double& ax, const double& bx, const double& cx, const double& ay,
-			   const double& by, const double& cy)
-{
-	length += integrate(ax, bx, cx, ay, by, cy, start, t, getIterations(start, t));
-	start = t;
-
-	return length - offset;
-}
-
-double findRoot(double& length, double& start, const double& offset, const double& ax,
-				const double& bx, const double& cx, const double& ay, const double& by,
-				const double& cy, double x, double a, double b)
-{
-	for (size_t i = 0; i < 32; i++)
-	{
-		double	fx = fLength(x, length, start, offset, ax, bx, cx, ay, by, cy),
-				dx = fx / CurveLength(x, ax, bx, cx, ay, by, cy),
-				nx = x - dx;
-		
-		if (fabs(dx) < EPSILON)
-		{
-			x = nx;
-			break;
-		}
-
-		if (fx > 0)
-		{
-			b = x;
-			x = nx <= a ? (a + b) * 0.5 : nx;
-		}
-		else{
-			a = x;
-			x = nx >= b ? (a + b) * 0.5 : nx;
-		}
-	}
-
-	return clamp(x, a, b);
-}
-
-bool intersect(std::vector<double> v, Aggplus::PointD& res)
+inline bool intersect(std::vector<double> v, Aggplus::PointD& res)
 {
 	v[2] -= v[0];
 	v[3] -= v[1];
@@ -229,7 +180,7 @@ bool intersect(std::vector<double> v, Aggplus::PointD& res)
 	return false;
 }
 
-void getConvexHull(const double& dq0, const double& dq1,
+inline void getConvexHull(const double& dq0, const double& dq1,
 				   const double& dq2, const double& dq3,
 				   std::vector<Aggplus::PointD>& top,
 				   std::vector<Aggplus::PointD>& bottom)
@@ -297,7 +248,7 @@ void getConvexHull(const double& dq0, const double& dq1,
 		std::swap(top, bottom);
 }
 
-double clipConvexHullPart(const std::vector<Aggplus::PointD>& part, const bool& top,
+inline double clipConvexHullPart(const std::vector<Aggplus::PointD>& part, const bool& top,
 								 const double& threshold)
 {
 	double	px = part[0].X,
@@ -348,7 +299,7 @@ inline int binarySearch(const std::vector<std::vector<double>>& allBounds,
 }
 
 inline double getSignedDistance(const double& px, const double& py, double vx, double vy,
-								const double& x, const double& y, bool asVector = false)
+								const double& x, const double& y, const bool& asVector)
 {
 	if (!asVector)
 	{
@@ -371,38 +322,6 @@ inline double getSignedDistance(const double& px, const double& py, double vx, d
 	return vx0 ? distX : vy0 ? distY : distXY;
 }
 
-inline double getDistance(const double& px, const double& py, const double& vx, const double& vy,
-						  const double& x, const double& y, const bool& asVector)
-{
-	return fabs(getSignedDistance(px, py, vx, vy, x, y, asVector));
-}
-
-inline double getDistance(const double& px, const double& py, const double& vx, const double& vy,
-						  const double& x, const double& y)
-{
-	if (vx == 0)
-	{
-		if (vy > 0)
-			return std::abs(x - px);
-		else
-			return std::abs(px - x);
-	}
-	if (vy == 0)
-	{
-		if (vx < 0)
-			return std::abs(y - py);
-		else
-			return std::abs(py -y);
-	}
-
-	bool dir = vy > vx;
-	double	dist = (x- px) * vy - (y - py) * vx,
-			epsY = vy * sqrt(1 + (vx * vx) / (vy * vy)),
-			epsX = vx * sqrt(1 + (vy * vy) / (vx * vx));
-
-	return  dist / (dir ? epsY : epsX);
-}
-
 inline double getDistance(const double& x1, const double& y1, const double& x2, const double& y2)
 {
 	return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
@@ -450,7 +369,7 @@ inline double getDiscriminant(const double& a, const double& b, const double& c)
 	return D;
 }
 
-int solveQuadratic(double a, double b, double c, std::vector<double>& roots,
+inline int solveQuadratic(double a, double b, double c, std::vector<double>& roots,
 				   const double& mn, const double& mx)
 {
 	double x1 = MAX, x2 = MAX;

DesktopEditor/graphics/commands/AnnotField.cpp

@@ -75,6 +75,7 @@ CAnnotFieldInfo::CAnnotFieldInfo() : IAdvancedCommand(AdvancedCommandType::Annot
 	m_pPopupPr        = NULL;
 	m_pFreeTextPr     = NULL;
 	m_pCaretPr        = NULL;
+	m_pStampPr        = NULL;
 	m_pWidgetPr       = NULL;
 }
 CAnnotFieldInfo::~CAnnotFieldInfo()
@@ -89,6 +90,7 @@ CAnnotFieldInfo::~CAnnotFieldInfo()
 	RELEASEOBJECT(m_pPopupPr);
 	RELEASEOBJECT(m_pFreeTextPr);
 	RELEASEOBJECT(m_pCaretPr);
+	RELEASEOBJECT(m_pStampPr);
 	RELEASEOBJECT(m_pWidgetPr);
 }
 
@@ -156,6 +158,15 @@ void CAnnotFieldInfo::SetType(int nType)
 		m_pTextMarkupPr = new CAnnotFieldInfo::CTextMarkupAnnotPr();
 		break;
 	}
+	case 12:
+	{
+		RELEASEOBJECT(m_pMarkupPr);
+		m_pMarkupPr = new CAnnotFieldInfo::CMarkupAnnotPr();
+
+		RELEASEOBJECT(m_pStampPr);
+		m_pStampPr = new CAnnotFieldInfo::CStampAnnotPr();
+		break;
+	}
 	case 13:
 	{
 		RELEASEOBJECT(m_pMarkupPr);
@@ -285,6 +296,10 @@ bool CAnnotFieldInfo::IsCaret() const
 {
 	return (m_nType == 13);
 }
+bool CAnnotFieldInfo::IsStamp() const
+{
+	return (m_nType == 12);
+}
 
 CAnnotFieldInfo::CMarkupAnnotPr*       CAnnotFieldInfo::GetMarkupAnnotPr()       { return m_pMarkupPr; }
 CAnnotFieldInfo::CTextAnnotPr*         CAnnotFieldInfo::GetTextAnnotPr()         { return m_pTextPr; }
@@ -296,6 +311,7 @@ CAnnotFieldInfo::CPolygonLineAnnotPr*  CAnnotFieldInfo::GetPolygonLineAnnotPr()
 CAnnotFieldInfo::CPopupAnnotPr*        CAnnotFieldInfo::GetPopupAnnotPr()        { return m_pPopupPr; }
 CAnnotFieldInfo::CFreeTextAnnotPr*     CAnnotFieldInfo::GetFreeTextAnnotPr()     { return m_pFreeTextPr; }
 CAnnotFieldInfo::CCaretAnnotPr*        CAnnotFieldInfo::GetCaretAnnotPr()        { return m_pCaretPr; }
+CAnnotFieldInfo::CStampAnnotPr*        CAnnotFieldInfo::GetStampAnnotPr()        { return m_pStampPr; }
 CAnnotFieldInfo::CWidgetAnnotPr*       CAnnotFieldInfo::GetWidgetAnnotPr()       { return m_pWidgetPr; }
 
 bool CAnnotFieldInfo::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMetafileToRenderter* pCorrector)
@@ -375,6 +391,8 @@ bool CAnnotFieldInfo::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMeta
 			m_pFreeTextPr->Read(pReader, nFlags);
 		else if (IsCaret())
 			m_pCaretPr->Read(pReader, nFlags);
+		else if (IsStamp())
+			m_pStampPr->Read(pReader, nFlags);
 	}
 	else if (IsPopup())
 		m_pPopupPr->Read(pReader);
@@ -627,6 +645,19 @@ void CAnnotFieldInfo::CCaretAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferReader*
 		m_nSy = pReader->ReadByte();
 }
 
+double CAnnotFieldInfo::CStampAnnotPr::GetRotate() { return m_nRotate; }
+const std::wstring& CAnnotFieldInfo::CStampAnnotPr::GetName() { return m_wsName; }
+void CAnnotFieldInfo::CStampAnnotPr::GetInRect(double& dRD1, double& dRD2, double& dRD3, double& dRD4) { dRD1 = m_dInRect[0]; dRD2 = m_dInRect[1]; dRD3 = m_dInRect[2]; dRD4 = m_dInRect[3]; }
+void CAnnotFieldInfo::CStampAnnotPr::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, int nFlags)
+{
+	m_wsName = pReader->ReadString();
+	m_nRotate = pReader->ReadDouble();
+	m_dInRect[0] = pReader->ReadDouble();
+	m_dInRect[1] = pReader->ReadDouble();
+	m_dInRect[2] = pReader->ReadDouble();
+	m_dInRect[3] = pReader->ReadDouble();
+}
+
 bool CAnnotFieldInfo::CPopupAnnotPr::IsOpen()      const { return m_bOpen; }
 int  CAnnotFieldInfo::CPopupAnnotPr::GetFlag()     const { return m_nFlag; }
 int  CAnnotFieldInfo::CPopupAnnotPr::GetParentID() const { return m_nParentID; }

DesktopEditor/graphics/commands/AnnotField.h

@@ -405,6 +405,21 @@ public:
 		double m_dRD[4]{};
 	};
 
+	class GRAPHICS_DECL CStampAnnotPr
+	{
+	public:
+		double GetRotate();
+		const std::wstring& GetName();
+		void GetInRect(double& dRD1, double& dRD2, double& dRD3, double& dRD4);
+
+		void Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, int nFlags);
+
+	private:
+		double m_nRotate;
+		std::wstring m_wsName;
+		double m_dInRect[4]{};
+	};
+
 	CAnnotFieldInfo();
 	virtual ~CAnnotFieldInfo();
 
@@ -439,6 +454,7 @@ public:
 	bool IsPopup()           const;
 	bool IsFreeText()        const;
 	bool IsCaret()           const;
+	bool IsStamp()           const;
 
 	CMarkupAnnotPr*       GetMarkupAnnotPr();
 	CTextAnnotPr*         GetTextAnnotPr();
@@ -450,6 +466,7 @@ public:
 	CPopupAnnotPr*        GetPopupAnnotPr();
 	CFreeTextAnnotPr*     GetFreeTextAnnotPr();
 	CCaretAnnotPr*        GetCaretAnnotPr();
+	CStampAnnotPr*        GetStampAnnotPr();
 	CWidgetAnnotPr*       GetWidgetAnnotPr();
 
 	bool Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMetafileToRenderter* pCorrector);
@@ -491,6 +508,7 @@ private:
 	CPopupAnnotPr*        m_pPopupPr;
 	CFreeTextAnnotPr*     m_pFreeTextPr;
 	CCaretAnnotPr*        m_pCaretPr;
+	CStampAnnotPr*        m_pStampPr;
 	CWidgetAnnotPr*       m_pWidgetPr;
 };
 

DesktopEditor/graphics/pro/Image.h

@@ -123,6 +123,7 @@ namespace MetaFile
 
 		virtual bool LoadFromFile(const wchar_t* wsFilePath) = 0;
 		virtual bool LoadFromBuffer(BYTE* pBuffer, unsigned int unSize) = 0;
+		virtual bool LoadFromString(const std::wstring& data) = 0;
 		virtual bool DrawOnRenderer(IRenderer* pRenderer, double dX, double dY, double dWidth, double dHeight) = 0;
 		virtual void Close() = 0;
 		virtual void GetBounds(double* pdX, double* pdY, double* pdW, double* pdH) = 0;
@@ -131,6 +132,7 @@ namespace MetaFile
 		virtual NSFonts::IFontManager* get_FontManager() = 0;
 
 		virtual std::wstring ConvertToSvg(unsigned int unWidth = 0, unsigned int unHeight = 0) = 0;
+		virtual void SetTempDirectory(const std::wstring& dir) = 0;
 
 		//Для тестов
 	#ifdef METAFILE_SUPPORT_WMF_EMF

DesktopEditor/graphics/pro/js/drawingfile.json

@@ -135,7 +135,7 @@
 	},
 	{
 		"folder": "./wasm/src/",
-		"files": ["lib/wasm_jmp.cpp", "drawingfile.cpp", "metafile.cpp", "pdfwriter.cpp"]
+		"files": ["lib/wasm_jmp.cpp", "drawingfile.cpp", "metafile.cpp", "pdfwriter.cpp", "HTMLRendererText.cpp"]
 	},
 	{
 		"folder": "freetype-2.10.4/src/",
@@ -201,10 +201,6 @@
 		"folder": "../",
 		"files": ["officedrawingfile.cpp"]
 	},
-	{
-		"folder": "../../../../HtmlRenderer/src/",
-		"files": ["HTMLRendererText.cpp"]
-	},
 	{
 		"folder": "../../../../UnicodeConverter/",
 		"files": ["UnicodeConverter.cpp"]
@@ -227,7 +223,7 @@
 	},
 	{
 		"folder": "../../../../DocxRenderer/src/logic/elements",
-		"files": ["BaseItem.cpp", "ContText.cpp", "DropCap.cpp", "Paragraph.cpp", "Shape.cpp", "TextLine.cpp"]
+		"files": ["BaseItem.cpp", "ContText.cpp", "Paragraph.cpp", "Shape.cpp", "TextLine.cpp", "Table.cpp"]
 	},
 	{
 		"folder": "../../../common",

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

@@ -19,7 +19,7 @@ include($$CORE_ROOT_DIR/Common/base.pri)
 include($$CORE_ROOT_DIR/Common/3dParty/icu/icu.pri)
 include(../../freetype.pri)
 
-ADD_DEPENDENCY(UnicodeConverter, kernel, HtmlRenderer)
+ADD_DEPENDENCY(UnicodeConverter, kernel)
 
 INCLUDEPATH += \
 	$$CORE_ROOT_DIR/DesktopEditor/agg-2.4/include \
@@ -704,7 +704,6 @@ HEADERS += \
 SOURCES += \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/BaseItem.cpp \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/ContText.cpp \
-	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/DropCap.cpp \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/Paragraph.cpp \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/Shape.cpp \
 	$$DOCX_RENDERER_ROOT_DIR/src/logic/elements/TextLine.cpp \
@@ -720,14 +719,15 @@ SOURCES += \
 	$$DOCX_RENDERER_ROOT_DIR/DocxRenderer.cpp \
 	$$DOCX_RENDERER_ROOT_DIR/src/resources/resources.cpp
 
-HEADERS += $$CORE_ROOT_DIR/HtmlRenderer/include/HTMLRendererText.h
-SOURCES += $$CORE_ROOT_DIR/HtmlRenderer/src/HTMLRendererText.cpp
+HEADERS += $$CORE_ROOT_DIR/DesktopEditor/doctrenderer/drawingfile.h
 
 HEADERS += \
-	../wasm/src/drawingfile.h \
-	../wasm/src/serialize.h
+	../wasm/src/serialize.h \
+	../wasm/src/HTMLRendererText.h \
+	../wasm/src/Text.h
 
 SOURCES += \
 	../wasm/src/pdfwriter.cpp \
+	../wasm/src/HTMLRendererText.cpp \
 	../wasm/src/drawingfile.cpp \
 	../wasm/src/drawingfile_test.cpp

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

@@ -1,5 +1,5 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * (c) Copyright Ascensio System SIA 2010-2024
  *
  * This program is a free software product. You can redistribute it and/or
  * modify it under the terms of the GNU Affero General Public License (AGPL)

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

@@ -1,5 +1,5 @@
 /*
- * (c) Copyright Ascensio System SIA 2010-2023
+ * (c) Copyright Ascensio System SIA 2010-2024
  *
  * This program is a free software product. You can redistribute it and/or
  * modify it under the terms of the GNU Affero General Public License (AGPL)

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

@@ -68,16 +68,6 @@ CFile.prototype.unlockPageNumForFontsLoader = function()
 	drawingFile.fontPageUpdateType = UpdateFontsSource.Undefined;
 };
 
-CFile.prototype.getOriginPage = function(originIndex)
-{
-	for (let i = 0; i < this.pages.length; ++i)
-	{
-		if (this.pages[i]["originIndex"] == originIndex)
-			return i;
-	}
-	return -1;
-};
-
 CFile.prototype["getPages"] = function()
 {
 	return this.pages;
@@ -241,18 +231,17 @@ CFile.prototype["getLinks"] = function(pageIndex)
 // TEXT
 CFile.prototype["getGlyphs"] = function(pageIndex)
 {
-	let i = this.getOriginPage(pageIndex);
-	if (i < 0)
-		return null;
-	let page = this.pages[i];
-	if (!page || page.fonts.length > 0)
+	let page = this.pages[pageIndex];
+	if (page.originIndex == undefined)
+		return [];
+	if (page.fonts.length > 0)
 	{
 		// waiting fonts
 		return null;
 	}
 
-	this.lockPageNumForFontsLoader(i, UpdateFontsSource.Page);
-	let res = this._getGlyphs(pageIndex);
+	this.lockPageNumForFontsLoader(pageIndex, UpdateFontsSource.Page);
+	let res = this._getGlyphs(page.originIndex);
 	// there is no need to delete the result; this buffer is used as a text buffer 
 	// for text commands on other pages. After receiving ALL text pages, 
 	// you need to call destroyTextInfo()
@@ -506,8 +495,8 @@ function readAnnotAP(reader, AP)
 {
 	// number for relations with AP
 	AP["i"] = reader.readInt();
-	AP["x"] = reader.readInt();
-	AP["y"] = reader.readInt();
+	AP["x"] = reader.readDouble();
+	AP["y"] = reader.readDouble();
 	AP["w"] = reader.readInt();
 	AP["h"] = reader.readInt();
 	let n = reader.readInt();
@@ -1136,7 +1125,7 @@ CFile.prototype["getAnnotationsInfo"] = function(pageIndex)
 		// FreeText
 		else if (rec["Type"] == 2)
 		{
-			// Bachground color - C->IC
+			// Background color - C->IC
 			if (rec["C"])
 			{
 				rec["IC"] = rec["C"];
@@ -1286,6 +1275,15 @@ CFile.prototype["getAnnotationsInfo"] = function(pageIndex)
 			if (flags & (1 << 26))
 				rec["Desc"] = reader.readString();
 		}
+		// Stamp
+		else if (rec["Type"] == 12)
+		{
+			rec["Icon"] = reader.readString();
+			rec["Rotate"] = reader.readDouble2();
+			rec["InRect"] = [];
+			for (let i = 0; i < 8; ++i)
+				rec["InRect"].push(reader.readDouble2());
+		}
 		res.push(rec);
 	}
 	
@@ -1382,18 +1380,17 @@ CFile.prototype["free"] = function(pointer)
 // PIXMAP
 CFile.prototype["getPagePixmap"] = function(pageIndex, width, height, backgroundColor)
 {
-	let i = this.getOriginPage(pageIndex);
-	if (i < 0)
+	let page = this.pages[pageIndex];
+	if (page.originIndex == undefined)
 		return null;
-	let page = this.pages[i];
-	if (!page || page.fonts.length > 0)
+	if (page.fonts.length > 0)
 	{
 		// waiting fonts
 		return null;
 	}
 
-	this.lockPageNumForFontsLoader(i, UpdateFontsSource.Page);
-	let ptr = this._getPixmap(pageIndex, width, height, backgroundColor);
+	this.lockPageNumForFontsLoader(pageIndex, UpdateFontsSource.Page);
+	let ptr = this._getPixmap(page.originIndex, width, height, backgroundColor);
 	this.unlockPageNumForFontsLoader();
 
 	if (page.fonts.length > 0)

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

@@ -29,8 +29,8 @@
  * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
  *
  */
-#include "../include/HTMLRendererText.h"
-#include "./Text.h"
+#include "HTMLRendererText.h"
+#include "Text.h"
 
 namespace NSHtmlRenderer
 {
@@ -40,52 +40,35 @@ namespace NSHtmlRenderer
 		double m_dWidth;
 		double m_dHeght;
 
-		NSStructures::CBrush m_oBrush;
-		NSStructures::CBrush m_oLastBrush;
-
 		NSStructures::CFont m_oFont;
-		NSStructures::CFont* m_pFont;
 		NSStructures::CFont	m_oInstalledFont;
-		LONG m_lCurrentFont;
-		double m_dCurrentFontSize;
 
 		Aggplus::CMatrix m_oTransform;
 		Aggplus::CMatrix m_oLastTransform;
 
-		bool m_bIsChangedFontParamBetweenDrawText;
-		LONG m_lCurrentCommandType;
-		LONG m_lSrcFileType;
-
 		CHText m_oSmartText;
-		CMetafile m_oPage;
+		NSWasm::CData m_oPage;
 
-		int* m_pTempUnicodes;
-		int  m_nTempUnicodesAlloc;
-		int  m_nTempUnicodesLen;
+		int* m_pTempUnicodes; // массив юникодов
+		int  m_nTempUnicodesAlloc; // размер выделенной памяти
+		int  m_nTempUnicodesLen; // размер используемой памяти
 
 		bool m_bIsFontsInit;
 
 	public:
 		CHTMLRendererText_Private()
 		{
-			m_bIsChangedFontParamBetweenDrawText = true;
-			m_lSrcFileType = 0;
 			m_pTempUnicodes = NULL;
 			m_nTempUnicodesLen = 0;
 			m_nTempUnicodesAlloc = 0;
 
 			m_bIsFontsInit = false;
-
-			m_lCurrentFont = 0;
-			m_dCurrentFontSize = 0;
-			m_pFont = &m_oFont;
 		}
 		~CHTMLRendererText_Private()
 		{
 			RELEASEARRAYOBJECTS(m_pTempUnicodes);
 		}
 
-	public:
 		void GetUnicodes(const std::wstring& sText)
 		{
 			int nLen = (int)sText.length();
@@ -101,7 +84,7 @@ namespace NSHtmlRenderer
 
 			if (sizeof(wchar_t) == 2)
 			{
-				for (int nIndex = 0, nGlyphIndex = 0; nIndex < nLen; ++nIndex, ++nGlyphIndex)
+				for (int nIndex = 0; nIndex < nLen; ++nIndex)
 				{
 					int code = (int)pWchars[nIndex];
 					if (code >= 0xD800 && code <= 0xDFFF && (nIndex + 1) < nLen)
@@ -109,32 +92,25 @@ namespace NSHtmlRenderer
 						++nIndex;
 						code = 0x10000 + (((code & 0x3FF) << 10) | (0x03FF & pWchars[nIndex]));
 					}
-
 					m_pTempUnicodes[m_nTempUnicodesLen++] = code;
 				}
 			}
 			else
 			{
-				for ( int nIndex = 0; nIndex < nLen; ++nIndex )
-				{
+				for (int nIndex = 0; nIndex < nLen; ++nIndex)
 					m_pTempUnicodes[m_nTempUnicodesLen++] = (int)pWchars[nIndex];
-				}
 			}
 		}
-
-		void WriteText(const int* pUnicodes, const int* pGids, const int& nCount, const double& x, const double& y,
-					   const double& width, const double& height, const bool& bIsChangedFontParamBetweenDrawText)
+		void WriteText(const int* pUnicodes, const int* pGids, const int& nCount, const double& x, const double& y)
 		{
 			bool bIsDumpFont = false;
 			if (!m_oInstalledFont.IsEqual(&m_oFont))
 			{
 				m_oInstalledFont = m_oFont;
 				bIsDumpFont = true;
-
-				m_dCurrentFontSize = m_oInstalledFont.Size;
 			}
 
-			m_oSmartText.CommandText(pUnicodes, pGids, nCount, x, y, width, height, bIsDumpFont, this);
+			m_oSmartText.CommandText(pUnicodes, pGids, nCount, x, y, bIsDumpFont);
 		}
 	};
 
@@ -149,9 +125,6 @@ namespace NSHtmlRenderer
 
 	void CHTMLRendererText::Init(IOfficeDrawingFile* pFile, int nCacheSize)
 	{
-		m_pInternal->m_oBrush.SetDefaultParams();
-		m_pInternal->m_oLastBrush.SetDefaultParams();
-
 		m_pInternal->m_oFont.SetDefaultParams();
 		m_pInternal->m_oInstalledFont.SetDefaultParams();
 		m_pInternal->m_oInstalledFont.Name = L"";
@@ -159,87 +132,38 @@ namespace NSHtmlRenderer
 		m_pInternal->m_oTransform.Reset();
 		m_pInternal->m_oLastTransform.Reset();
 
-		m_pInternal->m_oLastBrush.Color1 = -1;
-		m_pInternal->m_dCurrentFontSize	= 0.0;
-
-		m_pInternal->m_bIsChangedFontParamBetweenDrawText = false;
-		m_pInternal->m_lCurrentCommandType = -1;
-
-		m_pInternal->m_oSmartText.NewPage();
-
 		if (!m_pInternal->m_bIsFontsInit)
 		{
 			m_pInternal->m_oSmartText.m_oFontManager.m_pFont = &m_pInternal->m_oFont;
-
-			m_pInternal->m_oSmartText.m_pLastBrush = &m_pInternal->m_oLastBrush;
-			m_pInternal->m_oSmartText.m_pBrush = &m_pInternal->m_oBrush;
-
-			m_pInternal->m_oSmartText.m_pFont = &m_pInternal->m_oFont;
-
+			m_pInternal->m_oSmartText.m_oFontManager.Init(pFile->GetFonts(), nCacheSize);
 			m_pInternal->m_oSmartText.m_pTransform = &m_pInternal->m_oTransform;
 			m_pInternal->m_oSmartText.m_pLastTransform = &m_pInternal->m_oLastTransform;
-
 			m_pInternal->m_oSmartText.m_pPageMeta = &m_pInternal->m_oPage;
-
-			OfficeDrawingFileType eType = pFile->GetType();
-			switch (eType)
-			{
-			case odftPDF:
-			{
-				m_pInternal->m_lSrcFileType = AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF;
-				m_pInternal->m_oSmartText.m_dTextSpaceEps = 0.1;
-				break;
-			}
-			case odftDJVU:
-			{
-				m_pInternal->m_lSrcFileType = AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_DJVU;
-				m_pInternal->m_oSmartText.m_dTextSpaceEps = 0.1;
-				break;
-			}
-			case odftXPS:
-			{
-				m_pInternal->m_lSrcFileType = AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS;
-				m_pInternal->m_oSmartText.m_dTextSpaceEps = 0.1;
-				break;
-			}
-			default:
-				break;
-			}
-
 			m_pInternal->m_bIsFontsInit = true;
-			m_pInternal->m_oSmartText.Init(pFile->GetFonts(), nCacheSize);
 		}
 
 		m_pInternal->m_oPage.ClearNoAttack();
-		m_pInternal->m_oPage.WriteLONG(0);
-
+		m_pInternal->m_oPage.SkipLen();
 		// статистика
-		m_pInternal->m_oPage.WriteLONG(0);
-		m_pInternal->m_oPage.WriteLONG(0);
-		m_pInternal->m_oPage.WriteLONG(0);
-		m_pInternal->m_oPage.WriteLONG(0);
-
+		m_pInternal->m_oPage.AddInt(0);
+		m_pInternal->m_oPage.AddInt(0);
+		m_pInternal->m_oPage.AddInt(0);
+		m_pInternal->m_oPage.AddInt(0);
 	}
-
 	BYTE* CHTMLRendererText::GetBuffer()
 	{
 		m_pInternal->m_oSmartText.ClosePage();
-		LONG lPos = m_pInternal->m_oPage.GetPosition();
-		m_pInternal->m_oPage.Seek(0);
-		// len
-		m_pInternal->m_oPage.WriteLONG(lPos);
-		// stat
-		m_pInternal->m_oPage.WriteLONG(m_pInternal->m_oSmartText.m_lCountParagraphs);
-		m_pInternal->m_oPage.WriteLONG(m_pInternal->m_oSmartText.m_lCountWords);
-		m_pInternal->m_oPage.WriteLONG(m_pInternal->m_oSmartText.m_lCountSymbols);
-		m_pInternal->m_oPage.WriteLONG(m_pInternal->m_oSmartText.m_lCountSpaces);
-		// seek to end
-		m_pInternal->m_oPage.Seek(lPos);
+
+		m_pInternal->m_oPage.WriteLen();
+		// статистика
+		m_pInternal->m_oPage.AddInt(m_pInternal->m_oSmartText.m_nCountParagraphs, 4);
+		m_pInternal->m_oPage.AddInt(m_pInternal->m_oSmartText.m_nCountWords, 8);
+		m_pInternal->m_oPage.AddInt(m_pInternal->m_oSmartText.m_nCountSymbols, 12);
+		m_pInternal->m_oPage.AddInt(m_pInternal->m_oSmartText.m_nCountSpaces, 16);
 
 		m_pInternal->m_oSmartText.ClearStatistics();
-		return m_pInternal->m_oPage.GetData();
+		return m_pInternal->m_oPage.GetBuffer();
 	}
-
 	HRESULT CHTMLRendererText::get_Type(LONG* lType)
 	{
 		*lType = c_nHtmlRendrererText;
@@ -247,10 +171,7 @@ namespace NSHtmlRenderer
 	}
 
 	//-------- Функции для работы со страницей --------------------------------------------------
-	HRESULT CHTMLRendererText::NewPage()
-	{
-		return S_OK;
-	}
+	HRESULT CHTMLRendererText::NewPage() { return S_OK; }
 	HRESULT CHTMLRendererText::get_Height(double* dHeight)
 	{
 		*dHeight = m_pInternal->m_dHeght;
@@ -311,36 +232,12 @@ namespace NSHtmlRenderer
 	HRESULT CHTMLRendererText::put_BrushTransform(const Aggplus::CMatrix& oMatrix) { return S_OK; }
 
 	// brush ------------------------------------------------------------------------------------
-	HRESULT CHTMLRendererText::get_BrushType(LONG* lType)
-	{
-		*lType = m_pInternal->m_oBrush.Type;
-		return S_OK;
-	}
-	HRESULT CHTMLRendererText::put_BrushType(const LONG& lType)
-	{
-		m_pInternal->m_oBrush.Type = lType;
-		return S_OK;
-	}
-	HRESULT CHTMLRendererText::get_BrushColor1(LONG* lColor)
-	{
-		*lColor = m_pInternal->m_oBrush.Color1;
-		return S_OK;
-	}
-	HRESULT CHTMLRendererText::put_BrushColor1(const LONG& lColor)
-	{
-		m_pInternal->m_oBrush.Color1 = lColor;
-		return S_OK;
-	}
-	HRESULT CHTMLRendererText::get_BrushAlpha1(LONG* lAlpha)
-	{
-		*lAlpha = m_pInternal->m_oBrush.Alpha1;
-		return S_OK;
-	}
-	HRESULT CHTMLRendererText::put_BrushAlpha1(const LONG& lAlpha)
-	{
-		m_pInternal->m_oBrush.Alpha1 = lAlpha;
-		return S_OK;
-	}
+	HRESULT CHTMLRendererText::get_BrushType(LONG* lType) { return S_OK; }
+	HRESULT CHTMLRendererText::put_BrushType(const LONG& lType) { return S_OK; }
+	HRESULT CHTMLRendererText::get_BrushColor1(LONG* lColor) { return S_OK; }
+	HRESULT CHTMLRendererText::put_BrushColor1(const LONG& lColor) { return S_OK; }
+	HRESULT CHTMLRendererText::get_BrushAlpha1(LONG* lAlpha) { return S_OK; }
+	HRESULT CHTMLRendererText::put_BrushAlpha1(const LONG& lAlpha) { return S_OK; }
 	HRESULT CHTMLRendererText::get_BrushColor2(LONG* lColor) { return S_OK; }
 	HRESULT CHTMLRendererText::put_BrushColor2(const LONG& lColor) { return S_OK; }
 	HRESULT CHTMLRendererText::get_BrushAlpha2(LONG* lAlpha) { return S_OK; }
@@ -366,7 +263,6 @@ namespace NSHtmlRenderer
 	HRESULT CHTMLRendererText::put_FontName(const std::wstring& bsName)
 	{
 		m_pInternal->m_oFont.Name = bsName;
-		m_pInternal->m_bIsChangedFontParamBetweenDrawText = true;
 		return S_OK;
 	}
 	HRESULT CHTMLRendererText::get_FontPath(std::wstring* bsName)
@@ -377,7 +273,6 @@ namespace NSHtmlRenderer
 	HRESULT CHTMLRendererText::put_FontPath(const std::wstring& bsName)
 	{
 		m_pInternal->m_oFont.Path = bsName;
-		m_pInternal->m_bIsChangedFontParamBetweenDrawText = true;
 		return S_OK;
 	}
 	HRESULT CHTMLRendererText::get_FontSize(double* dSize)
@@ -387,11 +282,7 @@ namespace NSHtmlRenderer
 	}
 	HRESULT CHTMLRendererText::put_FontSize(const double& dSize)
 	{
-		if (m_pInternal->m_oFont.Size != dSize)
-		{
-			m_pInternal->m_oFont.Size = dSize;
-			m_pInternal->m_bIsChangedFontParamBetweenDrawText = true;
-		}
+		m_pInternal->m_oFont.Size = dSize;
 		return S_OK;
 	}
 	HRESULT CHTMLRendererText::get_FontStyle(LONG* lStyle)
@@ -401,12 +292,7 @@ namespace NSHtmlRenderer
 	}
 	HRESULT CHTMLRendererText::put_FontStyle(const LONG& lStyle)
 	{
-		LONG lOld = m_pInternal->m_oFont.GetStyle();
-		if (lOld != lStyle)
-		{
-			m_pInternal->m_oFont.SetStyle(lStyle);
-			m_pInternal->m_bIsChangedFontParamBetweenDrawText = true;
-		}
+		m_pInternal->m_oFont.SetStyle(lStyle);
 		return S_OK;
 	}
 	HRESULT CHTMLRendererText::get_FontStringGID(INT* bGID)
@@ -443,58 +329,34 @@ namespace NSHtmlRenderer
 	//-------- Функции для вывода текста --------------------------------------------------------
 	HRESULT CHTMLRendererText::CommandDrawTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h)
 	{
-		if (c_nHyperlinkType == m_pInternal->m_lCurrentCommandType)
-			return S_OK;
-
 		int _c = (int)c;
-		m_pInternal->WriteText(&_c, NULL, 1, x, y, w, h, m_pInternal->m_bIsChangedFontParamBetweenDrawText);
-		m_pInternal->m_bIsChangedFontParamBetweenDrawText = false;
+		m_pInternal->WriteText(&_c, NULL, 1, x, y);
 		return S_OK;
 	}
 	HRESULT CHTMLRendererText::CommandDrawText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h)
 	{
-		if (c_nHyperlinkType == m_pInternal->m_lCurrentCommandType)
-			return S_OK;
-
 		m_pInternal->GetUnicodes(bsText);
-		m_pInternal->WriteText(m_pInternal->m_pTempUnicodes, NULL, m_pInternal->m_nTempUnicodesLen, x, y, w, h, m_pInternal->m_bIsChangedFontParamBetweenDrawText);
-		m_pInternal->m_bIsChangedFontParamBetweenDrawText = false;
+		m_pInternal->WriteText(m_pInternal->m_pTempUnicodes, NULL, m_pInternal->m_nTempUnicodesLen, x, y);
 		return S_OK;
 	}
 	HRESULT CHTMLRendererText::CommandDrawTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h)
 	{
-		if (c_nHyperlinkType == m_pInternal->m_lCurrentCommandType)
-			return S_OK;
-
 		int _c = (int)c;
 		int _g = (int)gid;
 
-		m_pInternal->WriteText(&_c, &_g, 1, x, y, w, h, m_pInternal->m_bIsChangedFontParamBetweenDrawText);
-		m_pInternal->m_bIsChangedFontParamBetweenDrawText = false;
+		m_pInternal->WriteText(&_c, &_g, 1, x, y);
 		return S_OK;
 	}
 	HRESULT CHTMLRendererText::CommandDrawTextEx(const std::wstring& bsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& x, const double& y, const double& w, const double& h)
 	{
-		if (c_nHyperlinkType == m_pInternal->m_lCurrentCommandType)
-			return S_OK;
-
 		m_pInternal->GetUnicodes(bsUnicodeText);
-		m_pInternal->WriteText(m_pInternal->m_pTempUnicodes, (const int*)pGids, m_pInternal->m_nTempUnicodesLen, x, y, w, h, m_pInternal->m_bIsChangedFontParamBetweenDrawText);
-		m_pInternal->m_bIsChangedFontParamBetweenDrawText = false;
+		m_pInternal->WriteText(m_pInternal->m_pTempUnicodes, (const int*)pGids, m_pInternal->m_nTempUnicodesLen, x, y);
 		return S_OK;
 	}
 
 	//-------- Маркеры для команд ---------------------------------------------------------------
-	HRESULT CHTMLRendererText::BeginCommand(const DWORD& lType)
-	{
-		m_pInternal->m_lCurrentCommandType = lType;
-		return S_OK;
-	}
-	HRESULT CHTMLRendererText::EndCommand(const DWORD& lType)
-	{
-		m_pInternal->m_lCurrentCommandType = -1;
-		return S_OK;
-	}
+	HRESULT CHTMLRendererText::BeginCommand(const DWORD& lType) { return S_OK; }
+	HRESULT CHTMLRendererText::EndCommand(const DWORD& lType) { return S_OK; }
 
 	//-------- Функции для работы с Graphics Path -----------------------------------------------
 	HRESULT CHTMLRendererText::PathCommandMoveTo(const double& x, const double& y) { return S_OK; }

DesktopEditor/graphics/pro/js/wasm/src/HTMLRendererText.h

@@ -32,8 +32,8 @@
 #ifndef _ASC_HTMLRENDERER3_TEXT_H_
 #define _ASC_HTMLRENDERER3_TEXT_H_
 
-#include "../../DesktopEditor/graphics/IRenderer.h"
-#include "../../DesktopEditor/graphics/pro/officedrawingfile.h"
+#include "../../../../IRenderer.h"
+#include "../../../officedrawingfile.h"
 
 #ifndef HTMLRENDERER_USE_DYNAMIC_LIBRARY
 #define HTMLRENDERER_DECL_EXPORT

DesktopEditor/graphics/pro/js/wasm/src/Text.h

@@ -0,0 +1,409 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2023
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
+ * street, Riga, Latvia, EU, LV-1050.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+#ifndef _ASC_HTMLRENDERER_TEXT_H_
+#define _ASC_HTMLRENDERER_TEXT_H_
+
+#include <algorithm>
+
+#include "serialize.h"
+#include "../../../../structures.h"
+#include "../../../Fonts.h"
+
+namespace NSHtmlRenderer
+{
+	struct CHFontInfo
+	{
+		int m_lAscent;
+		int m_lDescent;
+		int m_lUnitsPerEm;
+
+		CHFontInfo() : m_lAscent(0), m_lDescent(0), m_lUnitsPerEm(0) {}
+		CHFontInfo(const CHFontInfo& oSrc) : m_lAscent(oSrc.m_lAscent), m_lDescent(oSrc.m_lDescent), m_lUnitsPerEm(oSrc.m_lUnitsPerEm) {}
+		CHFontInfo& operator=(const CHFontInfo& oSrc)
+		{
+			m_lAscent = oSrc.m_lAscent;
+			m_lDescent = oSrc.m_lDescent;
+			m_lUnitsPerEm = oSrc.m_lUnitsPerEm;
+			return *this;
+		}
+	};
+
+	class CFontManagerWrapper
+	{
+	private:
+		NSFonts::IFontManager* m_pManager;
+	public:
+		NSStructures::CFont* m_pFont;
+		CHFontInfo m_oCurrentInfo;
+
+	public:
+		CFontManagerWrapper() : m_pManager(NULL) {}
+		virtual ~CFontManagerWrapper()
+		{
+			RELEASEOBJECT(m_pManager);
+		}
+
+		void Init(NSFonts::IApplicationFonts* pApplicationFonts, int nCacheSize = 0)
+		{
+			RELEASEOBJECT(m_pManager);
+			m_pManager = pApplicationFonts->GenerateFontManager();
+			if (nCacheSize)
+			{
+				NSFonts::IFontsCache* pFontCache = NSFonts::NSFontCache::Create();
+				pFontCache->SetStreams(pApplicationFonts->GetStreams());
+				pFontCache->SetCacheSize(nCacheSize);
+				m_pManager->SetOwnerCache(pFontCache);
+			}
+		}
+		void SetStringGID(INT bGid)
+		{
+			m_pManager->SetStringGID(bGid);
+		}
+		void LoadCurrentFont()
+		{
+			if (m_pFont->Path.empty())
+				LoadFontByName(m_pFont->Name, m_pFont->Size, m_pFont->GetStyle());
+			else
+				LoadFontByFile(m_pFont->Path, m_pFont->Size);
+		}
+		double MeasureString(const unsigned int* symbols, const int& count, double x, double y)
+		{
+			if (!m_pManager)
+				return 0;
+
+			m_pManager->LoadString1(symbols, count, (float)x, (float)y);
+			TBBox _box = m_pManager->MeasureString2();
+
+			return abs((_box.fMaxX - _box.fMinX) * 25.4 / 72.0);
+		}
+
+	private:
+		inline void LoadFontByName(const std::wstring& strName, const double& dSize, const LONG& lStyle)
+		{
+			m_pManager->LoadFontByName(strName, dSize, lStyle, 72.0, 72.0);
+			LoadFontMetrics();
+		}
+		inline void LoadFontByFile(const std::wstring& strPath, const double& dSize)
+		{
+			m_pManager->LoadFontFromFile(strPath, 0, dSize, 72.0, 72.0);
+			LoadFontMetrics();
+		}
+		void LoadFontMetrics()
+		{
+			m_pManager->AfterLoad();
+			m_oCurrentInfo.m_lAscent     = abs(m_pManager->GetAscender());
+			m_oCurrentInfo.m_lDescent    = abs(m_pManager->GetDescender());
+			m_oCurrentInfo.m_lUnitsPerEm = abs(m_pManager->GetUnitsPerEm());
+		}
+	};
+
+	struct CHText
+	{
+		CFontManagerWrapper m_oFontManager;
+		Aggplus::CMatrix* m_pTransform;
+		Aggplus::CMatrix* m_pLastTransform;
+
+		NSWasm::CHLine m_oLine;
+		NSWasm::CData* m_pPageMeta;
+
+		LONG m_nCountParagraphs;
+		LONG m_nCountWords;
+		LONG m_nCountSymbols;
+		LONG m_nCountSpaces;
+
+		CHText() : m_oFontManager(), m_oLine()
+		{
+			m_nCountParagraphs = 0;
+			m_nCountWords = 0;
+			m_nCountSymbols = 0;
+			m_nCountSpaces = 0;
+		}
+
+		void ClearStatistics()
+		{
+			m_nCountParagraphs = 0;
+			m_nCountWords = 0;
+			m_nCountSymbols = 0;
+			m_nCountSpaces = 0;
+		}
+		void ClosePage()
+		{
+			if (m_oLine.GetCountChars())
+				DumpLine();
+		}
+		void CommandText(const int* pUnicodes, const int* pGids, const int& nCount, const double& x, const double& y, bool bIsDumpFont)
+		{
+			// 1) сначала определяем точку отсчета и направление baseline
+			double _x1 = x;
+			double _y1 = y;
+			double _x2 = x + 1;
+			double _y2 = y;
+			m_pTransform->TransformPoint(_x1, _y1);
+			m_pTransform->TransformPoint(_x2, _y2);
+
+			double _k = 0;
+			double _b = 0;
+			bool _isConstX = false;
+			if (fabs(_x1 - _x2) < 0.001)
+			{
+				_isConstX = true;
+				_b = _x1;
+			}
+			else
+			{
+				_k = (_y1 - _y2) / (_x1 - _x2);
+				_b = _y1 - _k * _x1;
+			}
+
+			double dAbsVec = sqrt((_x1 - _x2) * (_x1 - _x2) + (_y1 - _y2) * (_y1 - _y2));
+			if (dAbsVec == 0)
+				dAbsVec = 1;
+
+			bool bIsNewLine = true;
+			if (m_oLine.GetCountChars())
+			{
+				if (_isConstX && m_oLine.m_bIsConstX && fabs(_b - m_oLine.m_dB) < 0.001)
+					bIsNewLine = false;
+				else if (!_isConstX && !m_oLine.m_bIsConstX && fabs(_k - m_oLine.m_dK) < 0.001 && fabs(_b - m_oLine.m_dB) < 0.001)
+					bIsNewLine = false;
+
+				if (bIsNewLine) // не совпала baseline. поэтому просто скидываем линию в поток
+					DumpLine();
+			}
+
+			// теперь нужно определить сдвиг по baseline относительно destination точки
+			double dOffsetX = 0;
+			LONG nCountChars = m_oLine.GetCountChars();
+			if (0 == nCountChars)
+			{
+				m_oLine.m_bIsConstX = _isConstX;
+				m_oLine.m_dK = _k;
+				m_oLine.m_dB = _b;
+
+				m_oLine.m_dX = _x1;
+				m_oLine.m_dY = _y1;
+
+				m_oLine.m_ex = (_x2 - _x1) / dAbsVec;
+				m_oLine.m_ey = (_y2 - _y1) / dAbsVec;
+
+				m_oLine.m_dEndX = _x1;
+				m_oLine.m_dEndY = _y1;
+			}
+			else
+			{
+				double sx = _x1 - m_oLine.m_dEndX;
+				double sy = _y1 - m_oLine.m_dEndY;
+				double len = sqrt(sx*sx + sy*sy);
+
+				if (sx * m_oLine.m_ex >= 0 && sy * m_oLine.m_ey >= 0)
+				{
+					// продолжаем линию
+					dOffsetX = len;
+
+					// теперь посмотрим, может быть нужно вставить пробел??
+					NSWasm::CHChar* pLastChar = m_oLine.GetTail();
+					if (dOffsetX > (pLastChar->width + 0.5))
+					{
+						// вставляем пробел. Пробел у нас будет не совсем пробел. А специфический
+						NSWasm::CHChar* pSpaceChar = m_oLine.AddTail();
+						pLastChar = &m_oLine.m_pChars[m_oLine.m_lCharsTail - 2];
+						pSpaceChar->x = pLastChar->width;
+						pSpaceChar->width = dOffsetX - pLastChar->width;
+						pSpaceChar->unicode = 0xFFFF;
+						dOffsetX -= pLastChar->width;
+					}
+				}
+				else
+				{
+					// буква сдвинута влево относительно предыдущей буквы
+					// на такую ситуацию реагируем просто - просто начинаем новую линию,
+					// предварительно сбросив старую
+					DumpLine();
+
+					m_oLine.m_bIsConstX = _isConstX;
+
+					m_oLine.m_dX = _x1;
+					m_oLine.m_dY = _y1;
+
+					m_oLine.m_dK = _k;
+					m_oLine.m_dB = _b;
+
+					m_oLine.m_ex = (_x2 - _x1) / dAbsVec;
+					m_oLine.m_ey = (_y2 - _y1) / dAbsVec;
+				}
+
+				m_oLine.m_dEndX = _x1;
+				m_oLine.m_dEndY = _y1;
+			}
+
+			if (!Aggplus::CMatrix::IsEqual(m_pLastTransform, m_pTransform, 0.001, true))
+			{ // смотрим, совпадает ли главная часть матрицы
+				bIsDumpFont = true;
+				*m_pLastTransform = *m_pTransform;
+				m_oLine.m_bIsSetUpTransform = true;
+				m_oLine.m_sx  = m_pTransform->sx();
+				m_oLine.m_shx = m_pTransform->shx();
+				m_oLine.m_shy = m_pTransform->shy();
+				m_oLine.m_sy  = m_pTransform->sy();
+			}
+
+			// все, baseline установлен. теперь просто продолжаем линию
+			if (bIsDumpFont)
+				m_oFontManager.LoadCurrentFont();
+
+			double dKoef = m_oFontManager.m_pFont->Size * 25.4 / (72 * m_oFontManager.m_oCurrentInfo.m_lUnitsPerEm);
+			double dAscender  = m_oFontManager.m_oCurrentInfo.m_lAscent  * dKoef * dAbsVec;
+			double dDescender = m_oFontManager.m_oCurrentInfo.m_lDescent * dKoef * dAbsVec;
+
+			if (m_oLine.m_dAscent < dAscender)
+				m_oLine.m_dAscent = dAscender;
+			if (m_oLine.m_dDescent < dDescender)
+				m_oLine.m_dDescent = dDescender;
+
+			const int* input = NULL;
+			if (NULL != pGids)
+			{
+				input = pGids;
+				m_oFontManager.SetStringGID(TRUE);
+			}
+			else
+			{
+				input = pUnicodes;
+				m_oFontManager.SetStringGID(FALSE);
+			}
+
+			double dPlusOffset = 0;
+			double dPrevW = dOffsetX;
+			for (int i = 0; i < nCount; ++i)
+			{
+				double dW = m_oFontManager.MeasureString((const unsigned int*)(input + i), 1, 0, 0);
+
+				NSWasm::CHChar* pChar = m_oLine.AddTail();
+				pChar->unicode = pUnicodes[i];
+
+				pChar->x = dPrevW;
+				if (i)
+					dPlusOffset += dPrevW;
+				dPrevW = dW;
+				pChar->width = dW * dAbsVec;
+
+				if (i == nCount - 1)
+				{
+					m_oLine.m_dEndX += dPlusOffset * m_oLine.m_ex;
+					m_oLine.m_dEndY += dPlusOffset * m_oLine.m_ey;
+				}
+			}
+		}
+		void DumpLine()
+		{
+			LONG nCount = m_oLine.GetCountChars();
+			if (!nCount)
+			{
+				m_oLine.Clear();
+				return;
+			}
+
+			if (m_oLine.m_bIsSetUpTransform)
+			{
+				// выставится трансформ!!!
+				// cравнивать нужно с ним!!!
+				m_pLastTransform->SetElements(m_oLine.m_sx, m_oLine.m_shy, m_oLine.m_shx, m_oLine.m_sy);
+			}
+
+			// скидываем линию в поток pMeta
+			m_pPageMeta->WriteDouble(m_oLine.m_dX);
+			m_pPageMeta->WriteDouble(m_oLine.m_dY);
+
+			bool bHorizontal = false;
+			if (fabs(m_oLine.m_ex - 1.0) < 0.001 && fabs(m_oLine.m_ey) < 0.001)
+				bHorizontal = true;
+			m_pPageMeta->WriteBYTE(!bHorizontal ? 1 : 0);
+			if (!bHorizontal)
+			{
+				m_pPageMeta->WriteDouble(m_oLine.m_ex);
+				m_pPageMeta->WriteDouble(m_oLine.m_ey);
+			}
+
+			m_pPageMeta->WriteDouble(m_oLine.m_dAscent);
+			m_pPageMeta->WriteDouble(m_oLine.m_dDescent);
+
+			m_nCountParagraphs++;
+
+			// width
+			LONG _position = m_pPageMeta->GetSize();
+			m_pPageMeta->AddInt(0);
+
+			double dWidthLine = 0;
+			double dCurrentGlyphLineOffset = 0;
+			m_pPageMeta->AddInt(nCount);
+			NSWasm::CHChar* pChar = NULL;
+			bool bIsLastSymbol = false;
+			for (LONG lIndexChar = 0; lIndexChar < nCount; ++lIndexChar)
+			{
+				pChar = &m_oLine.m_pChars[lIndexChar];
+
+				if (lIndexChar)
+				{
+					m_pPageMeta->WriteDouble(pChar->x);
+					dCurrentGlyphLineOffset += pChar->x;
+				}
+
+				if (pChar->unicode == 0xFFFF || pChar->unicode == 32 || pChar->unicode == 9)
+				{
+					m_nCountSpaces++;
+					if (bIsLastSymbol)
+					{
+						bIsLastSymbol = false;
+						m_nCountWords++;
+					}
+				}
+				else
+				{
+					m_nCountSymbols++;
+					bIsLastSymbol = true;
+				}
+
+				m_pPageMeta->AddInt(pChar->unicode); // юникодное значение
+				m_pPageMeta->WriteDouble(pChar->width); // ширина буквы
+			}
+			if (bIsLastSymbol)
+				m_nCountWords++;
+
+			if (pChar)
+				dWidthLine = dCurrentGlyphLineOffset + pChar->width;
+			m_pPageMeta->AddInt((int)(dWidthLine * 10000.0), _position);
+			m_oLine.Clear();
+		}
+	};
+}
+
+#endif // _ASC_HTMLRENDERER_TEXT_H_

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

@@ -10,6 +10,10 @@ unsigned char READ_BYTE(BYTE* x)
 {
 	return x ? x[0] : 1;
 }
+unsigned short READ_SHORT(BYTE* x)
+{
+	return x ? (x[0] | x[1] << 8) : 2;
+}
 unsigned int READ_INT(BYTE* x)
 {
 	return x ? (x[0] | x[1] << 8 | x[2] << 16 | x[3] << 24) : 4;
@@ -750,11 +754,11 @@ void ReadAnnotAP(BYTE* pWidgetsAP, int& i)
 
 	int nPathLength = READ_INT(pWidgetsAP + i);
 	i += 4;
-	std::cout << "X " << nPathLength << ", ";
+	std::cout << "X " << (double)nPathLength / 100.0 << ", ";
 
 	nPathLength = READ_INT(pWidgetsAP + i);
 	i += 4;
-	std::cout << "Y " << nPathLength << ", ";
+	std::cout << "Y " << (double)nPathLength / 100.0 << ", ";
 
 	int nWidgetWidth = READ_INT(pWidgetsAP + i);
 	i += 4;
@@ -990,7 +994,7 @@ int main(int argc, char* argv[])
 	}
 
 	int i = nTestPage;
-	for (int i = 0; i < nPagesCount; ++i)
+	//for (int i = 0; i < nPagesCount; ++i)
 	{
 		// RASTER
 		if (true)
@@ -998,6 +1002,9 @@ int main(int argc, char* argv[])
 			nWidth  = READ_INT(pInfo + i * 16 + 12);
 			nHeight = READ_INT(pInfo + i * 16 + 16);
 
+			//nWidth  *= 3;
+			//nHeight *= 3;
+
 			BYTE* res = NULL;
 			res = GetPixmap(pGrFile, i, nWidth, nHeight, 0xFFFFFF);
 
@@ -1083,15 +1090,82 @@ int main(int argc, char* argv[])
 	}
 
 	// GLYPHS
-	if (false && nPagesCount > 0)
+	if (true && nPagesCount > 0)
 	{
-		// TODO:
 		BYTE* pGlyphs = GetGlyphs(pGrFile, nTestPage);
+		nLength = READ_INT(pGlyphs);
+		int i = 4;
+		nLength -= 20;
+
+		int nPathLength = READ_INT(pGlyphs + i);
+		i += 4;
+		std::cout << "Stats Paragraphs " << nPathLength;
+		nPathLength = READ_INT(pGlyphs + i);
+		i += 4;
+		std::cout << " Words " << nPathLength;
+		nPathLength = READ_INT(pGlyphs + i);
+		i += 4;
+		std::cout << " Symbols " << nPathLength;
+		nPathLength = READ_INT(pGlyphs + i);
+		i += 4;
+		std::cout << " Spaces " << nPathLength << std::endl;
+
+		while (i < nLength)
+		{
+			int nPathLength = READ_INT(pGlyphs + i);
+			i += 4;
+			std::cout << "Line X " << (double)nPathLength / 10000.0;
+			nPathLength = READ_INT(pGlyphs + i);
+			i += 4;
+			std::cout << " Y " << (double)nPathLength / 10000.0;
+			nPathLength = READ_BYTE(pGlyphs + i);
+			i += 1;
+			if (nPathLength)
+			{
+				nPathLength = READ_INT(pGlyphs + i);
+				i += 4;
+				std::cout << " Ex " << (double)nPathLength / 10000.0;
+				nPathLength = READ_INT(pGlyphs + i);
+				i += 4;
+				std::cout << " Ey " << (double)nPathLength / 10000.0;
+			}
+			nPathLength = READ_INT(pGlyphs + i);
+			i += 4;
+			std::cout << " Ascent " << (double)nPathLength / 10000.0;
+			nPathLength = READ_INT(pGlyphs + i);
+			i += 4;
+			std::cout << " Descent " << (double)nPathLength / 10000.0;
+			nPathLength = READ_INT(pGlyphs + i);
+			i += 4;
+			std::cout << " LineWidth " << (double)nPathLength / 10000.0;
+			int nCharLength = READ_INT(pGlyphs + i);
+			i += 4;
+			std::cout << " Chars:" << std::endl;
+			for (int j = 0; j < nCharLength; ++j)
+			{
+				int nCharX = 0;
+				if (j)
+				{
+					nCharX = READ_INT(pGlyphs + i);
+					i += 4;
+				}
+				nPathLength = READ_INT(pGlyphs + i);
+				i += 4;
+				std::cout << "  Unicode " << nPathLength;
+				nPathLength = READ_INT(pGlyphs + i);
+				i += 4;
+				std::cout << " width " << (double)nPathLength / 10000.0;
+				if (nCharX)
+					std::cout << " charX " << (double)nCharX / 10000.0;
+				std::cout << std::endl;
+			}
+		}
+
 		DestroyTextInfo(pGrFile);
 	}
 
 	// INTERACTIVE FORMS
-	if (true)
+	if (false)
 	{
 		ReadInteractiveFormsFonts(pGrFile, 1);
 		ReadInteractiveFormsFonts(pGrFile, 2);
@@ -1787,6 +1861,49 @@ int main(int argc, char* argv[])
 					i += nPathLength;
 				}
 			}
+			else if (sType == "Stamp")
+			{
+				nPathLength = READ_INT(pAnnots + i);
+				i += 4;
+				std::cout << "Icon " << std::string((char*)(pAnnots + i), nPathLength) << ", ";
+				i += nPathLength;
+
+				nPathLength = READ_INT(pAnnots + i);
+				i += 4;
+				std::cout << "Rotate " << nPathLength / 10000.0 << ", ";
+
+				nPathLength = READ_INT(pAnnots + i);
+				i += 4;
+				std::cout << "X1 " << (double)nPathLength / 10000.0 << ", ";
+
+				nPathLength = READ_INT(pAnnots + i);
+				i += 4;
+				std::cout << "Y1 " << (double)nPathLength / 10000.0 << ", ";
+
+				nPathLength = READ_INT(pAnnots + i);
+				i += 4;
+				std::cout << "X2 " << (double)nPathLength / 10000.0 << ", ";
+
+				nPathLength = READ_INT(pAnnots + i);
+				i += 4;
+				std::cout << "Y2 " << (double)nPathLength / 10000.0 << ", ";
+
+				nPathLength = READ_INT(pAnnots + i);
+				i += 4;
+				std::cout << "X3 " << (double)nPathLength / 10000.0 << ", ";
+
+				nPathLength = READ_INT(pAnnots + i);
+				i += 4;
+				std::cout << "Y3 " << (double)nPathLength / 10000.0 << ", ";
+
+				nPathLength = READ_INT(pAnnots + i);
+				i += 4;
+				std::cout << "X4 " << (double)nPathLength / 10000.0 << ", ";
+
+				nPathLength = READ_INT(pAnnots + i);
+				i += 4;
+				std::cout << "Y4 " << (double)nPathLength / 10000.0 << ", ";
+			}
 
 			std::cout << std::endl << std::endl;
 		}
@@ -1808,7 +1925,8 @@ int main(int argc, char* argv[])
 			free(pAnnotAP);
 	}
 
-	if (true)
+	// SCAN PAGE
+	if (false)
 	{
 		BYTE* pScan = ScanPage(pGrFile, nTestPage, 1);
 		if (pScan)

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

@@ -42,6 +42,7 @@ namespace MetaFile
 		virtual void SetImageSize(int nWidth, int nHeight) {}
 		virtual bool LoadFromFile(const wchar_t* wsFilePath) { return false; }
 		virtual bool LoadFromBuffer(BYTE* pBuffer, unsigned int unSize) { return false; }
+		virtual bool LoadFromString(const std::wstring& data) { return false; }
 		virtual bool DrawOnRenderer(IRenderer* pRenderer, double dX, double dY, double dWidth, double dHeight) { return false; }
 		virtual void Close() {}
 		virtual void GetBounds(double* pdX, double* pdY, double* pdW, double* pdH) {}
@@ -50,6 +51,7 @@ namespace MetaFile
 		virtual NSFonts::IFontManager* get_FontManager() { return NULL; }
 
 		virtual std::wstring ConvertToSvg(unsigned int unWidth = 0, unsigned int unHeight = 0) { return L""; }
+		virtual void SetTempDirectory(const std::wstring& dir) {}
 
 		virtual void ConvertToXml(const wchar_t* wsFilePath) {}
 		virtual void ConvertToXmlAndRaster(const wchar_t *wsXmlFilePath, const wchar_t* wsOutFilePath, unsigned int unFileType, int nWidth, int nHeight = -1) {}

DesktopEditor/graphics/pro/js/wasm/src/serialize.h

@@ -1,10 +1,7 @@
 #ifndef _WASM_SERIALIZE_H
 #define _WASM_SERIALIZE_H
 
-#include "../../../../../common/StringExt.h"
-#include "../../../../../common/StringUTF32.h"
-#include "../../../../../graphics/IRenderer.h"
-#include "../../../../../graphics/pro/Fonts.h"
+#include <vector>
 #include "../../../../../common/File.h"
 
 namespace NSWasm
@@ -208,58 +205,32 @@ namespace NSWasm
 		}
 	};
 
-	class CHChar
+	struct CHChar
 	{
-	public:
-		int unicode;	// юникодное значение
-		int gid;		// индекс глифа в файле
-		double x;		// сдвиг по baseline
-		double width;	// ширина символа (сдвиг до след буквы)
-		double* matrix; // матрица преобразования (!!! без сдвига)
+		int unicode; // юникодное значение
+		double x; // сдвиг по baseline
+		double width; // ширина символа (сдвиг до след буквы)
 
-	public:
-		CHChar()
-		{
-			unicode = 0;
-			gid = 0;
-			width = 0;
-			matrix = NULL;
-		}
-		CHChar(const CHChar& oSrc)
-		{
-			*this = oSrc;
-		}
+		CHChar() : unicode(0), x(0), width(0) {}
+		CHChar(const CHChar& oSrc) { *this = oSrc; }
 		CHChar& operator=(const CHChar& oSrc)
 		{
 			unicode = oSrc.unicode;
-			gid = oSrc.gid;
+			x = oSrc.x;
 			width = oSrc.width;
-			matrix = NULL;
-			if (NULL != oSrc.matrix)
-			{
-				matrix = new double[4];
-				memcpy(matrix, oSrc.matrix, 4 * sizeof(double));
-			}
 			return *this;
 		}
-		~CHChar()
-		{
-			RELEASEARRAYOBJECTS(matrix);
-		}
 
 		inline void Clear()
 		{
 			unicode = 0;
-			gid = 0;
+			x = 0;
 			width = 0;
-
-			RELEASEARRAYOBJECTS(matrix);
 		}
 	};
 
-	class CHLine
+	struct CHLine
 	{
-	public:
 		double m_dAscent;
 		double m_dDescent;
 		double m_dX;
@@ -288,7 +259,6 @@ namespace NSWasm
 		double m_shx;
 		double m_shy;
 
-	public:
 		CHLine()
 		{
 			m_dAscent = 0;
@@ -374,9 +344,7 @@ namespace NSWasm
 			{
 				CHChar* pNews = new CHChar[2 * m_lSizeChars];
 				for (LONG i = 0; i < m_lSizeChars; ++i)
-				{
 					pNews[i] = m_pChars[i];
-				}
 
 				RELEASEARRAYOBJECTS(m_pChars);
 				m_pChars = pNews;
@@ -392,10 +360,18 @@ namespace NSWasm
 
 		inline CHChar* GetTail()
 		{
-			if (0 == m_lCharsTail)
-				return NULL;
+			if (m_lCharsTail >= m_lSizeChars)
+			{
+				CHChar* pNews = new CHChar[2 * m_lSizeChars];
+				for (LONG i = 0; i < m_lSizeChars; ++i)
+					pNews[i] = m_pChars[i];
 
-			return &m_pChars[m_lCharsTail - 1];
+				RELEASEARRAYOBJECTS(m_pChars);
+				m_pChars = pNews;
+				m_lSizeChars *= 2;
+			}
+
+			return m_lCharsTail ? &m_pChars[m_lCharsTail - 1] : NULL;
 		}
 
 		inline LONG GetCountChars()

DesktopEditor/graphics/pro/metafile.pri

@@ -19,6 +19,7 @@ METAFILE_PATH = $$PWD/../../raster/Metafile
 		\
 		$$METAFILE_PATH/Emf/EmfTypes.h \
 		$$METAFILE_PATH/Emf/EmfObjects.h \
+		$$METAFILE_PATH/Emf/EmfPlusObjects.h \
 		$$METAFILE_PATH/Emf/EmfPlayer.h \
 		$$METAFILE_PATH/Emf/EmfFile.h \
 		$$METAFILE_PATH/Wmf/WmfObjects.h \

DesktopEditor/graphics/pro/officedrawingfile.h

@@ -43,6 +43,18 @@ enum OfficeDrawingFileType
     odftUndefined = 255
 };
 
+struct COfficeDrawingPageParams
+{
+	bool m_bNeedDrawAnnotation;
+
+	COfficeDrawingPageParams() : m_bNeedDrawAnnotation(true){}
+
+	void SetDrawAnnotation(bool bDraw)
+	{
+		m_bNeedDrawAnnotation = bDraw;
+	}
+};
+
 class GRAPHICS_DECL IOfficeDrawingFile
 {
 public:
@@ -70,7 +82,7 @@ public:
     // Pages info/draw
     virtual int GetPagesCount() = 0;
     virtual void GetPageInfo(int nPageIndex, double* pdWidth, double* pdHeight, double* pdDpiX, double* pdDpiY) = 0;
-    virtual void DrawPageOnRenderer(IRenderer* pRenderer, int nPageIndex, bool* pBreak) = 0;
+    virtual void DrawPageOnRenderer(IRenderer* pRenderer, int nPageIndex, bool* pBreak, COfficeDrawingPageParams* pParams = NULL) = 0;
 
     // Common methods/wrappers on GetPageInfo + DrawPageOnRenderer
     virtual unsigned char* ConvertToPixels(int nPageIndex, int nRasterW, int nRasterH,

DesktopEditor/raster/Metafile/Common/CPath.cpp

@@ -327,6 +327,13 @@ namespace MetaFile
 		if (NULL == pCommand)
 			return false;
 		
+		if (PATH_COMMAND_MOVETO == pCommand->GetType() && !m_arCommands.empty() && PATH_COMMAND_MOVETO == m_arCommands.back()->GetType())
+		{
+			CPathCommandBase* pLastCommand = m_arCommands.back();
+			m_arCommands.pop_back();
+			delete pLastCommand;
+		}
+
 		m_arCommands.push_back(pCommand);
 		return true;
 	}

DesktopEditor/raster/Metafile/Common/CPathConverter.cpp

@@ -59,7 +59,7 @@ namespace MetaFile
 				{
 					CPathCommandArcTo *pCommandArcTo = (CPathCommandArcTo*)pCommand;
 
-                                        oNewPath.ArcTo(pCommandArcTo->GetLeft(),       pCommandArcTo->GetTop(),
+					oNewPath.ArcTo(pCommandArcTo->GetLeft(),       pCommandArcTo->GetTop(),
 					               pCommandArcTo->GetRight(),      pCommandArcTo->GetBottom(),
 					               pCommandArcTo->GetStartAngle(), pCommandArcTo->GetSweepAngle());
 

DesktopEditor/raster/Metafile/Common/MetaFileObjects.h

@@ -33,6 +33,7 @@
 #define _METAFILE_COMMON_METAFILEOBJECTS_H
 
 #include <string>
+#include <vector>
 
 namespace MetaFile
 {
@@ -70,22 +71,33 @@ namespace MetaFile
 		virtual void         GetBounds(double& left, double& top, double& width, double& height) const = 0;
 		virtual void         GetCenterPoint(double& dX, double& dY) const = 0;
 
+		virtual void GetGradientColors(std::vector<long>& arColors, std::vector<double>& arPositions) const = 0;
+
 		virtual void         GetDibPattern(unsigned char** pBuffer, unsigned int &unWidth, unsigned int &unHeight) const = 0;
 	};
 
+	class ILineCap
+	{
+	public:
+		ILineCap(){}
+		virtual ~ILineCap(){}
+	};
+
 	class IPen
 	{
 	public:
 		IPen(){}
 		virtual ~IPen(){}
 
-		virtual int          GetColor()      const = 0;
-		virtual unsigned int GetStyle()      const = 0;
-		virtual double       GetWidth()      const = 0;
-		virtual unsigned int GetAlpha()      const = 0;
-		virtual double       GetMiterLimit() const = 0;
-		virtual double       GetDashOffset() const = 0;
-		virtual void         GetDashData(double*&, unsigned int&) const = 0;
+		virtual int             GetColor()        const = 0;
+		virtual unsigned int    GetStyle()        const = 0;
+		virtual double          GetWidth()        const = 0;
+		virtual unsigned int    GetAlpha()        const = 0;
+		virtual double          GetMiterLimit()   const = 0;
+		virtual double          GetDashOffset()   const = 0;
+		virtual void            GetDashData(double*&, unsigned int&) const = 0;
+		virtual const ILineCap* GetStartLineCap() const = 0;
+		virtual const ILineCap* GetEndLineCap()   const = 0;
 	};
 
 	class IRegion

DesktopEditor/raster/Metafile/Common/MetaFileRenderer.h

@@ -100,6 +100,8 @@ namespace MetaFile
 			m_bStartedPath = false;
 			m_bUpdatedClip = true;
 
+			m_pRenderer->CommandLong(c_nPenWidth0As1px, 1);
+
 			//int alpha = 0xff;
 			//m_pRenderer->put_BrushAlpha1(alpha);
 			//m_pRenderer->put_BrushType(c_BrushTypeSolid);
@@ -1107,12 +1109,11 @@ namespace MetaFile
 
 				m_pRenderer->put_BrushLinearAngle(pBrush->GetStyleEx());
 
-				long Colors[2];
-				Colors[0] = pBrush->GetColor()  + (pBrush->GetAlpha()  << 24);
-				Colors[1] = pBrush->GetColor2() + (pBrush->GetAlpha2() << 24);
-				double Position[2] = {0, 1};
+				std::vector<long> arColors;
+				std::vector<double> arPositions;
 
-				m_pRenderer->put_BrushGradientColors(Colors,Position,2);
+				pBrush->GetGradientColors(arColors, arPositions);
+				m_pRenderer->put_BrushGradientColors(arColors.data(), arPositions.data(), arColors.size());
 
 			}
 			else if (	BS_RADIALGRADIENT	== unBrushStyle ||
@@ -1180,7 +1181,6 @@ namespace MetaFile
 				return false;
 
 			unsigned int unMetaPenStyle = pPen->GetStyle();
-
 			unsigned int ulPenStyle     = unMetaPenStyle & PS_STYLE_MASK;
 
 			if (PS_NULL == ulPenStyle)
@@ -1218,22 +1218,8 @@ namespace MetaFile
 			else if (PS_JOIN_MITER == ulPenJoin)
 				nJoinStyle = Aggplus::LineJoinMiter;
 
-			double dWidth = pPen->GetWidth();
-
-			if (Equals(0, dWidth) || (Equals(1, dWidth) && PS_COSMETIC == ulPenType))
-			{
-				double dRendererDpiX;
-				m_pRenderer->get_DpiX(&dRendererDpiX);
-
-				dWidth = 25.4 / 96. * m_pFile->GetDpi() / dRendererDpiX;
-
-				nStartCapStyle = nEndCapStyle = Aggplus::LineCapFlat;
-				nJoinStyle = Aggplus::LineJoinMiter;
-			}
-			else
-				dWidth *= m_dScaleX;
-
-			double dMiterLimit = (0 != pPen->GetMiterLimit()) ? pPen->GetMiterLimit() : m_pFile->GetMiterLimit() * m_dScaleX;
+			const double dWidth = pPen->GetWidth() * m_dScaleX;
+			const double dMiterLimit = (0 != pPen->GetMiterLimit()) ? pPen->GetMiterLimit() : m_pFile->GetMiterLimit() * m_dScaleX;
 
 			BYTE nDashStyle = Aggplus::DashStyleSolid;
 
@@ -1246,10 +1232,16 @@ namespace MetaFile
 			{
 				m_pRenderer->put_PenDashOffset(pPen->GetDashOffset());
 
+				double dM11, dTemp;
+				m_pRenderer->GetTransform(&dM11, &dTemp, &dTemp, &dTemp, &dTemp, &dTemp);
+				double dDpi;
+				m_pRenderer->get_DpiX(&dDpi);
+				const double dNewWidth{dWidth * dM11 * dDpi / 25.4};
+
 				std::vector<double> arDashes(unSizeDash);
 
 				for (unsigned int unIndex = 0; unIndex < unSizeDash; ++unIndex)
-						arDashes[unIndex] = pDataDash[unIndex] * dWidth;
+					arDashes[unIndex] = pDataDash[unIndex] * dNewWidth;
 
 				m_pRenderer->PenDashPattern(arDashes.data(), unSizeDash);
 
@@ -1259,39 +1251,45 @@ namespace MetaFile
 			{
 				std::vector<double> arDashPattern;
 
+				double dM11, dTemp;
+				m_pRenderer->GetTransform(&dM11, &dTemp, &dTemp, &dTemp, &dTemp, &dTemp);
+				double dDpi;
+				m_pRenderer->get_DpiX(&dDpi);
+				const double dNewWidth{dWidth * dM11 * dDpi / 25.4};
+
 				switch (ulPenStyle)
 				{
 					case PS_DASH:
 					{
-						arDashPattern.push_back(9 * dWidth);
-						arDashPattern.push_back(3 * dWidth);
+						arDashPattern.push_back(9 * dNewWidth);
+						arDashPattern.push_back(3 * dNewWidth);
 
 						break;
 					}
 					case PS_DOT:
 					{
-						arDashPattern.push_back(3 * dWidth);
-						arDashPattern.push_back(3 * dWidth);
+						arDashPattern.push_back(3 * dNewWidth);
+						arDashPattern.push_back(3 * dNewWidth);
 
 						break;
 					}
 					case PS_DASHDOT:
 					{
-						arDashPattern.push_back(9 * dWidth);
-						arDashPattern.push_back(3 * dWidth);
-						arDashPattern.push_back(3 * dWidth);
-						arDashPattern.push_back(3 * dWidth);
+						arDashPattern.push_back(9 * dNewWidth);
+						arDashPattern.push_back(3 * dNewWidth);
+						arDashPattern.push_back(3 * dNewWidth);
+						arDashPattern.push_back(3 * dNewWidth);
 
 						break;
 					}
 					case PS_DASHDOTDOT:
 					{
-						arDashPattern.push_back(9 * dWidth);
-						arDashPattern.push_back(3 * dWidth);
-						arDashPattern.push_back(3 * dWidth);
-						arDashPattern.push_back(3 * dWidth);
-						arDashPattern.push_back(3 * dWidth);
-						arDashPattern.push_back(3 * dWidth);
+						arDashPattern.push_back(9 * dNewWidth);
+						arDashPattern.push_back(3 * dNewWidth);
+						arDashPattern.push_back(3 * dNewWidth);
+						arDashPattern.push_back(3 * dNewWidth);
+						arDashPattern.push_back(3 * dNewWidth);
+						arDashPattern.push_back(3 * dNewWidth);
 
 						break;
 					}

DesktopEditor/raster/Metafile/Common/MetaFileTypes.h

@@ -349,6 +349,8 @@ typedef unsigned char BYTE;
 
 namespace MetaFile
 {
+	#define DEFAULT_FONT_SIZE 14
+
 	enum InterpretatorType
 	{
 			Emf,

DesktopEditor/raster/Metafile/Common/MetaFileUtils.cpp

@@ -147,6 +147,10 @@ namespace MetaFile
 			if (BI_JPEG != unCompression || BI_PNG != unCompression)
 				return false;
 
+#ifdef METAFILE_DISABLE_FILESYSTEM
+			return false;
+#endif
+
 			std::wstring wsTempFileName = GetTempFilename();
 			if (wsTempFileName.empty())
 				return false;

DesktopEditor/raster/Metafile/Common/MetaFileUtils.h

@@ -48,6 +48,8 @@ namespace MetaFile
 {
 	bool Equals(double dFirst, double dSecond, double dEpsilon = DBL_EPSILON);
 	std::wstring ConvertToUnicode(const unsigned char* pText, unsigned long unLength, unsigned short uchCharSet);
+	std::wstring ConvertToWString(double dValue, int nAccuracy = -1);
+	std::wstring ConvertToWString(const std::vector<double>& arValues, int nAccuracy = -1);
 
 	struct TRgbQuad
 	{
@@ -88,13 +90,34 @@ namespace MetaFile
 	};
 
 	typedef std::pair<const std::wstring, std::wstring>     NodeAttribute;
-	typedef std::vector<NodeAttribute>                      NodeAttributes;
+	// typedef std::vector<NodeAttribute>                      NodeAttributes;
+
+	class NodeAttributes : public std::vector<NodeAttribute>
+	{
+	public:
+		using std::vector<NodeAttribute>::vector;
+
+		void Add(const std::wstring& wsNameArgument, const std::wstring& wsValueArgument)
+		{
+			emplace_back(NodeAttribute{wsNameArgument, wsValueArgument});
+		}
+
+		void Add(const std::wstring& wsNameArgument, const double& dValueArgument, int nAccuracy = -1)
+		{
+			emplace_back(NodeAttribute{wsNameArgument, ConvertToWString(dValueArgument, nAccuracy)});
+		}
+
+		void Add(const std::wstring& wsNameArgument, const int& nValueArgument)
+		{
+			emplace_back(NodeAttribute{wsNameArgument, std::to_wstring(nValueArgument)});
+		}
+	};
 
 	class CDataStream
 	{
 	public:
 
-		CDataStream() : pBuffer(NULL), pBufferEnd(NULL), pEnd(NULL), pCur(NULL)
+		CDataStream() : pBuffer(NULL), pBufferEnd(NULL), pCur(NULL), pEnd(NULL)
 		{
 		}
 
@@ -1159,8 +1182,5 @@ namespace MetaFile
 
 	std::wstring StringNormalization(const std::wstring& wsString);
 	bool StringEquals(const std::wstring& wsFirstString, const std::wstring& wsSecondString);
-
-	std::wstring ConvertToWString(double dValue, int nAccuracy = -1);
-	std::wstring ConvertToWString(const std::vector<double>& arValues, int nAccuracy = -1);
 };
 #endif // _METAFILE_COMMON_METAFILEUTILS_H

DesktopEditor/raster/Metafile/Emf/EmfInterpretator/CEmfInterpretatorRender.cpp

@@ -41,7 +41,7 @@ namespace MetaFile
 	}
 
 	void CEmfInterpretatorRender::DrawString(std::wstring &wsText, unsigned int unCharsCount, double dX, double dY, double *pDx,
-											 int iGraphicsMode, double dXScale, double dYScale)
+	                                         int iGraphicsMode, double dXScale, double dYScale)
 	{
 		if (NULL != m_pMetaFileRenderer)
 			m_pMetaFileRenderer->DrawString(wsText, unCharsCount, dX, dY, pDx, iGraphicsMode, dXScale, dYScale);

DesktopEditor/raster/Metafile/Emf/EmfInterpretator/CEmfInterpretatorSvg.cpp

@@ -33,7 +33,8 @@ namespace MetaFile
 			return;
 
 		std::swap(m_pParser, m_oSecondConditional.m_pParser);
-		std::swap(m_oClip, m_oSecondConditional.m_oClip);
+
+		SwapClips(m_oClip, m_oSecondConditional.m_oClip);
 	}
 
 	InterpretatorType CEmfInterpretatorSvg::GetType() const
@@ -107,7 +108,7 @@ namespace MetaFile
 		
 		if (NULL == pPath)
 			return;
-		
+
 		const std::wstring wsValue = CreatePath(*pPath);
 
 		if (wsValue.empty())
@@ -117,6 +118,7 @@ namespace MetaFile
 
 		AddClip();
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 
 		WriteNode(L"path" , arAttributes);
@@ -175,6 +177,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 
 		if (AD_COUNTERCLOCKWISE == m_pParser->GetArcDirection())
 		{
@@ -238,6 +241,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 
 		if (AD_COUNTERCLOCKWISE == m_pParser->GetArcDirection())
 		{
@@ -292,6 +296,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 
 		if (AD_COUNTERCLOCKWISE == m_pParser->GetArcDirection())
 		{
@@ -325,6 +330,7 @@ namespace MetaFile
 		                               {L"ry", ConvertToWString((oNewRect.Bottom - oNewRect.Top)    / 2)}};
 		AddStroke(arAttributes);
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -365,6 +371,7 @@ namespace MetaFile
 		                               {L"y2", ConvertToWString(oPoint.Y)}};
 
 		AddStroke(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -373,21 +380,29 @@ namespace MetaFile
 
 	void CEmfInterpretatorSvg::HANDLE_EMR_PIE(const TRectL &oBox, const TPointL &oStart, const TPointL &oEnd)
 	{
-		short shCenterX = (oBox.Left + oBox.Right) / 2;
-		short shCenterY = (oBox.Top + oBox.Bottom) / 2;
+		int nCenterX = (oBox.Left + oBox.Right) / 2;
+		int nCenterY = (oBox.Top + oBox.Bottom) / 2;
 
 		short shRadiusX = std::abs(oBox.Right - oBox.Left) / 2;
 		short shRadiusY = std::abs(oBox.Bottom - oBox.Top) / 2;
 
-		std::wstring wsPath = L'M' + ConvertToWString(shCenterX) + L' ' + ConvertToWString(shCenterY) + L' ' +
+		double dStartAngle = std::atan2(oStart.Y - nCenterY, oStart.X - nCenterX);
+		double dEndAngle   = std::atan2(oEnd.Y   - nCenterY, oEnd.X   - nCenterX);
+
+		if (dEndAngle > dStartAngle)
+			dEndAngle -= 2 * M_PI;
+
+		std::wstring wsPath = L'M' + ConvertToWString(nCenterX) + L' ' + ConvertToWString(nCenterY) + L' ' +
 		                      L'L' + ConvertToWString(oStart.X)+ L' ' + ConvertToWString(oStart.Y)+ L' ' +
-		                      L'A' + ConvertToWString(shRadiusX) + L' ' + ConvertToWString(shRadiusY) + L" 0, 0, 0, " + ConvertToWString(oEnd.X) + L' ' + ConvertToWString(oEnd.Y) + L' ' +
-		                      L'L' + ConvertToWString(shCenterX) + L' ' + ConvertToWString(shCenterY) + L" Z";
+		                      L'A' + ConvertToWString(shRadiusX) + L' ' + ConvertToWString(shRadiusY) + L" 0 " +
+		                      ((std::abs(dEndAngle - dStartAngle) > M_PI) ? L'1' : L'0') + L" 0 " + ConvertToWString(oEnd.X) + L' ' + ConvertToWString(oEnd.Y) + L' ' +
+		                      L'L' + ConvertToWString(nCenterX) + L' ' + ConvertToWString(nCenterY) + L" Z";
 
 		NodeAttributes arAttributes = {{L"d", wsPath}};
 
 		AddStroke(arAttributes);
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -402,14 +417,15 @@ namespace MetaFile
 		std::wstring wsValue = L"M " + ConvertToWString(arPoints[0].X) + L' ' + ConvertToWString(arPoints[0].Y) + L" C ";
 
 		for (unsigned int unIndex = 1; unIndex + 2 < arPoints.size(); unIndex += 3)
-			wsValue +=	ConvertToWString(arPoints[unIndex].X)     + L' ' + ConvertToWString(arPoints[unIndex].Y)     + L' ' +
-			            ConvertToWString(arPoints[unIndex + 1].X) + L' ' + ConvertToWString(arPoints[unIndex + 1].Y) + L' ' +
-			            ConvertToWString(arPoints[unIndex + 2].X) + L' ' + ConvertToWString(arPoints[unIndex + 2].Y) + L' ';
+			wsValue += ConvertToWString(arPoints[unIndex].X)     + L' ' + ConvertToWString(arPoints[unIndex].Y)     + L' ' +
+			           ConvertToWString(arPoints[unIndex + 1].X) + L' ' + ConvertToWString(arPoints[unIndex + 1].Y) + L' ' +
+			           ConvertToWString(arPoints[unIndex + 2].X) + L' ' + ConvertToWString(arPoints[unIndex + 2].Y) + L' ';
 
 		NodeAttributes arAttributes = {{L"d", wsValue}};
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -424,14 +440,15 @@ namespace MetaFile
 		std::wstring wsValue = L"M " + ConvertToWString(arPoints[0].X) + L' ' + ConvertToWString(arPoints[0].Y) + L" C ";
 
 		for (unsigned int unIndex = 1; unIndex + 2 < arPoints.size(); unIndex += 3)
-			wsValue +=	ConvertToWString(arPoints[unIndex].X)     + L' ' + ConvertToWString(arPoints[unIndex].Y)     + L' ' +
-			            ConvertToWString(arPoints[unIndex + 1].X) + L' ' + ConvertToWString(arPoints[unIndex + 1].Y) + L' ' +
-			            ConvertToWString(arPoints[unIndex + 2].X) + L' ' + ConvertToWString(arPoints[unIndex + 2].Y) + L' ';
+			wsValue += ConvertToWString(arPoints[unIndex].X)     + L' ' + ConvertToWString(arPoints[unIndex].Y)     + L' ' +
+			           ConvertToWString(arPoints[unIndex + 1].X) + L' ' + ConvertToWString(arPoints[unIndex + 1].Y) + L' ' +
+			           ConvertToWString(arPoints[unIndex + 2].X) + L' ' + ConvertToWString(arPoints[unIndex + 2].Y) + L' ';
 
 		NodeAttributes arAttributes = {{L"d", wsValue}};
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -446,14 +463,15 @@ namespace MetaFile
 		std::wstring wsValue = L"M " + ConvertToWString(arPoints[0].X) + L' ' + ConvertToWString(arPoints[0].Y) + L" C ";
 
 		for (unsigned int unIndex = 1; unIndex + 2 < arPoints.size(); unIndex += 3)
-			wsValue +=	ConvertToWString(arPoints[unIndex].X)     + L' ' + ConvertToWString(arPoints[unIndex].Y)     + L' ' +
-			            ConvertToWString(arPoints[unIndex + 1].X) + L' ' + ConvertToWString(arPoints[unIndex + 1].Y) + L' ' +
-			            ConvertToWString(arPoints[unIndex + 2].X) + L' ' + ConvertToWString(arPoints[unIndex + 2].Y) + L' ';
+			wsValue += ConvertToWString(arPoints[unIndex].X)     + L' ' + ConvertToWString(arPoints[unIndex].Y)     + L' ' +
+			           ConvertToWString(arPoints[unIndex + 1].X) + L' ' + ConvertToWString(arPoints[unIndex + 1].Y) + L' ' +
+			           ConvertToWString(arPoints[unIndex + 2].X) + L' ' + ConvertToWString(arPoints[unIndex + 2].Y) + L' ';
 
 		NodeAttributes arAttributes = {{L"d", wsValue}};
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -468,14 +486,15 @@ namespace MetaFile
 		std::wstring wsValue = L"M " + ConvertToWString(arPoints[0].X) + L' ' + ConvertToWString(arPoints[0].Y) + L" C ";
 
 		for (unsigned int unIndex = 1; unIndex + 2 < arPoints.size(); unIndex += 3)
-			wsValue +=	ConvertToWString(arPoints[unIndex].X)     + L' ' + ConvertToWString(arPoints[unIndex].Y)     + L' ' +
-			            ConvertToWString(arPoints[unIndex + 1].X) + L' ' + ConvertToWString(arPoints[unIndex + 1].Y) + L' ' +
-			            ConvertToWString(arPoints[unIndex + 2].X) + L' ' + ConvertToWString(arPoints[unIndex + 2].Y) + L' ';
+			wsValue += ConvertToWString(arPoints[unIndex].X)     + L' ' + ConvertToWString(arPoints[unIndex].Y)     + L' ' +
+			           ConvertToWString(arPoints[unIndex + 1].X) + L' ' + ConvertToWString(arPoints[unIndex + 1].Y) + L' ' +
+			           ConvertToWString(arPoints[unIndex + 2].X) + L' ' + ConvertToWString(arPoints[unIndex + 2].Y) + L' ';
 
 		NodeAttributes arAttributes = {{L"d", wsValue}};
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -509,9 +528,9 @@ namespace MetaFile
 					wsValue += L" C ";
 					oLastType = 0x04;
 				}
-				wsValue +=	ConvertToWString(arPoints[unIndex].X)     + L',' + ConvertToWString(arPoints[unIndex].Y)     + L' ' +
-				            ConvertToWString(arPoints[unIndex + 1].X) + L',' + ConvertToWString(arPoints[unIndex + 1].Y) + L' ' +
-				            ConvertToWString(arPoints[unIndex + 2].X) + L',' + ConvertToWString(arPoints[unIndex + 2].Y) + L' ';
+				wsValue += ConvertToWString(arPoints[unIndex].X)     + L',' + ConvertToWString(arPoints[unIndex].Y)     + L' ' +
+				           ConvertToWString(arPoints[unIndex + 1].X) + L',' + ConvertToWString(arPoints[unIndex + 1].Y) + L' ' +
+				           ConvertToWString(arPoints[unIndex + 2].X) + L',' + ConvertToWString(arPoints[unIndex + 2].Y) + L' ';
 
 				unIndex += 3;
 			}
@@ -526,6 +545,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -559,9 +579,9 @@ namespace MetaFile
 					wsValue += L" C ";
 					oLastType = 0x04;
 				}
-				wsValue +=	ConvertToWString(arPoints[unIndex].X)     + L',' + ConvertToWString(arPoints[unIndex].Y)     + L' ' +
-				            ConvertToWString(arPoints[unIndex + 1].X) + L',' + ConvertToWString(arPoints[unIndex + 1].Y) + L' ' +
-				            ConvertToWString(arPoints[unIndex + 2].X) + L',' + ConvertToWString(arPoints[unIndex + 2].Y) + L' ';
+				wsValue += ConvertToWString(arPoints[unIndex].X)     + L',' + ConvertToWString(arPoints[unIndex].Y)     + L' ' +
+				           ConvertToWString(arPoints[unIndex + 1].X) + L',' + ConvertToWString(arPoints[unIndex + 1].Y) + L' ' +
+				           ConvertToWString(arPoints[unIndex + 2].X) + L',' + ConvertToWString(arPoints[unIndex + 2].Y) + L' ';
 
 				unIndex += 3;
 			}
@@ -576,6 +596,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -596,6 +617,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -616,6 +638,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -636,6 +659,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -658,6 +682,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -680,6 +705,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -702,6 +728,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -729,10 +756,11 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
-		arAttributes.push_back({L"fill-rule", L"evenodd"});
+		arAttributes.Add(L"fill-rule", L"evenodd");
 
 		WriteNode(L"path", arAttributes);
 	}
@@ -758,10 +786,11 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
-		arAttributes.push_back({L"fill-rule", L"evenodd"});
+		arAttributes.Add(L"fill-rule", L"evenodd");
 
 		WriteNode(L"path", arAttributes);
 	}
@@ -787,10 +816,11 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
-		arAttributes.push_back({L"fill-rule", L"evenodd"});
+		arAttributes.Add(L"fill-rule", L"evenodd");
 
 		WriteNode(L"path", arAttributes);
 	}
@@ -816,10 +846,11 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
-		arAttributes.push_back({L"fill-rule", L"evenodd"});
+		arAttributes.Add(L"fill-rule", L"evenodd");
 
 		WriteNode(L"path", arAttributes);
 	}
@@ -828,13 +859,14 @@ namespace MetaFile
 	{
 		TRectD oNewRect = TranslateRect(oBox);
 
-		NodeAttributes arAttributes = {{L"x",		ConvertToWString(oNewRect.Left)},
-		                               {L"y",		ConvertToWString(oNewRect.Top)},
-		                               {L"width",	ConvertToWString(oNewRect.Right - oNewRect.Left)},
-		                               {L"height",	ConvertToWString(oNewRect.Bottom - oNewRect.Top)}};
+		NodeAttributes arAttributes = {{L"x",      ConvertToWString(oNewRect.Left)},
+		                               {L"y",      ConvertToWString(oNewRect.Top)},
+		                               {L"width",  ConvertToWString(oNewRect.Right - oNewRect.Left)},
+		                               {L"height", ConvertToWString(oNewRect.Bottom - oNewRect.Top)}};
 
 		AddStroke(arAttributes);
 		AddFill(arAttributes, oNewRect.Right - oNewRect.Left, oNewRect.Bottom - oNewRect.Top);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -845,15 +877,16 @@ namespace MetaFile
 	{
 		TRectD oNewRect = TranslateRect(oBox);
 
-		NodeAttributes arAttributes = {{L"x",		ConvertToWString(oNewRect.Left)},
-		                               {L"y",		ConvertToWString(oNewRect.Top)},
-		                               {L"width",	ConvertToWString(oNewRect.Right - oNewRect.Left)},
-		                               {L"height",	ConvertToWString(oNewRect.Bottom - oNewRect.Top)},
-		                               {L"rx",		ConvertToWString((double)oCorner.X / 2.)},
-		                               {L"ry",		ConvertToWString((double)oCorner.Y / 2.)}};
+		NodeAttributes arAttributes = {{L"x",      ConvertToWString(oNewRect.Left)},
+		                               {L"y",      ConvertToWString(oNewRect.Top)},
+		                               {L"width",  ConvertToWString(oNewRect.Right - oNewRect.Left)},
+		                               {L"height", ConvertToWString(oNewRect.Bottom - oNewRect.Top)},
+		                               {L"rx",     ConvertToWString((double)oCorner.X / 2.)},
+		                               {L"ry",     ConvertToWString((double)oCorner.Y / 2.)}};
 
 		AddStroke(arAttributes);
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -889,6 +922,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddFill(arAttributes, std::fabs(oBounds.Right - oBounds.Left), std::fabs(oBounds.Bottom - oBounds.Top));
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -914,6 +948,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -928,15 +963,16 @@ namespace MetaFile
 		NodeAttributes arAttributes;
 
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
 		if (4 == arVertex.size())
 		{
-			arAttributes.push_back({L"x",      ConvertToWString(std::min(arVertex[0].nX, arVertex[1].nX))});
-			arAttributes.push_back({L"y",      ConvertToWString(std::min(arVertex[0].nY, arVertex[2].nY))});
-			arAttributes.push_back({L"width",  ConvertToWString(std::abs(arVertex[1].nX - arVertex[0].nX))});
-			arAttributes.push_back({L"height", ConvertToWString(std::abs(arVertex[2].nY - arVertex[0].nY))});
+			arAttributes.Add(L"x",      std::min(arVertex[0].nX, arVertex[1].nX));
+			arAttributes.Add(L"y",      std::min(arVertex[0].nY, arVertex[2].nY));
+			arAttributes.Add(L"width",  std::abs(arVertex[1].nX - arVertex[0].nX));
+			arAttributes.Add(L"height", std::abs(arVertex[2].nY - arVertex[0].nY));
 			WriteNode(L"rect" , arAttributes);
 		}
 		else if (3 == arVertex.size())
@@ -950,7 +986,7 @@ namespace MetaFile
 			std::wstring wsValue = CreatePath(oPath);
 
 			if (!wsValue.empty())
-				arAttributes.push_back({L"d", wsValue});
+				arAttributes.Add(L"d", wsValue);
 
 			WriteNode(L"path" , arAttributes);
 		}
@@ -969,16 +1005,17 @@ namespace MetaFile
 		{
 			oTempRect = TranslateRect(oRect);
 
-			wsValue +=	L"M " + ConvertToWString(oTempRect.Left)  + L',' + ConvertToWString(oTempRect.Top) + L' ' +
-			            L"L " + ConvertToWString(oTempRect.Right) + L',' + ConvertToWString(oTempRect.Top) + L' ' +
-			                    ConvertToWString(oTempRect.Right) + L',' + ConvertToWString(oTempRect.Bottom) + L' ' +
-			                    ConvertToWString(oTempRect.Left)	+ L',' + ConvertToWString(oTempRect.Bottom) + L' ' +
-			                    ConvertToWString(oTempRect.Left)	+ L',' + ConvertToWString(oTempRect.Top) + L' ';
+			wsValue += L"M " + ConvertToWString(oTempRect.Left)  + L',' + ConvertToWString(oTempRect.Top) + L' ' +
+			           L"L " + ConvertToWString(oTempRect.Right) + L',' + ConvertToWString(oTempRect.Top) + L' ' +
+			                   ConvertToWString(oTempRect.Right) + L',' + ConvertToWString(oTempRect.Bottom) + L' ' +
+			                   ConvertToWString(oTempRect.Left)  + L',' + ConvertToWString(oTempRect.Bottom) + L' ' +
+			                   ConvertToWString(oTempRect.Left)  + L',' + ConvertToWString(oTempRect.Top) + L' ';
 		}
 
 		NodeAttributes arAttributes = {{L"d", wsValue}};
 
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -998,16 +1035,17 @@ namespace MetaFile
 		{
 			oTempRect = TranslateRect(oRect);
 
-			wsValue +=	L"M " + ConvertToWString(oTempRect.Left)  + L',' + ConvertToWString(oTempRect.Top) + L' ' +
-			            L"L " + ConvertToWString(oTempRect.Right) + L',' + ConvertToWString(oTempRect.Top) + L' ' +
-			                    ConvertToWString(oTempRect.Right) + L',' + ConvertToWString(oTempRect.Bottom) + L' ' +
-			                    ConvertToWString(oTempRect.Left)	+ L',' + ConvertToWString(oTempRect.Bottom) + L' ' +
-			                    ConvertToWString(oTempRect.Left)	+ L',' + ConvertToWString(oTempRect.Top) + L' ';
+			wsValue += L"M " + ConvertToWString(oTempRect.Left)  + L',' + ConvertToWString(oTempRect.Top)    + L' ' +
+			           L"L " + ConvertToWString(oTempRect.Right) + L',' + ConvertToWString(oTempRect.Top)    + L' ' +
+			                   ConvertToWString(oTempRect.Right) + L',' + ConvertToWString(oTempRect.Bottom) + L' ' +
+			                   ConvertToWString(oTempRect.Left)  + L',' + ConvertToWString(oTempRect.Bottom) + L' ' +
+			                   ConvertToWString(oTempRect.Left)  + L',' + ConvertToWString(oTempRect.Top)    + L' ';
 		}
 
 		NodeAttributes arAttributes = {{L"d", wsValue}};
 
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -1016,6 +1054,7 @@ namespace MetaFile
 
 	void CEmfInterpretatorSvg::HANDLE_EMR_FRAMERGN(const TRectL &oBounds, unsigned int unIhBrush, int nWidth, int nHeight, const TRegionDataHeader &oRegionDataHeader, const std::vector<TRectL> &arRects)
 	{
+		m_bUpdatedClip = false;
 	}
 
 	void CEmfInterpretatorSvg::HANDLE_EMFPLUS_OFFSETCLIP(double dX, double dY)
@@ -1085,6 +1124,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 
 		if (AD_COUNTERCLOCKWISE == m_pParser->GetArcDirection())
 		{
@@ -1111,14 +1151,15 @@ namespace MetaFile
 		std::wstring wsValue = L"M " + ConvertToWString(arPoints[0].X) + L' ' + ConvertToWString(arPoints[0].Y) + L" C ";
 
 		for (unsigned int unIndex = 1; unIndex + 2 < arPoints.size(); unIndex += 3)
-			wsValue +=	ConvertToWString(arPoints[unIndex].X)     + L' ' + ConvertToWString(arPoints[unIndex].Y)     + L' ' +
-			            ConvertToWString(arPoints[unIndex + 1].X) + L' ' + ConvertToWString(arPoints[unIndex + 1].Y) + L' ' +
-			            ConvertToWString(arPoints[unIndex + 2].X) + L' ' + ConvertToWString(arPoints[unIndex + 2].Y) + L' ';
+			wsValue += ConvertToWString(arPoints[unIndex].X)     + L' ' + ConvertToWString(arPoints[unIndex].Y)     + L' ' +
+			           ConvertToWString(arPoints[unIndex + 1].X) + L' ' + ConvertToWString(arPoints[unIndex + 1].Y) + L' ' +
+			           ConvertToWString(arPoints[unIndex + 2].X) + L' ' + ConvertToWString(arPoints[unIndex + 2].Y) + L' ';
 
 		NodeAttributes arAttributes = {{L"d", wsValue}};
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -1158,14 +1199,14 @@ namespace MetaFile
 		int nColor = m_pParser->GetTextColor();
 
 		if (0 != nColor)
-			arNodeAttributes.push_back({L"fill", CalculateColor(nColor, 255)});
+			arNodeAttributes.Add(L"fill", CalculateColor(nColor, 255));
 
 		double dFontHeight = std::fabs(pFont->GetHeight());
 
 		if (dFontHeight < 0.01)
 			dFontHeight = 18;
 
-		arNodeAttributes.push_back({L"font-size", ConvertToWString(dFontHeight)});
+		arNodeAttributes.Add(L"font-size", dFontHeight);
 
 		NSStringUtils::CStringBuilder oFontName;
 		oFontName.WriteEncodeXmlString(pFont->GetFaceName());
@@ -1188,21 +1229,21 @@ namespace MetaFile
 				oFontName.WriteEncodeXmlString(L"\'");
 			}
 			#endif
-			arNodeAttributes.push_back({L"font-family", oFontName.GetData()});
+			arNodeAttributes.Add(L"font-family", oFontName.GetData());
 		}
 
 		if (pFont->GetWeight() > 550)
-			arNodeAttributes.push_back({L"font-weight", L"bold"});
+			arNodeAttributes.Add(L"font-weight", L"bold");
 
 		if (pFont->IsItalic())
-			arNodeAttributes.push_back({L"font-style", L"italic"});
+			arNodeAttributes.Add(L"font-style", L"italic");
 
 		if (pFont->IsUnderline() && pFont->IsStrikeOut())
-			arNodeAttributes.push_back({L"text-decoration", L"underline line-through"});
+			arNodeAttributes.Add(L"text-decoration", L"underline line-through");
 		else if (pFont->IsUnderline())
-			arNodeAttributes.push_back({L"text-decoration", L"underline"});
+			arNodeAttributes.Add(L"text-decoration", L"underline");
 		else if (pFont->IsStrikeOut())
-			arNodeAttributes.push_back({L"text-decoration", L"line-through"});
+			arNodeAttributes.Add(L"text-decoration", L"line-through");
 
 		AddTransform(arNodeAttributes);
 		AddClip();
@@ -1218,8 +1259,8 @@ namespace MetaFile
 		wsX.pop_back();
 		wsY.pop_back();
 
-		arNodeAttributes.push_back({L"x", wsX});
-		arNodeAttributes.push_back({L"y", wsY});
+		arNodeAttributes.Add(L"x", wsX);
+		arNodeAttributes.Add(L"y", wsY);
 
 		WriteNode(L"text", arNodeAttributes, wsText);
 	}
@@ -1234,6 +1275,7 @@ namespace MetaFile
 		                               {L"ry", ConvertToWString((oNewRect.Bottom - oNewRect.Top)    / 2)}};
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -1254,6 +1296,7 @@ namespace MetaFile
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -1273,7 +1316,9 @@ namespace MetaFile
 		NodeAttributes arAttributes = {{L"d", wsValue}};
 
 		AddStroke(arAttributes);
+		AddLineCaps(arAttributes, pPath);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -1295,17 +1340,18 @@ namespace MetaFile
 		{
 			oTempRect = oRect.ToRectD();
 
-			wsValue +=	L"M "  + ConvertToWString(oTempRect.Left)  + L',' + ConvertToWString(oTempRect.Top) +
-			            L" L " + ConvertToWString(oTempRect.Right) + L',' + ConvertToWString(oTempRect.Top) + L' ' +
-			                     ConvertToWString(oTempRect.Right) + L',' + ConvertToWString(oTempRect.Bottom) + L' ' +
-			                     ConvertToWString(oTempRect.Left)	+ L',' + ConvertToWString(oTempRect.Bottom) + L' ' +
-			                     ConvertToWString(oTempRect.Left)	+ L',' + ConvertToWString(oTempRect.Top) + L' ';
+			wsValue += L"M "  + ConvertToWString(oTempRect.Left)  + L',' + ConvertToWString(oTempRect.Top)    +
+			           L" L " + ConvertToWString(oTempRect.Right) + L',' + ConvertToWString(oTempRect.Top)    + L' ' +
+			                    ConvertToWString(oTempRect.Right) + L',' + ConvertToWString(oTempRect.Bottom) + L' ' +
+			                    ConvertToWString(oTempRect.Left)  + L',' + ConvertToWString(oTempRect.Bottom) + L' ' +
+			                    ConvertToWString(oTempRect.Left)  + L',' + ConvertToWString(oTempRect.Top)    + L' ';
 		}
 
 		NodeAttributes arAttributes = {{L"d", wsValue}};
 
 		AddStroke(arAttributes);
 		AddNoneFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -1332,6 +1378,7 @@ namespace MetaFile
 		                               {L"ry", ConvertToWString((oNewRect.Bottom - oNewRect.Top)    / 2)}};
 
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -1353,6 +1400,7 @@ namespace MetaFile
 		TRectD oPathRect = pPath->GetBounds();
 
 		AddFill(arAttributes, std::fabs(oPathRect.Right - oPathRect.Left), std::fabs(oPathRect.Bottom - oPathRect.Top));
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 		AddClip();
 
@@ -1377,6 +1425,7 @@ namespace MetaFile
 		NodeAttributes arAttributes = {{L"points", wsValue}};
 
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddTransform(arAttributes);
 
 		NodeAttributes arGAttributes;
@@ -1387,17 +1436,18 @@ namespace MetaFile
 
 	void CEmfInterpretatorSvg::HANDLE_EMFPLUS_FILLRECTS(unsigned int unBrushId, const std::vector<TEmfPlusRectF> &arRects)
 	{
+		if (arRects.empty())
+			return;
+
 		std::wstring wsValue;
 
 		TRectD oTempRect;
+		TXForm oFileTransform(m_pParser->GetTransform());
 
 		for (const TEmfPlusRectF& oRect : arRects)
 		{
 			oTempRect = oRect.ToRectD();
 
-			m_pParser->GetTransform().Apply(oTempRect.Left,  oTempRect.Top);
-			m_pParser->GetTransform().Apply(oTempRect.Right, oTempRect.Bottom);
-
 			wsValue += L"M "  + ConvertToWString(oTempRect.Left)  + L',' + ConvertToWString(oTempRect.Top)    +
 			           L" L " + ConvertToWString(oTempRect.Right) + L',' + ConvertToWString(oTempRect.Top)    + L' ' +
 			                    ConvertToWString(oTempRect.Right) + L',' + ConvertToWString(oTempRect.Bottom) + L' ' +
@@ -1405,9 +1455,13 @@ namespace MetaFile
 			                    ConvertToWString(oTempRect.Left)  + L',' + ConvertToWString(oTempRect.Top)    + L' ';
 		}
 
+		wsValue.pop_back();
+
 		NodeAttributes arAttributes = {{L"d", wsValue}};
 
+		AddTransform(arAttributes);
 		AddFill(arAttributes);
+		AddShapeRendering(arAttributes);
 		AddClip();
 
 		WriteNode(L"path", arAttributes);
@@ -1448,25 +1502,15 @@ namespace MetaFile
 		CInterpretatorSvgBase::PathClip(oPath, nClipMode, pTransform);
 	}
 
-	TRectD CEmfInterpretatorSvg::TranslateRect(const TRectL &oRect) const
+	void CEmfInterpretatorSvg::SwapClips(CSvgClip& oFirstClip, CSvgClip& oSecondClip)
 	{
-		TRectD oNewRect(oRect.Left, oRect.Top, oRect.Right, oRect.Bottom);
+		if (oFirstClip.StartedClip())
+			WriteNodeEnd(L"g");
 
-		if (oNewRect.Right < oNewRect.Left)
-		{
-			double dTempValue = oNewRect.Left;
-			oNewRect.Left    = oNewRect.Right;
-			oNewRect.Right   = dTempValue;
-		}
+		if (oSecondClip.StartedClip())
+			WriteNodeBegin(L"g", {{L"clip-path", L"url(#" + oSecondClip.GetClipId() + L')'}});
 
-		if (oNewRect.Bottom < oNewRect.Top)
-		{
-			double dTempValue = oNewRect.Top;
-			oNewRect.Top     = oNewRect.Bottom;
-			oNewRect.Bottom  = dTempValue;
-		}
-
-		return oNewRect;
+		std::swap(oFirstClip, oSecondClip);
 	}
 }
 

DesktopEditor/raster/Metafile/Emf/EmfInterpretator/CEmfInterpretatorSvg.h

@@ -226,7 +226,7 @@ namespace MetaFile
 		void SetTransform(double& dM11, double& dM12, double& dM21, double& dM22, double& dX, double& dY) override {};
 		void GetTransform(double* pdM11, double* pdM12, double* pdM21, double* pdM22, double* pdX, double* pdY) override {};
 
-		TRectD TranslateRect(const TRectL &oRect) const;
+		void SwapClips(CSvgClip& oFirstClip, CSvgClip& oSecondClip);
 	};
 }
 

DesktopEditor/raster/Metafile/Emf/EmfObjects.cpp

@@ -155,9 +155,38 @@ namespace MetaFile
 		unHeight = unDibHeigth;
 	}
 
-	CEmfLogFont::CEmfLogFont(bool bFixedLength) : m_bFixedLength(bFixedLength)
+	void CEmfLogBrushEx::GetGradientColors(std::vector<long>& arColors, std::vector<double>& arPositions) const
+	{
+		arColors    = {(long)(GetColor()  + (GetAlpha()  << 24)), (long)(GetColor2() + (GetAlpha2() << 24))};
+		arPositions = {0., 1.};
+	}
+
+	CEmfLogFont::CEmfLogFont(bool bFixedLength)
+	    : m_bFixedLength(bFixedLength)
 	{
 		oDesignVector.pValues = NULL;
+
+		oLogFontEx.oLogFont.nHeight           = DEFAULT_FONT_SIZE;
+		oLogFontEx.oLogFont.nWidth            = 0;
+		oLogFontEx.oLogFont.nEscapement       = 0;
+		oLogFontEx.oLogFont.nOrientation      = 0;
+		oLogFontEx.oLogFont.nWeight           = 400;
+		oLogFontEx.oLogFont.uchItalic         = 0x00;
+		oLogFontEx.oLogFont.uchUnderline      = 0x00;
+		oLogFontEx.oLogFont.uchStrikeOut      = 0x00;
+		oLogFontEx.oLogFont.uchCharSet        = 0x01;
+		oLogFontEx.oLogFont.uchOutPrecision   = 0x00;
+		oLogFontEx.oLogFont.uchClipPrecision  = 0x00;
+		oLogFontEx.oLogFont.uchQuality        = 0x00;
+		oLogFontEx.oLogFont.uchPitchAndFamily = 0x00;
+
+		memset(oLogFontEx.oLogFont.ushFaceName, 0x00, 32);
+
+		oLogFontEx.oLogFont.ushFaceName[0] = 'A';
+		oLogFontEx.oLogFont.ushFaceName[1] = 'r';
+		oLogFontEx.oLogFont.ushFaceName[2] = 'i';
+		oLogFontEx.oLogFont.ushFaceName[3] = 'a';
+		oLogFontEx.oLogFont.ushFaceName[4] = 'l';
 	}
 
 	CEmfLogFont::~CEmfLogFont()
@@ -271,6 +300,16 @@ namespace MetaFile
 		unSize  = 0;
 	}
 
+	const ILineCap* CEmfLogPen::GetStartLineCap() const
+	{
+		return NULL;
+	}
+
+	const ILineCap* CEmfLogPen::GetEndLineCap() const
+	{
+		return NULL;
+	}
+
 	CEmfLogPalette::CEmfLogPalette() : ushNumberOfEntries(0), pPaletteEntries(NULL)
 	{}
 

DesktopEditor/raster/Metafile/Emf/EmfObjects.h

@@ -77,6 +77,8 @@ namespace MetaFile
 		void         GetBounds(double& left, double& top, double& width, double& height) const override;
 		void         GetCenterPoint(double& dX, double& dY) const override;
 		void         GetDibPattern(unsigned char** pBuffer, unsigned int &unWidth, unsigned int &unHeight) const override;
+
+		void GetGradientColors(std::vector<long>& arColors, std::vector<double>& arPositions) const override;
 	public:
 		unsigned int   unBrushStyle;
 		TRGBA          oColor;
@@ -122,13 +124,15 @@ namespace MetaFile
 		virtual EEmfObjectType GetType() const override;
 
 		// IPen
-		int          GetColor()      const override;
-		unsigned int GetStyle()      const override;
-		double       GetWidth()      const override;
-		unsigned int GetAlpha()      const override;
-		double       GetMiterLimit() const override;
-		double       GetDashOffset() const override;
-		void         GetDashData(double*& arDatas, unsigned int& unSize) const override;
+		int             GetColor()        const override;
+		unsigned int    GetStyle()        const override;
+		double          GetWidth()        const override;
+		unsigned int    GetAlpha()        const override;
+		double          GetMiterLimit()   const override;
+		double          GetDashOffset()   const override;
+		void            GetDashData(double*& arDatas, unsigned int& unSize) const override;
+		const ILineCap* GetStartLineCap() const override;
+		const ILineCap* GetEndLineCap()   const override;
 	public:
 		unsigned int  unPenStyle;
 		unsigned int  unWidth;

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

@@ -1659,13 +1659,15 @@ namespace MetaFile
 
 			RestoreDC(-1);
 		}
-		else if (sType == "GDIC")
+		else if (sType == "GDIC" && NULL != m_pInterpretator)
 		{
 			unsigned int unPublicCommentIdentifier;
 
 			m_oStream >> unPublicCommentIdentifier;
 
-			if (EMR_COMMENT_WINDOWS_METAFILE == unPublicCommentIdentifier)
+			// At the moment, we are disabling support for embedded MWF files (in bug #71100 - The plus-minus symbol is not displayed correctly)
+			// From the tests, it became clear that the embedded WMF files are ignored
+			if (EMR_COMMENT_WINDOWS_METAFILE == unPublicCommentIdentifier && false)
 			{
 				m_oStream.Skip(12); // Version, Reserved, Checksum, Flags
 

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

@@ -78,8 +78,8 @@ namespace MetaFile
 		unsigned int ulWidth, ulHeight;
 
 		if (ReadImage(oTEmfStretchDIBITS.unOffBmiSrc, oTEmfStretchDIBITS.unCbBmiSrc,
-					  oTEmfStretchDIBITS.unOffBitsSrc, oTEmfStretchDIBITS.unCbBitsSrc,
-					  sizeof(TEmfStretchDIBITS) + 8, &pBgraBuffer, &ulWidth, &ulHeight))
+		              oTEmfStretchDIBITS.unOffBitsSrc, oTEmfStretchDIBITS.unCbBitsSrc,
+		              sizeof(TEmfStretchDIBITS) + 8, &pBgraBuffer, &ulWidth, &ulHeight))
 		{
 			if (m_pInterpretator)
 			{
@@ -761,7 +761,11 @@ namespace MetaFile
 		RELEASEOBJECT(m_pInterpretator);
 
 		if (InterpretatorType::Svg == oInterpretatorType)
-			m_pInterpretator = new CEmfInterpretatorSvg(this, dWidth, dHeight);
+		{
+			CEmfInterpretatorSvg *pEmfInterpretatorSvg = new CEmfInterpretatorSvg(this, dWidth, dHeight);
+			pEmfInterpretatorSvg->SetShapeRendering(EShapeRendering::CrispEdges);
+			m_pInterpretator = pEmfInterpretatorSvg;
+		}
 	}
 
 	CEmfInterpretatorBase* CEmfParserBase::GetInterpretator()
@@ -1505,11 +1509,19 @@ namespace MetaFile
 		if (NULL != m_pInterpretator && (NULL == m_pPath || Svg != m_pInterpretator->GetType()))
 			m_pInterpretator->HANDLE_EMR_PIE(oBox, oStart, oEnd);
 
-		double dStartAngle = GetEllipseAngle(oBox.Left, oBox.Top, oBox.Right, oBox.Bottom, oStart.X, oStart.Y);
-		double dSweepAngle = GetEllipseAngle(oBox.Left, oBox.Top, oBox.Right, oBox.Bottom, oEnd.X, oEnd.Y) - dStartAngle;
+		const int nCenterX = (oBox.Left + oBox.Right) / 2;
+		const int nCenterY = (oBox.Top + oBox.Bottom) / 2;
 
-		ArcTo(oBox.Left, oBox.Top, oBox.Right, oBox.Bottom, dStartAngle, dSweepAngle);
-		LineTo((oBox.Left + oBox.Right) / 2, (oBox.Top + oBox.Bottom) / 2);
+		double dStartAngle = std::atan2(oStart.Y - nCenterY, oStart.X - nCenterX);
+		double dEndAngle   = std::atan2(oEnd.Y   - nCenterY, oEnd.X   - nCenterX);
+
+		if (dEndAngle > dStartAngle)
+			dEndAngle -= 2 * M_PI;
+
+		MoveTo(nCenterX, nCenterY);
+		LineTo(oStart.X, oStart.Y);
+		ArcTo(oBox.Left, oBox.Top, oBox.Right, oBox.Bottom, dStartAngle * 180. / M_PI, (dEndAngle - dStartAngle) * 180. / M_PI);
+		LineTo(nCenterX, nCenterY);
 		ClosePath();
 		DrawPath(true, true);
 	}

DesktopEditor/raster/Metafile/Emf/EmfParser/CEmfParserBase.h

@@ -25,7 +25,7 @@
 #include  <algorithm>
 #include <cstdlib>
 
-#define LOG_EMF_RECORDS 0
+#define LOG_EMF_RECORDS 1
 
 #ifdef LOG_EMF_RECORDS
 	#if 1 == LOG_EMF_RECORDS

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

@@ -655,20 +655,18 @@ namespace MetaFile
 
 				m_oStream >> unPositionCount;
 
-				std::vector<double> arBlendPositions(unPositionCount);
-
-				for (unsigned int unIndex = 0; unIndex <  unPositionCount; ++unIndex)
-					m_oStream >> arBlendPositions[unIndex];
-
-				std::vector<TEmfPlusARGB> arBlendColors(unPositionCount);
-
-				for (unsigned int unIndex = 0; unIndex <  unPositionCount; ++unIndex)
-					m_oStream >> arBlendColors[unIndex];
-
-				if (1 < unPositionCount)
+				if (unPositionCount > 1)
 				{
-					pEmfPlusBrush->oColorBack = arBlendColors[0];
-					pEmfPlusBrush->oColor     = arBlendColors.back();
+					pEmfPlusBrush->arGradientColors.resize(unPositionCount);
+
+					for (unsigned int unIndex = 0; unIndex < unPositionCount; ++unIndex)
+						m_oStream >> pEmfPlusBrush->arGradientColors[unIndex].second;
+
+					for (unsigned int unIndex = 0; unIndex < unPositionCount; ++unIndex)
+						m_oStream >> pEmfPlusBrush->arGradientColors[unIndex].first;
+
+					pEmfPlusBrush->oColor = pEmfPlusBrush->arGradientColors[unPositionCount - 1].first;
+					pEmfPlusBrush->oColorBack = pEmfPlusBrush->arGradientColors[0].first;
 				}
 			}
 
@@ -679,13 +677,40 @@ namespace MetaFile
 			//TODO: реализовать
 			pEmfPlusBrush->unStyle = BS_LINEARGRADIENT;
 
-			m_oStream.Skip(8); // BrushDataFlags, WrapMode
+			int nBrushDataFlags;
+			m_oStream >> nBrushDataFlags;
+
+			m_oStream.Skip(4); // WrapMode
 
 			//				m_oStream >> pEmfPlusBrush->RectF;
 			m_oStream.Skip(16);
 			m_oStream >> pEmfPlusBrush->oColor;
 			m_oStream >> pEmfPlusBrush->oColorBack;
 
+			m_oStream.Skip(8); // Reserved1, Reserved2
+
+			if (BrushDataTransform & nBrushDataFlags)
+			{
+				m_oStream.Skip(24);
+			}
+
+			if (BrushDataPresetColors & nBrushDataFlags)
+			{
+				int nPositionCount;
+				m_oStream >> nPositionCount;
+
+				if (nPositionCount > 1)
+				{
+					pEmfPlusBrush->arGradientColors.resize(nPositionCount);
+
+					for (unsigned int unIndex = 0; unIndex < nPositionCount; ++unIndex)
+						m_oStream >> pEmfPlusBrush->arGradientColors[unIndex].second;
+
+					for (unsigned int unIndex = 0; unIndex < nPositionCount; ++unIndex)
+						m_oStream >> pEmfPlusBrush->arGradientColors[unIndex].first;
+				}
+			}
+
 			break;
 		}
 		default:
@@ -2266,16 +2291,21 @@ namespace MetaFile
 			if (NULL != pEmfPlusPen->pBrush)
 				m_pDC->SetBrush(pEmfPlusPen->pBrush);
 
-			CPathConverter oPathConverter;
-			CPath oNewPath, oLineCapPath;
-
-			oPathConverter.GetUpdatedPath(oNewPath, oLineCapPath, *pPath, *pEmfPlusPen);
-
-			oNewPath.DrawOn(m_pInterpretator, true, false);
-			oLineCapPath.DrawOn(m_pInterpretator, false, true);
-
 			if (NULL != m_pInterpretator)
-				m_pInterpretator->HANDLE_EMFPLUS_DRAWPATH(shOgjectIndex, unPenId, &oNewPath);
+			{
+				CPathConverter oPathConverter;
+				CPath oNewPath, oLineCapPath;
+
+				oPathConverter.GetUpdatedPath(oNewPath, oLineCapPath, *pPath, *pEmfPlusPen);
+
+				if (InterpretatorType::Render == m_pInterpretator->GetType())
+				{
+					oNewPath.DrawOn(m_pInterpretator, true, false);
+					oLineCapPath.DrawOn(m_pInterpretator, false, true);
+				}
+				else
+					m_pInterpretator->HANDLE_EMFPLUS_DRAWPATH(shOgjectIndex, unPenId, pPath);
+			}
 
 			if (NULL != pEmfPlusPen->pBrush)
 				m_pDC->RemoveBrush(pEmfPlusPen->pBrush);
@@ -3126,7 +3156,6 @@ namespace MetaFile
 		m_oStream >> oMatrix;
 
 		m_pDC->MultiplyTransform(oMatrix, (unShFlags & 0x2000) ? MWT_RIGHTMULTIPLY : MWT_LEFTMULTIPLY);
-		UpdateOutputDC();
 	}
 
 	void CEmfPlusParser::Read_EMFPLUS_RESETWORLDTRANSFORM()
@@ -3134,7 +3163,6 @@ namespace MetaFile
 		m_bBanEmfProcessing = true;
 
 		m_pDC->ResetTransform();
-		UpdateOutputDC();
 	}
 
 	void CEmfPlusParser::Read_EMFPLUS_ROTATEWORLDTRANSFORM(unsigned short unShFlags)
@@ -3153,7 +3181,6 @@ namespace MetaFile
 		TEmfPlusXForm oMatrix(dCosTheta, dSinTheta, -dSinTheta, dCosTheta, 0, 0);
 
 		m_pDC->MultiplyTransform(oMatrix, (unShFlags & 0x2000) ? MWT_RIGHTMULTIPLY : MWT_LEFTMULTIPLY);
-		UpdateOutputDC();
 	}
 
 	void CEmfPlusParser::Read_EMFPLUS_SCALEWORLDTRANSFORM(unsigned short unShFlags)
@@ -3168,7 +3195,6 @@ namespace MetaFile
 		TEmfPlusXForm oMatrix(dSx, 0, 0, dSy, 0, 0);
 
 		m_pDC->MultiplyTransform(oMatrix, (unShFlags & 0x2000) ? MWT_RIGHTMULTIPLY : MWT_LEFTMULTIPLY);
-		UpdateOutputDC();
 	}
 
 	void CEmfPlusParser::Read_EMFPLUS_SETPAGETRANSFORM(unsigned short unShFlags)
@@ -3185,8 +3211,6 @@ namespace MetaFile
 
 		TEmfPlusXForm oUnitKoefMatrix(m_dPageTransformX, 0, 0, m_dPageTransformY, 0, 0);
 		m_pDC->MultiplyTransform(oUnitKoefMatrix, MWT_LEFTMULTIPLY);
-
-		UpdateOutputDC();
 	}
 
 	void CEmfPlusParser::Read_EMFPLUS_SETWORLDTRANSFORM()
@@ -3196,11 +3220,8 @@ namespace MetaFile
 		m_oStream >> oMatrix;
 
 		m_pDC->MultiplyTransform(oMatrix, MWT_SET);
-
 		TEmfPlusXForm oUnitKoefMatrix(m_dPageTransformX, 0, 0, m_dPageTransformY, 0, 0);
 		m_pDC->MultiplyTransform(oUnitKoefMatrix, MWT_LEFTMULTIPLY);
-
-		UpdateOutputDC();
 	}
 
 	void CEmfPlusParser::Read_EMFPLUS_TRANSLATEWORLDTRANSFORM(unsigned short unShFlags)
@@ -3213,7 +3234,6 @@ namespace MetaFile
 		TEmfPlusXForm oMatrix(1, 0, 0, 1, dX, dY);
 
 		m_pDC->MultiplyTransform(oMatrix, (unShFlags & 0x2000) ? MWT_RIGHTMULTIPLY : MWT_LEFTMULTIPLY);
-		UpdateOutputDC();
 	}
 
 	void CEmfPlusParser::Read_EMFPLUS_ENDOFFILE()

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

@@ -27,7 +27,6 @@ namespace MetaFile
 
 		void   SetStream(BYTE *pBytes, unsigned int unSize);
 		bool   GetBanEMFProcesses();
-
 	private:
 		void RegisterObject(CEmfPlusObject* pObject, unsigned int unIndex);
 

DesktopEditor/raster/Metafile/Emf/EmfPlayer.cpp

@@ -728,7 +728,7 @@ namespace MetaFile
 		m_oFinalTransform.Multiply(oWindowXForm, MWT_RIGHTMULTIPLY);
 
 		m_oFinalTransform2.Init();
-		m_oFinalTransform2.Multiply(m_oTransform, MWT_RIGHTMULTIPLY);
+		// m_oFinalTransform2.Multiply(m_oTransform, MWT_RIGHTMULTIPLY);
 		m_oFinalTransform2.Multiply(oViewportXForm, MWT_RIGHTMULTIPLY);
 		m_oFinalTransform2.Multiply(oWindowXForm, MWT_RIGHTMULTIPLY);
 	}

DesktopEditor/raster/Metafile/Emf/EmfPlusObjects.cpp

@@ -79,6 +79,26 @@ namespace MetaFile
 		height = oRectF.dHeight;
 	}
 
+	void CEmfPlusBrush::GetGradientColors(std::vector<long>& arColors, std::vector<double>& arPositions) const
+	{
+		if (arGradientColors.empty())
+		{
+			arColors    = {(long)(GetColor()  + (GetAlpha()  << 24)), (long)(GetColor2() + (GetAlpha2() << 24))};
+			arPositions = {0., 1.};
+
+			return;
+		}
+
+		arColors.resize(arGradientColors.size());
+		arPositions.resize(arGradientColors.size());
+
+		for (unsigned int unIndex = 0; unIndex < arGradientColors.size(); ++unIndex)
+		{
+			arColors[unIndex] = METAFILE_RGBA(arGradientColors[unIndex].first.chRed, arGradientColors[unIndex].first.chGreen, arGradientColors[unIndex].first.chBlue, arGradientColors[unIndex].first.chAlpha);
+			arPositions[unIndex] = arGradientColors[unIndex].second;
+		}
+	}
+
 	CEmfPlusPen::CEmfPlusPen()
 		: unStyle(PS_SOLID | PS_GEOMETRIC | PS_STARTCAP_FLAT | PS_ENDCAP_FLAT | PS_JOIN_MITER), dWidth(1), oColor(0, 0, 0),
 		  pBrush(NULL), dMiterLimit(0), dDashOffset(0),
@@ -90,7 +110,7 @@ namespace MetaFile
 		RELEASEOBJECT(pBrush)
 		RELEASEARRAYOBJECTS(pDataDash)
 		RELEASEOBJECT(pLineStartCapData)
-				RELEASEOBJECT(pLineEndCapData)
+		RELEASEOBJECT(pLineEndCapData)
 	}
 
 	EEmfObjectType CEmfPlusPen::GetType() const
@@ -148,6 +168,16 @@ namespace MetaFile
 		unSize  = unSizeDash;
 	}
 
+	const ILineCap* CEmfPlusPen::GetStartLineCap() const
+	{
+		return pLineStartCapData;
+	}
+
+	const ILineCap* CEmfPlusPen::GetEndLineCap() const
+	{
+		return pLineEndCapData;
+	}
+
 	CEmfPlusFont::CEmfPlusFont()
 		: m_dEmSize(18), m_unSizeUnit(0), m_bBold(false),
 		  m_bItalic(false), m_bUnderline(false), m_bStrikeout(false),

DesktopEditor/raster/Metafile/Emf/EmfPlusObjects.h

@@ -189,6 +189,7 @@ namespace MetaFile
 		void         GetCenterPoint(double& dX, double& dY) const override;
 		void         GetBounds(double& left, double& top, double& width, double& height) const override;
 
+		void GetGradientColors(std::vector<long>& arColors, std::vector<double>& arPositions) const override;
 	public:
 		TEmfPlusARGB   oColor;
 		TEmfPlusARGB   oColorBack;
@@ -198,6 +199,8 @@ namespace MetaFile
 		TEmfPlusPointF oCenterPoint;
 		unsigned int   unAngle;
 		std::wstring   wsDibPatternPath;
+
+		std::vector<std::pair<TEmfPlusARGB, double>> arGradientColors;
 	};
 
 	class CEmfPlusPen: public CEmfPlusObject, public IPen
@@ -209,14 +212,15 @@ namespace MetaFile
 		virtual EEmfPlusObjectType GetObjectType() const override;
 
 		// IPen
-		int          GetColor()      const override;
-		unsigned int GetStyle()      const override;
-		double       GetWidth()      const override;
-		unsigned int GetAlpha()      const override;
-		double       GetMiterLimit() const override;
-		double       GetDashOffset() const override;
-		void         GetDashData(double*& arDatas, unsigned int& unSize) const override;
-
+		int             GetColor()        const override;
+		unsigned int    GetStyle()        const override;
+		double          GetWidth()        const override;
+		unsigned int    GetAlpha()        const override;
+		double          GetMiterLimit()   const override;
+		double          GetDashOffset()   const override;
+		void            GetDashData(double*& arDatas, unsigned int& unSize) const override;
+		const ILineCap* GetStartLineCap() const override;
+		const ILineCap* GetEndLineCap()   const override;
 	public:
 		unsigned int   unStyle;
 		double         dWidth;

DesktopEditor/raster/Metafile/Emf/EmfPlusTypes.h

@@ -2,6 +2,7 @@
 #define EMFPLUSTYPES_H
 
 #include "EmfTypes.h"
+#include "../Common/MetaFileObjects.h"
 
 namespace MetaFile
 {
@@ -243,7 +244,7 @@ namespace MetaFile
 		CustomLineCapDataLinePath = 0x00000002
 	} CustomLineCapDataFlags;
 
-	class CLineCapData
+	class CLineCapData : public ILineCap
 	{
 	public:
 		CLineCapData() {};