new version!!!

git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@59491 954022d7-b5bf-4e40-9824-e11837661b57

DoctRenderer/DoctRenderer.h

@@ -7,6 +7,38 @@
 
 #include "../../../../../../Common/TimeMeasurer.h"
 
+#ifdef _DEBUG
+#define _LOG_ERRORS_TO_FILE_
+#endif
+
+// TEST!!!
+#define _LOG_ERRORS_TO_FILE_
+
+#ifdef _LOG_ERRORS_TO_FILE_
+
+void __log_error_(const CString& strType, const CString& strError)
+{
+	FILE* f = fopen("C:\\doct_renderer_errors.txt", "a+");
+
+	CStringA sT = (CStringA)strType;
+	fprintf(f, sT.GetBuffer());
+	fprintf(f, ": ");
+
+	CStringA s = (CStringA)strError;
+	fprintf(f, s.GetBuffer());
+	fprintf(f, "\n");
+	fclose(f);
+}
+
+#define _LOGGING_ERROR_(type, err) __log_error_(type, err);
+
+#else
+
+#define _LOGGING_ERROR_(type, err)
+
+#endif
+
+
 #pragma comment(lib, "ws2_32.lib")
 #pragma comment(lib, "winmm.lib")
 
@@ -365,6 +397,9 @@ public:
 		if (m_strEditorType == _T("spreadsheet"))
 			strScript += _T("\n$.ready();");
 
+		CTimeMeasurer oMeasurer;
+		oMeasurer.Reset();
+
 		CString strError = _T("");
 		BOOL bResult = ExecuteScript(strScript, strError);
 
@@ -374,6 +409,11 @@ public:
 			*pbsError = sDestError.AllocSysString();
 		}
 
+		int nTime = (int)(1000 * oMeasurer.GetTimeInterval());
+		CString strTime = _T("");
+		strTime.Format(_T("%d"), nTime);
+		_LOGGING_ERROR_(L"time_changes", strTime);
+
 		return bResult ? S_OK : S_FALSE;
 	}
 
@@ -534,7 +574,8 @@ private:
 			CString strCode = to_cstring(try_catch.Message()->GetSourceLine());
 			strException = to_cstring(try_catch.Message()->Get());
 
-			CStringA ss = (CStringA)strException;
+			_LOGGING_ERROR_(L"compile", strException)
+
 			strError = _T("code=\"compile\"");
 			return FALSE;
 		}
@@ -546,6 +587,8 @@ private:
 			CString strCode = to_cstring(try_catch.Message()->GetSourceLine());
 			strException = to_cstring(try_catch.Message()->Get());
 
+			_LOGGING_ERROR_(L"run", strException)
+
 			strError = _T("code=\"run\"");
 			return FALSE;
 		}
@@ -556,14 +599,26 @@ private:
 		args[0] = v8::Int32::New(isolate, 0);
 
 		// all
+#if 0
 		v8::Handle<v8::Value> js_func_open			= global_js->Get(v8::String::NewFromUtf8(isolate, "NativeOpenFile"));
+#else
+		v8::Handle<v8::Value> js_func_open			= global_js->Get(v8::String::NewFromUtf8(isolate, "NativeOpenFileData"));
+#endif
 		v8::Handle<v8::Value> js_func_id			= global_js->Get(v8::String::NewFromUtf8(isolate, "GetNativeId"));
 
 		// changes
+#if 0
 		v8::Handle<v8::Value> js_func_apply_changes	= global_js->Get(v8::String::NewFromUtf8(isolate, "NativeApplyChanges"));
+#else
+		v8::Handle<v8::Value> js_func_apply_changes = global_js->Get(v8::String::NewFromUtf8(isolate, "NativeApplyChangesData"));
+#endif
 
 		// save T format
+#if 0
 		v8::Handle<v8::Value> js_func_get_file_s	= global_js->Get(v8::String::NewFromUtf8(isolate, "NativeGetFileString"));
+#else
+		v8::Handle<v8::Value> js_func_get_file_s	= global_js->Get(v8::String::NewFromUtf8(isolate, "NativeGetFileData"));		
+#endif
 
 		// pdf
 		v8::Handle<v8::Value> js_func_calculate		= global_js->Get(v8::String::NewFromUtf8(isolate, "NativeCalculateFile"));
@@ -625,22 +680,112 @@ private:
 
 		pNative->m_nMaxChangesNumber	= m_oParams.m_nCountChangesItems;
 
-		if (js_func_open->IsFunction()) 
+#if 1
+
+		if (js_func_open->IsFunction())
+		{
+			v8::Handle<v8::Function> func_open = v8::Handle<v8::Function>::Cast(js_func_open);
+
+			CChangesWorker oWorkerLoader;
+			int nVersion = oWorkerLoader.OpenNative(pNative->GetFilePath());
+
+			v8::Handle<v8::Value> args_changes[2];
+			args_changes[0] = oWorkerLoader.GetDataFull();
+			args_changes[1] = v8::Integer::New(isolate, nVersion);
+
+			func_open->Call(global_js, 2, args_changes);
+
+			if (try_catch.HasCaught())
+			{
+				CString strCode = to_cstring(try_catch.Message()->GetSourceLine());
+				strException = to_cstring(try_catch.Message()->Get()); //  ?  
+
+				_LOGGING_ERROR_(L"open", strException)
+					strError = _T("code=\"open\"");
+				return FALSE;
+			}
+		}		
+
+#else
+
+		if (js_func_open->IsFunction())
 		{
 			v8::Handle<v8::Function> func_open = v8::Handle<v8::Function>::Cast(js_func_open);
 
 			func_open->Call(global_js, 1, args);
-			
-			if (try_catch.HasCaught()) 
+
+			if (try_catch.HasCaught())
 			{
 				CString strCode = to_cstring(try_catch.Message()->GetSourceLine());
 				strException = to_cstring(try_catch.Message()->Get()); //  ?  
 
+				_LOGGING_ERROR_(L"open", strException)
 				strError = _T("code=\"open\"");
 				return FALSE;
 			}
 		}
 
+#endif
+
+#if 1
+
+		if (m_oParams.m_arChanges.GetCount() != 0)
+		{
+			//CTimeMeasurer oMeasurer;
+			//oMeasurer.Reset();
+
+			int nCurrentIndex = 0;
+			CChangesWorker oWorker;
+
+			int nFileType = 0;
+			if (m_strEditorType == _T("spreadsheet"))
+				nFileType = 1;
+
+			oWorker.SetFormatChanges(nFileType);
+			oWorker.CheckFiles(m_oParams.m_arChanges);
+
+			while (true)
+			{
+				nCurrentIndex = oWorker.Open(m_oParams.m_arChanges, nCurrentIndex);
+				bool bIsFull = (nCurrentIndex == m_oParams.m_arChanges.GetCount()) ? true : false;
+
+				if (js_func_apply_changes->IsFunction())
+				{
+					v8::Handle<v8::Function> func_apply_changes = v8::Handle<v8::Function>::Cast(js_func_apply_changes);
+					v8::Handle<v8::Value> args_changes[2];
+					args_changes[0] = oWorker.GetData();
+					args_changes[1] = v8::Boolean::New(isolate, bIsFull);
+
+					func_apply_changes->Call(global_js, 2, args_changes);
+
+					if (try_catch.HasCaught())
+					{
+						int nLineError = try_catch.Message()->GetLineNumber();
+						CString strCode = to_cstring(try_catch.Message()->GetSourceLine());
+						strException = to_cstring(try_catch.Message()->Get()); //  ?  
+
+						_LOGGING_ERROR_(L"change_code", strCode)
+						_LOGGING_ERROR_(L"change", strException)
+
+						strError = _T("");
+						strError.Format(_T("index=\"%d\""), pNative->m_nCurrentChangesNumber);
+						return FALSE;
+					}
+				}
+
+				if (bIsFull)
+					break;
+			}
+			
+			//int nTime = (oMeasurer.GetTimeInterval() * 1000);
+			//CString strTime = _T("");
+			//strTime.Format(_T("%d"), nTime);
+			//_LOGGING_ERROR_(L"time_changes", strTime);
+			
+		}
+
+#else
+
 		if (m_oParams.m_arChanges.GetCount() != 0)
 		{
 			if (js_func_apply_changes->IsFunction()) 
@@ -654,6 +799,9 @@ private:
 					CString strCode = to_cstring(try_catch.Message()->GetSourceLine());
 					strException = to_cstring(try_catch.Message()->Get()); //  ?  
 
+					_LOGGING_ERROR_(L"change_code", strCode)
+					_LOGGING_ERROR_(L"change", strException)
+
 					strError = _T("");
 					strError.Format(_T("index=\"%d\""), pNative->m_nCurrentChangesNumber);
 					return FALSE;
@@ -661,12 +809,56 @@ private:
 			}
 		}
 
+#endif
+
 		switch (m_oParams.m_eDstFormat)
 		{
 		case DoctRendererFormat::DOCT:
 		case DoctRendererFormat::PPTT:
 		case DoctRendererFormat::XLST:
 			{
+#if 1
+				if (js_func_get_file_s->IsFunction())
+				{
+					v8::Handle<v8::Function> func_get_file_s = v8::Handle<v8::Function>::Cast(js_func_get_file_s);
+					v8::Local<v8::Value> js_result2 = func_get_file_s->Call(global_js, 1, args);
+
+					if (try_catch.HasCaught()) 
+					{
+						int nLineError = try_catch.Message()->GetLineNumber();
+						CString strCode = to_cstring(try_catch.Message()->GetSourceLine());
+						strException = to_cstring(try_catch.Message()->Get()); //  ?  
+
+						strError = _T("code=\"save\"");
+
+						_LOGGING_ERROR_(L"save", strException)
+
+						return FALSE;
+					}
+
+					v8::Local<v8::Uint8Array> pArray = v8::Local<v8::Uint8Array>::Cast(js_result2);
+					BYTE* pData = (BYTE*)pArray->Buffer()->Externalize().Data();
+
+					CFile oFile;
+					if (S_OK == oFile.CreateFile(m_oParams.m_strDstFilePath))
+					{
+						oFile.WriteFile((void*)pNative->m_sHeader.GetBuffer(), (DWORD)pNative->m_sHeader.GetLength());
+
+						int nLen64 = Base64EncodeGetRequiredLength((DWORD)pNative->m_nSaveBinaryLen, ATL_BASE64_FLAG_NOCRLF);
+						char* pDst64 = new char[nLen64];
+						int nDstLen = nLen64;
+						Base64Encode(pData, pNative->m_nSaveBinaryLen, pDst64, &nDstLen, ATL_BASE64_FLAG_NOCRLF);
+
+						oFile.WriteFile((void*)pDst64, (DWORD)nDstLen);
+
+						RELEASEARRAYOBJECTS(pDst64);
+
+						oFile.CloseFile();
+						return TRUE;
+					}
+				}
+#else
+
 				if (js_func_get_file_s->IsFunction()) 
 				{
 					v8::Handle<v8::Function> func_get_file_s = v8::Handle<v8::Function>::Cast(js_func_get_file_s);
@@ -679,6 +871,9 @@ private:
 						strException = to_cstring(try_catch.Message()->Get()); //  ?  
 
 						strError = _T("code=\"save\"");
+
+						_LOGGING_ERROR_(L"save", strException)
+
 						return FALSE;
 					}
 
@@ -691,6 +886,8 @@ private:
 						return TRUE;
 					}
 				}
+
+#endif
 				break;
 			}
 		case DoctRendererFormat::PDF:
@@ -707,6 +904,9 @@ private:
 						strException = to_cstring(try_catch.Message()->Get()); //  ?  
 
 						strError = _T("code=\"calculate\"");
+
+						_LOGGING_ERROR_(L"calculate", strException)
+
 						return FALSE;
 					}
 				}
@@ -759,6 +959,8 @@ private:
 							CString strCode = to_cstring(try_catch.Message()->GetSourceLine());
 							strException = to_cstring(try_catch.Message()->Get()); //  ?  
 
+							_LOGGING_ERROR_(L"render", strException)
+
 							strError = _T("code=\"render\"");
 							return FALSE;
 						}
@@ -785,7 +987,10 @@ private:
 					RELEASEINTERFACE(pPDF);
 
 					if (S_OK != hr)
+					{
+						_LOGGING_ERROR_(L"save", L"pdfsave")
 						strError = _T("code=\"save\"");
+					}
 
 					return (hr == S_OK) ? TRUE : FALSE;
 				}

DoctRenderer/DoctRenderer.sln

 
-Microsoft Visual Studio Solution File, Format Version 10.00
-# Visual Studio 2008
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DoctRenderer", "DoctRenderer.vcproj", "{BC0A8A11-2017-473D-8AB1-86A55116A2F5}"
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Express 2013 for Windows Desktop
+VisualStudioVersion = 12.0.21005.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DoctRenderer", "DoctRenderer.vcxproj", "{BC0A8A11-2017-473D-8AB1-86A55116A2F5}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution

DoctRenderer/DoctRenderer.vcproj

@@ -52,6 +52,7 @@
 			<Tool
 				Name="VCCLCompilerTool"
 				Optimization="0"
+				AdditionalIncludeDirectories=""
 				PreprocessorDefinitions="WIN32;_WINDOWS;_DEBUG;_USRDLL;_ATL_ATTRIBUTES"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"

DoctRenderer/NativeControl.h

@@ -37,6 +37,12 @@ public:
 	int m_nCurrentChangesNumber;
 	int m_nMaxChangesNumber;
 
+	BYTE* m_pSaveBinary;
+	int m_nSaveLen;
+	
+	int m_nSaveBinaryLen;
+	CStringA m_sHeader;
+
 public:
 	CMemoryStream* m_pStream;
 
@@ -47,11 +53,51 @@ public:
 
 		m_nCurrentChangesNumber = -1;
 		m_nMaxChangesNumber = -1;
+
+		m_pSaveBinary = NULL;
+		m_nSaveLen = 0;
+		m_nSaveBinaryLen = 0;
 	}
 	~CNativeControl()
 	{
 		RELEASEOBJECT(m_pStream);
 		m_pChanges = NULL;
+
+		RELEASEARRAYOBJECTS(m_pSaveBinary);
+		m_nSaveLen = 0;
+	}
+
+public:
+
+	void Save_Alloc(int nLen)
+	{
+		m_nSaveLen = nLen;
+		m_pSaveBinary = new BYTE[m_nSaveLen];
+		memset(m_pSaveBinary, 0xFF, m_nSaveLen);
+	}
+
+	void Save_ReAlloc(int pos, int len)
+	{
+		BYTE* pOld = m_pSaveBinary;
+		m_nSaveLen = len;
+		m_pSaveBinary = new BYTE[m_nSaveLen];
+		
+		memcpy(m_pSaveBinary, pOld, pos);
+
+		RELEASEARRAYOBJECTS(pOld);
+	}
+
+	void Save_End(CStringA sHeader, int len)
+	{		
+		m_sHeader = sHeader;
+		m_nSaveBinaryLen = len;
+	}
+
+	void Save_Destroy()
+	{
+		RELEASEARRAYOBJECTS(m_pSaveBinary);
+		m_nSaveLen = 0;
+		m_nSaveBinaryLen = 0;
 	}
 
 public:	
@@ -247,6 +293,53 @@ void _GetFileString(const v8::FunctionCallbackInfo<v8::Value>& args)
 	args.GetReturnValue().Set(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), (char*)pData, v8::String::kNormalString, len));
 }
 
+void _Save_AllocNative(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+	args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
+	if (args.Length() < 1)
+		return;
+
+	CNativeControl* pNative = unwrap_nativeobject(args.This());
+	v8::Local<v8::Int32> intValue = args[0]->ToInt32();
+	int nLen = (int)intValue->Value();
+	
+	pNative->Save_Alloc(nLen);
+
+	v8::Local<v8::ArrayBuffer> _buffer = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), (void*)pNative->m_pSaveBinary, (size_t)pNative->m_nSaveLen);
+	v8::Local<v8::Uint8Array> _array = v8::Uint8Array::New(_buffer, 0, (size_t)pNative->m_nSaveLen);
+	args.GetReturnValue().Set(_array);
+}
+
+void _Save_ReAllocNative(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+	args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
+	if (args.Length() < 2)
+		return;
+
+	CNativeControl* pNative = unwrap_nativeobject(args.This());
+	int _pos = args[0]->Int32Value();
+	int _len = args[1]->Int32Value();
+	
+	pNative->Save_ReAlloc(_pos, _len);
+
+	v8::Local<v8::ArrayBuffer> _buffer = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), (void*)pNative->m_pSaveBinary, (size_t)pNative->m_nSaveLen);
+	v8::Local<v8::Uint8Array> _array = v8::Uint8Array::New(_buffer, 0, (size_t)pNative->m_nSaveLen);
+	args.GetReturnValue().Set(_array);
+}
+
+void _Save_End(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+	args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
+	if (args.Length() < 2)
+		return;
+
+	CNativeControl* pNative = unwrap_nativeobject(args.This());
+	CStringA sHeader = to_cstringA(args[0]);
+	int _len = args[1]->Int32Value();
+
+	pNative->Save_End(sHeader, _len);
+}
+
 void _ConsoleLog(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
 	args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
@@ -282,6 +375,10 @@ v8::Handle<v8::ObjectTemplate> CreateNativeControlTemplate(v8::Isolate* isolate)
 	result->Set(v8::String::NewFromUtf8(current, "GetCountChanges"), v8::FunctionTemplate::New(current, _GetChangesCount));
 	result->Set(v8::String::NewFromUtf8(current, "GetChangesFile"), v8::FunctionTemplate::New(current, _GetChangesFile));
 
+	result->Set(v8::String::NewFromUtf8(current, "Save_AllocNative"), v8::FunctionTemplate::New(current, _Save_AllocNative));
+	result->Set(v8::String::NewFromUtf8(current, "Save_ReAllocNative"), v8::FunctionTemplate::New(current, _Save_ReAllocNative));
+	result->Set(v8::String::NewFromUtf8(current, "Save_End"), v8::FunctionTemplate::New(current, _Save_End));
+
 	result->Set(v8::String::NewFromUtf8(current, "ConsoleLog"), v8::FunctionTemplate::New(current, _ConsoleLog));
 
 	//     ,       HandleScope     
@@ -490,4 +587,520 @@ enum CommandType
     ctPageEnd                       = 203,
 
     ctError						    = 255
-};
\ No newline at end of file
+};
+
+class CChangesWorker
+{
+private:
+	BYTE*	m_pData;
+	BYTE*	m_pDataCur;
+	int		m_nLen;
+
+	int		m_nMaxUnionSize = 100 * 1024 * 1024; // 100Mb
+	v8::Local<v8::ArrayBuffer> m_oArrayBuffer;
+
+	int		m_nFileType; // 0 - docx; 1 - excel
+
+public:
+	CChangesWorker()
+	{
+		m_pData = NULL;
+		m_pDataCur = m_pData;
+		m_nLen = 0;
+
+		m_nFileType = 0;
+	}
+	~CChangesWorker()
+	{
+		if (NULL != m_pData)
+			delete[] m_pData;
+	}
+
+	void SetFormatChanges(const int& nFileType)
+	{
+		m_nFileType = nFileType;
+	}
+
+public:	
+
+	void CheckFiles(CAtlArray<CString>& oFiles)
+	{
+		int nMax = 0;
+		int nLen = 0;
+
+		int nCount = (int)oFiles.GetCount();
+		for (int i = 0; i < nCount; ++i)
+		{
+			CFile oFile;
+			oFile.OpenFile(oFiles[i]);
+
+			int nSize = (int)oFile.GetFileSize();
+
+			if (nMax < nSize)
+				nMax = nSize;
+
+			nLen += nSize;
+			oFile.CloseFile();
+		}
+
+		if (nLen <= m_nMaxUnionSize)
+		{
+			//   -   
+			m_nLen = nLen + 4;
+		}
+		else
+		{
+			m_nLen = nMax + 4;
+			if (m_nLen < m_nMaxUnionSize)
+				m_nLen = m_nMaxUnionSize;
+		}
+
+		m_pData = new BYTE[m_nLen];
+		m_pDataCur = m_pData;
+
+		m_oArrayBuffer = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), (void*)m_pData, (size_t)m_nLen);
+	}
+
+	inline int Open(CAtlArray<CString>& oFiles, int nStart)
+	{
+		if (m_nFileType == 0)
+			return Open_docx(oFiles, nStart);
+		return Open_excel(oFiles, nStart);
+	}
+
+	int Open_docx(CAtlArray<CString>& oFiles, int nStart)
+	{
+		m_pDataCur += 4;
+		int nCountData = 0;
+
+		int nCount = oFiles.GetCount();
+		int nLenCurrect = 0;
+		int i = nStart;
+		for (; i < nCount; i++)
+		{
+			CFile oFile;
+			oFile.OpenFile(oFiles[i]);
+
+			int nLen = (int)oFile.GetFileSize();
+			nLenCurrect += nLen;
+
+			if (nLenCurrect > m_nLen)
+				break;
+
+			char* pData = new char[nLen];
+
+			oFile.ReadFile((BYTE*)pData, nLen);
+
+			// parse data
+			int nCur = 0;
+			while (nCur < nLen)
+			{
+				// Id
+				skip_name(pData, nCur, nLen);
+				if (nCur >= nLen)
+					break;
+
+				int nId = read_int(pData, nCur, nLen);
+				*((int*)m_pDataCur) = nId;
+				m_pDataCur += 4;
+
+				// data
+				skip_name(pData, nCur, nLen);
+				skip_int2(pData, nCur, nLen);
+
+				read_base64(pData, nCur, nLen);
+				++nCur;
+
+				++nCountData;
+			}
+
+			delete[]pData;
+		}
+
+		*((int*)m_pData) = nCountData;
+		return i;
+	}
+
+	int Open_excel(CAtlArray<CString>& oFiles, int nStart)
+	{
+		m_pDataCur += 4;
+		int nCountData = 0;
+
+		int nCount = oFiles.GetCount();
+		int nLenCurrect = 0;
+		int i = nStart;
+		for (; i < nCount; i++)
+		{
+			CFile oFile;
+			oFile.OpenFile(oFiles[i]);
+
+			int nLen = (int)oFile.GetFileSize();
+			nLenCurrect += nLen;
+
+			if (nLenCurrect > m_nLen)
+				break;
+
+			char* pData = new char[nLen];
+
+			oFile.ReadFile((BYTE*)pData, nLen);
+
+			// parse data
+			int nCur = 0;
+			while (nCur < nLen)
+			{
+				skip_int2(pData, nCur, nLen);
+
+				read_base64(pData, nCur, nLen);
+				++nCur;
+
+				++nCountData;
+			}
+
+			delete[]pData;
+		}
+
+		*((int*)m_pData) = nCountData;
+		return i;
+	}
+
+	v8::Local<v8::Uint8Array> GetData()
+	{
+		size_t len = (size_t)(m_pDataCur - m_pData);
+		v8::Local<v8::Uint8Array> _array = v8::Uint8Array::New(m_oArrayBuffer, 0, len);
+		return _array;
+	}
+
+public:
+	void OpenFull(CAtlArray<CString>& oFiles)
+	{
+		//  
+		int nCount = (int)oFiles.GetCount();
+		for (int i = 0; i < nCount; ++i)
+		{
+			CFile oFile;
+			oFile.OpenFile(oFiles[i]);
+			m_nLen += (int)oFile.GetFileSize();
+			oFile.CloseFile();
+		}
+
+		m_pData = new BYTE[m_nLen];
+		m_pDataCur = m_pData;
+
+		m_pDataCur += 4;
+		int nCountData = 0;
+
+		for (int i = 0; i < nCount; i++)
+		{
+			CFile oFile;
+			oFile.OpenFile(oFiles[i]);
+
+			int nLen = (int)oFile.GetFileSize();
+			char* pData = new char[nLen];
+
+			oFile.ReadFile((BYTE*)pData, nLen);
+
+			// parse data
+			int nCur = 0;
+			while (nCur < nLen)
+			{
+				// Id
+				skip_name(pData, nCur, nLen);
+				if (nCur >= nLen)
+					break;
+
+				int nId = read_int(pData, nCur, nLen);
+				*((int*)m_pDataCur) = nId;
+				m_pDataCur += 4;
+
+				// data
+				skip_name(pData, nCur, nLen);
+				skip_int2(pData, nCur, nLen);
+
+				read_base64(pData, nCur, nLen);
+				++nCur;
+
+				++nCountData;
+			}
+
+			delete[]pData;
+		}
+
+		*((int*)m_pData) = nCountData;
+	}
+
+	void OpenFull_excel(CAtlArray<CString>& oFiles)
+	{
+		//  
+		int nCount = (int)oFiles.GetCount();
+		for (int i = 0; i < nCount; ++i)
+		{
+			CFile oFile;
+			oFile.OpenFile(oFiles[i]);
+			m_nLen += (int)oFile.GetFileSize();
+			oFile.CloseFile();
+		}
+
+		m_pData = new BYTE[m_nLen];
+		m_pDataCur = m_pData;
+
+		m_pDataCur += 4;
+		int nCountData = 0;
+
+		for (int i = 0; i < nCount; i++)
+		{
+			CFile oFile;
+			oFile.OpenFile(oFiles[i]);
+
+			int nLen = (int)oFile.GetFileSize();
+			char* pData = new char[nLen];
+
+			oFile.ReadFile((BYTE*)pData, nLen);
+
+			// parse data
+			int nCur = 0;
+			while (nCur < nLen)
+			{
+				skip_int2(pData, nCur, nLen);
+
+				read_base64(pData, nCur, nLen);
+				++nCur;
+
+				++nCountData;
+			}
+
+			delete[]pData;
+		}
+
+		*((int*)m_pData) = nCountData;
+	}
+
+	v8::Local<v8::Uint8Array> GetDataFull()
+	{
+		size_t len = (size_t)(m_pDataCur - m_pData);
+		v8::Local<v8::ArrayBuffer> _buffer = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), (void*)m_pData, len);
+		v8::Local<v8::Uint8Array> _array = v8::Uint8Array::New(_buffer, 0, len);
+		return _array;
+	}
+
+	int OpenNative(CString strFile)
+	{
+		CFile oFile;
+		oFile.OpenFile(strFile);
+
+		int nLen = (int)oFile.GetFileSize();
+		char* pData = new char[nLen];
+
+		oFile.ReadFile((BYTE*)pData, nLen);
+
+		int nCur = 0;
+
+		// DOCY
+		skip_int2(pData, nCur, nLen);
+		// v
+		skip_no_digit(pData, nCur, nLen);
+		int nVersion = read_int2(pData, nCur, nLen);
+
+		m_nLen = read_int2(pData, nCur, nLen);
+		
+		m_pData = new BYTE[m_nLen];
+		m_pDataCur = m_pData;
+
+		read_base64_2(pData, nCur, nLen);
+
+		delete[]pData;
+
+		return nVersion;
+	}
+
+	__forceinline void skip_name(const char* data, int& cur, const int& len)
+	{
+		int nCount = 0;
+		while (cur < len)
+		{
+			if (data[cur] == '\"')
+				++nCount;
+
+			++cur;
+
+			if (3 == nCount)
+				break;
+		}
+	}
+
+	__forceinline int read_int(const char* data, int& cur, const int& len)
+	{
+		int res = 0;
+		while (cur < len)
+		{
+			if (data[cur] == '\"')
+			{
+				++cur;
+				break;
+			}
+
+			res *= 10;
+			res += (data[cur++] - '0');
+		}
+
+		return res;
+	}
+	__forceinline void skip_int2(const char* data, int& cur, const int& len)
+	{
+		while (cur < len)
+		{
+			if (data[cur++] == ';')
+				break;
+		}
+	}
+	__forceinline int read_int2(const char* data, int& cur, const int& len)
+	{
+		int res = 0;
+		while (cur < len)
+		{
+			if (data[cur] == ';')
+			{
+				++cur;
+				break;
+			}
+
+			res *= 10;
+			res += (data[cur++] - '0');
+		}
+
+		return res;
+	}
+	__forceinline void skip_no_digit(const char* data, int& cur, const int& len)
+	{
+		while (cur < len)
+		{
+			char _c = data[cur];
+			if (_c >= '0' && _c <= '9')
+				break;
+			++cur;
+		}
+	}
+
+	__forceinline void read_base64(const char* data, int& cur, const int& len)
+	{
+		Base64Decode(data, cur, len);
+	}
+	__forceinline void read_base64_2(const char* data, int& cur, const int& len)
+	{
+		Base64Decode2(data, cur, len);
+	}
+
+private:
+	__forceinline int DecodeBase64Char(unsigned int ch)
+	{
+		// returns -1 if the character is invalid
+		// or should be skipped
+		// otherwise, returns the 6-bit code for the character
+		// from the encoding table
+		if (ch >= 'A' && ch <= 'Z')
+			return ch - 'A' + 0;	// 0 range starts at 'A'
+		if (ch >= 'a' && ch <= 'z')
+			return ch - 'a' + 26;	// 26 range starts at 'a'
+		if (ch >= '0' && ch <= '9')
+			return ch - '0' + 52;	// 52 range starts at '0'
+		if (ch == '+')
+			return 62;
+		if (ch == '/')
+			return 63;
+		return -1;
+	}
+
+	void Base64Decode(const char* data, int& cur, const int& len)
+	{
+		// walk the source buffer
+		// each four character sequence is converted to 3 bytes
+		// CRLFs and =, and any characters not in the encoding table
+		// are skiped
+
+		BYTE* pDataLen = m_pDataCur;
+		m_pDataCur += 4;
+
+		int nWritten = 0;
+		while (cur < len && data[cur] != '\"')
+		{
+			DWORD dwCurr = 0;
+			int i;
+			int nBits = 0;
+			for (i = 0; i<4; i++)
+			{
+				if (data[cur] == '\"')
+					break;
+				int nCh = DecodeBase64Char(data[cur++]);
+				if (nCh == -1)
+				{
+					// skip this char
+					i--;
+					continue;
+				}
+				dwCurr <<= 6;
+				dwCurr |= nCh;
+				nBits += 6;
+			}
+
+			// dwCurr has the 3 bytes to write to the output buffer
+			// left to right
+			dwCurr <<= 24 - nBits;
+			for (i = 0; i<nBits / 8; i++)
+			{
+				*m_pDataCur = (BYTE)((dwCurr & 0x00ff0000) >> 16);
+				++m_pDataCur;
+
+				dwCurr <<= 8;
+				nWritten++;
+			}
+
+		}
+
+		*((int*)pDataLen) = nWritten;
+	}
+
+	void Base64Decode2(const char* data, int& cur, const int& len)
+	{
+		// walk the source buffer
+		// each four character sequence is converted to 3 bytes
+		// CRLFs and =, and any characters not in the encoding table
+		// are skiped
+
+		int nWritten = 0;
+		while (cur < len && data[cur] != '\"')
+		{
+			DWORD dwCurr = 0;
+			int i;
+			int nBits = 0;
+			for (i = 0; i<4; i++)
+			{
+				if (cur >= len)
+					break;
+				int nCh = DecodeBase64Char(data[cur++]);
+				if (nCh == -1)
+				{
+					// skip this char
+					i--;
+					continue;
+				}
+				dwCurr <<= 6;
+				dwCurr |= nCh;
+				nBits += 6;
+			}
+
+			// dwCurr has the 3 bytes to write to the output buffer
+			// left to right
+			dwCurr <<= 24 - nBits;
+			for (i = 0; i<nBits / 8; i++)
+			{
+				*m_pDataCur = (BYTE)((dwCurr & 0x00ff0000) >> 16);
+				++m_pDataCur;
+
+				dwCurr <<= 8;
+				nWritten++;
+			}
+
+		}
+	}
+};
+
+//////////////////////////////////////////////////////////////////////////////

DoctRenderer/stdafx.h

@@ -28,6 +28,8 @@
 
 #define _USE_LIBXML2_READER_
 
+#pragma comment(lib, "libxml2.lib")
+
 using namespace ATL;
 
 #include "../ASCImageStudio3/ASCGraphics/Interfaces/ASCRenderer.h"