pengjunjie/core
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/core.git synced 2026-04-07 13:55:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

"docrenderer like CJS" continue

Browse Source
This commit is contained in:
Kulikova Svetlana
2020-10-16 17:17:19 +03:00
parent dbd7ed3e1c
commit 0d61c3cacb
12 changed files with 393 additions and 671 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
DesktopEditor/doctrenderer/app_builder/main.cpp
View File

@ -62,8 +62,7 @@ int main(int argc, char *argv[])
#else
std::string sParam(argv[i]);
#endif
if (sParam == "-v" ||
sParam == "-version")
if (sParam == "-v" || sParam == "-version")
{
std::cout << "v" VALUE(INTVER) << std::endl;
NSDoctRenderer::CDocBuilder oBuilder;

334
DesktopEditor/doctrenderer/docbuilder_p.cpp
View File

@ -31,21 +31,6 @@
*/
#include "docbuilder_p.h"
namespace NSDoctRenderer
{
CDocBuilderValue_Private::CDocBuilderValue_Private()
{
m_isolate = NULL;
}
CDocBuilderValue_Private::~CDocBuilderValue_Private()
{
}
void CDocBuilderValue_Private::Clear()
{
m_value.Release();
}
}
void CV8RealTimeWorker::_LOGGING_ERROR_(const std::wstring& strType, const std::wstring& strError)
{
std::string sT = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strType);
@ -75,7 +60,6 @@ CV8RealTimeWorker::CV8RealTimeWorker(NSDoctRenderer::CDocBuilder* pBuilder)
JSSmart<CJSTryCatch> try_catch = m_context->GetExceptions();
builder_CreateNative("builderJS", m_context, pBuilder);
// m_context->GetGlobal()->set("builderJS", _builder_CreateNative(m_isolate, pBuilder));
}
CV8RealTimeWorker::~CV8RealTimeWorker()
{
@ -94,7 +78,6 @@ bool CV8RealTimeWorker::ExecuteCommand(const std::wstring& command, NSDoctRender
JSSmart<CJSContextScope> context_scope = m_context->CreateContextScope();
JSSmart<CJSTryCatch> try_catch = m_context->GetExceptions();
JSSmart<CJSObject> global_js = m_context->GetGlobal();
LOGGER_SPEED_LAP("compile_command")
@ -118,45 +101,15 @@ std::string CV8RealTimeWorker::GetGlobalVariable()
{
std::string commandA = "JSON.stringify(GlobalVariable);";
v8::Context::Scope context_scope(m_context);
v8::TryCatch try_catch(m_isolate);
v8::Local<v8::String> source = v8::String::NewFromUtf8(m_isolate, commandA.c_str());
v8::Local<v8::Script> script = v8::Script::Compile(m_context, source).FromMaybe(v8::Local<v8::Script>());
std::string sReturn = "{}";
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"execute_compile_code", strCode);
_LOGGING_ERROR_(L"execute_compile", strException);
JSSmart<CJSContextScope> context_scope = m_context->CreateContextScope();
JSSmart<CJSTryCatch> try_catch = m_context->GetExceptions();
JSSmart<CJSValue> _value = m_context->runScript(commandA, try_catch);
if(try_catch->Check())
return "";
}
else
{
v8::Local<v8::Value> _value = script->Run(m_context).FromMaybe(v8::Local<v8::Value>());
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"execute_run_code", strCode);
_LOGGING_ERROR_(L"execute_run", strException);
return "";
}
if (_value->IsString())
sReturn = CV8Convert::ToStringA(_value);
}
return sReturn;
if(_value->isString())
return _value->toStringA();
return "{}";
}
std::wstring CV8RealTimeWorker::GetJSVariable(std::wstring sParam)
@ -165,42 +118,14 @@ std::wstring CV8RealTimeWorker::GetJSVariable(std::wstring sParam)
NSCommon::string_replaceA(sParamA, "\\\"", "\"");
std::string commandA = "(function(){ return (" + sParamA + "); })()";
v8::Context::Scope context_scope(m_context);
v8::TryCatch try_catch(m_isolate);
v8::Local<v8::String> source = v8::String::NewFromUtf8(m_isolate, commandA.c_str());
v8::Local<v8::Script> script = v8::Script::Compile(m_context, source).FromMaybe(v8::Local<v8::Script>());
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"execute_compile_code", strCode);
_LOGGING_ERROR_(L"execute_compile", strException);
JSSmart<CJSContextScope> context_scope = m_context->CreateContextScope();
JSSmart<CJSTryCatch> try_catch = m_context->GetExceptions();
JSSmart<CJSValue> _value = m_context->runScript(commandA, try_catch);
if(try_catch->Check())
return L"jsValue(" + sParam + L")";
}
else
{
v8::Local<v8::Value> _value = script->Run(m_context).FromMaybe(v8::Local<v8::Value>());
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"execute_run_code", strCode);
_LOGGING_ERROR_(L"execute_run", strException);
return L"jsValue(" + sParam + L")";
}
if (_value->IsString())
return CV8Convert::ToString(_value);
}
if(_value->isString())
return _value->toStringW();
return L"jsValue(" + sParam + L")";
}
@ -208,48 +133,30 @@ bool CV8RealTimeWorker::OpenFile(const std::wstring& sBasePath, const std::wstri
{
LOGGER_SPEED_START
v8::Context::Scope context_scope(m_context);
v8::TryCatch try_catch(m_isolate);
v8::Local<v8::String> source = v8::String::NewFromUtf8(m_isolate, sString.c_str());
v8::Local<v8::Script> script;
JSSmart<CJSContextScope> context_scope = m_context->CreateContextScope();
JSSmart<CJSTryCatch> try_catch = m_context->GetExceptions();
CCacheDataScript oCachedScript(sCachePath);
if (sCachePath.empty())
script = v8::Script::Compile(m_context, source).FromMaybe(v8::Local<v8::Script>());
else
LOGGER_SPEED_LAP("compile");
if (!sCachePath.empty())
{
script = oCachedScript.Compile(m_context, source);
}
LOGGER_SPEED_LAP("compile")
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"sdk_compile_code", strCode);
_LOGGING_ERROR_(L"sdk_compile", strException);
return false;
}
else
{
script->Run(m_context);
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"sdk_run_code", strCode);
_LOGGING_ERROR_(L"sdk_run", strException);
v8::Local<v8::Script> script = oCachedScript.Compile(m_context->m_internal->m_context, v8::String::NewFromUtf8(m_context->m_internal->m_isolate, sString.c_str()));
if(try_catch->Check())
return false;
else
{
script->Run(m_context->m_internal->m_context);
if(try_catch->Check())
return false;
}
}
else
{
m_context->runScript(sString, try_catch);
if(try_catch->Check())
return false;
}
LOGGER_SPEED_LAP("run")
if (true)
@ -261,20 +168,9 @@ bool CV8RealTimeWorker::OpenFile(const std::wstring& sBasePath, const std::wstri
NSCommon::string_replaceA(sArg, "\"", "\\\"");
std::string sArgument = "var Argument = JSON.parse(\"" + sArg + "\");";
v8::Local<v8::String> _sourceArg = v8::String::NewFromUtf8(m_isolate, sArgument.c_str());
v8::Local<v8::Script> _scriptArg = v8::Script::Compile(m_context, _sourceArg).FromMaybe(v8::Local<v8::Script>());
_scriptArg->Run(m_context);
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"sdk_argument_code", strCode);
_LOGGING_ERROR_(L"sdk_argument", strException);
m_context->runScript(sArgument, try_catch);
if (try_catch->Check())
return false;
}
}
if (true)
@ -287,56 +183,28 @@ bool CV8RealTimeWorker::OpenFile(const std::wstring& sBasePath, const std::wstri
std::string sScriptVar = "var GlobalVariable = JSON.parse(\"" + sArg + "\");";
v8::Local<v8::String> _sourceArg = v8::String::NewFromUtf8(m_isolate, sScriptVar.c_str());
v8::Local<v8::Script> _scriptArg = v8::Script::Compile(m_context, _sourceArg).FromMaybe(v8::Local<v8::Script>());
_scriptArg->Run(m_context);
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"sdk_global_var_code", strCode);
_LOGGING_ERROR_(L"sdk_global_var", strException);
m_context->runScript(sScriptVar, try_catch);
if (try_catch->Check())
return false;
}
}
CNativeControl* pNative = NULL;
NSNativeControl::CNativeControl* pNative = NULL;
bool bIsBreak = false;
v8::Local<v8::Object> global_js = m_context->Global();
v8::Handle<v8::Value> args[1];
args[0] = v8::Int32::New(m_isolate, 0);
JSSmart<CJSObject> global_js = m_context->GetGlobal();
JSSmart<CJSValue> args[1];
args[0] = CJSContext::createInt(0);
// GET_NATIVE_ENGINE
if (!bIsBreak)
{
v8::Handle<v8::Value> js_func_get_native = global_js->Get(v8::String::NewFromUtf8(m_isolate, "GetNativeEngine"));
v8::Local<v8::Object> objNative;
if (js_func_get_native->IsFunction())
JSSmart<CJSValue> js_result2 = global_js->call_func("GetNativeEngine", 1, args);
if (try_catch->Check())
bIsBreak = true;
else
{
v8::Handle<v8::Function> func_get_native = v8::Handle<v8::Function>::Cast(js_func_get_native);
v8::Local<v8::Value> js_result2 = func_get_native->Call(global_js, 1, args);
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"run_code", strCode);
_LOGGING_ERROR_(L"run", strException);
bIsBreak = true;
}
else
{
objNative = js_result2->ToObject();
v8::Handle<v8::External> field = v8::Handle<v8::External>::Cast(objNative->GetInternalField(0));
pNative = static_cast<CNativeControl*>(field->Value());
}
JSSmart<CJSObject> objNative = js_result2->toObject();
pNative = (NSNativeControl::CNativeControl*)objNative->getNative()->getObject();
}
}
@ -364,42 +232,18 @@ bool CV8RealTimeWorker::OpenFile(const std::wstring& sBasePath, const std::wstri
// OPEN
if (!bIsBreak)
{
v8::Handle<v8::Value> js_func_open = global_js->Get(v8::String::NewFromUtf8(m_isolate, "NativeOpenFileData"));
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());
CChangesWorker oWorkerLoader;
int nVersion = oWorkerLoader.OpenNative(pNative->GetFilePath());
JSSmart<CJSValue> args_open[3];
args_open[0] = oWorkerLoader.GetDataFull().get();
args_open[1] = CJSContext::createInt(nVersion);
std::wstring sXlsx = NSCommon::GetDirectoryName(pNative->GetFilePath()) + L"/Editor.xlsx";
args_open[2] = NSFile::CFileBinary::Exists(sXlsx) ? CJSContext::createString(sXlsx) : NULL;
v8::Handle<v8::Value> args_open[3];
args_open[0] = oWorkerLoader.GetDataFull();
args_open[1] = v8::Integer::New(m_isolate, nVersion);
std::wstring sXlsx = NSCommon::GetDirectoryName(pNative->GetFilePath()) + L"/Editor.xlsx";
if (NSFile::CFileBinary::Exists(sXlsx))
{
std::string sXlsxA = U_TO_UTF8(sXlsx);
args_open[2] = v8::String::NewFromUtf8(m_isolate, (char*)(sXlsxA.c_str()));
}
else
{
args_open[2] = v8::Undefined(m_isolate);
}
func_open->Call(global_js, 3, args_open);
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"open_code", strCode);
_LOGGING_ERROR_(L"open", strException);
bIsBreak = true;
}
}
global_js->call_func("NativeOpenFileData", 3, args_open);
if (try_catch->Check())
bIsBreak = true;
}
if (!bIsBreak)
@ -422,40 +266,23 @@ bool CV8RealTimeWorker::SaveFileWithChanges(int type, const std::wstring& _path)
else if ((type & AVS_OFFICESTUDIO_FILE_CROSSPLATFORM) || (type & AVS_OFFICESTUDIO_FILE_IMAGE))
_formatDst = NSDoctRenderer::DoctRendererFormat::PDF;
v8::Context::Scope context_scope(m_context);
v8::TryCatch try_catch(m_isolate);
JSSmart<CJSContextScope> context_scope = m_context->CreateContextScope();
JSSmart<CJSTryCatch> try_catch = m_context->GetExceptions();
CNativeControl* pNative = NULL;
NSNativeControl::CNativeControl* pNative = NULL;
v8::Local<v8::Object> global_js = m_context->Global();
v8::Handle<v8::Value> args[1];
args[0] = v8::Int32::New(m_isolate, 0);
JSSmart<CJSObject> global_js = m_context->GetGlobal();
JSSmart<CJSValue> args[1];
args[0] = CJSContext::createInt(0);
// GET_NATIVE_ENGINE
if (true)
{
v8::Handle<v8::Value> js_func_get_native = global_js->Get(v8::String::NewFromUtf8(m_isolate, "GetNativeEngine"));
v8::Local<v8::Object> objNative;
if (js_func_get_native->IsFunction())
JSSmart<CJSValue> js_result2 = global_js->call_func("GetNativeEngine", 1, args);
if (!try_catch->Check())
{
v8::Handle<v8::Function> func_get_native = v8::Handle<v8::Function>::Cast(js_func_get_native);
v8::Local<v8::Value> js_result2 = func_get_native->Call(global_js, 1, args);
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"run_code", strCode);
_LOGGING_ERROR_(L"run", strException);
}
else
{
objNative = js_result2->ToObject();
v8::Handle<v8::External> field = v8::Handle<v8::External>::Cast(objNative->GetInternalField(0));
pNative = static_cast<CNativeControl*>(field->Value());
}
JSSmart<CJSObject> objNative = js_result2->toObject();
pNative = (NSNativeControl::CNativeControl*)objNative->getNative()->getObject();
}
}
@ -469,11 +296,8 @@ bool CV8RealTimeWorker::SaveFileWithChanges(int type, const std::wstring& _path)
bool bIsError = Doct_renderer_SaveFile_ForBuilder(_formatDst,
_path,
pNative,
m_isolate,
m_context,
global_js,
args,
try_catch,
strError);
if (_formatDst == NSDoctRenderer::DoctRendererFormat::PDF)
@ -508,7 +332,7 @@ namespace NSDoctRenderer
bool CDocBuilderValue::IsEmpty()
{
return m_internal->m_value.IsEmpty();
return m_internal->m_value->isEmpty();
}
void CDocBuilderValue::Clear()
{
@ -516,33 +340,29 @@ namespace NSDoctRenderer
}
bool CDocBuilderValue::IsNull()
{
if (m_internal->m_value.IsEmpty())
return false;
return m_internal->m_value->IsNull();
return m_internal->m_value->isNull();
}
bool CDocBuilderValue::IsUndefined()
{
if (m_internal->m_value.IsEmpty())
return false;
return m_internal->m_value->IsUndefined();
return m_internal->m_value->isUndefined();
}
int CDocBuilderValue::ToInt()
{
if (m_internal->m_value.IsEmpty() || !m_internal->m_value->IsInt32())
if (IsEmpty() || !m_internal->m_value->isNumber())
return 0;
return CV8Convert::ToInt(m_internal->m_value);
return m_internal->m_value->toInt32();
}
double CDocBuilderValue::ToDouble()
{
if (m_internal->m_value.IsEmpty() || !m_internal->m_value->IsNumber())
if (IsEmpty() || !m_internal->m_value->isNumber())
return 0;
return CV8Convert::ToDouble(m_internal->m_value);
return m_internal->m_value->toDouble();
}
wchar_t* CDocBuilderValue::ToString()
{
if (m_internal->m_value.IsEmpty() || !m_internal->m_value->IsString())
if (IsEmpty() || !m_internal->m_value->isString())
return NULL;
std::wstring sValue = CV8Convert::ToString(m_internal->m_value);
std::wstring sValue = m_internal->m_value->toStringW();
if (sValue.empty())
return NULL;
size_t len = sValue.length();
@ -558,14 +378,14 @@ namespace NSDoctRenderer
CDocBuilderValue CDocBuilderValue::GetProperty(const wchar_t* name)
{
CDocBuilderValue ret;
if (m_internal->m_value.IsEmpty() || !m_internal->m_value->IsObject())
if (IsEmpty() || !m_internal->m_value->isObject())
return ret;
std::wstring sProp(name);
std::string sPropA = U_TO_UTF8(sProp);
ret.m_internal->m_isolate = m_internal->m_isolate;
ret.m_internal->m_value = m_internal->m_value->ToObject()->Get(v8::String::NewFromUtf8(m_internal->m_isolate, sPropA.c_str()));
ret.m_internal->m_context = m_internal->m_context;
ret.m_internal->m_value = m_internal->m_value->toObject()->get(sPropA.c_str());
return ret;
}

6
DesktopEditor/doctrenderer/docbuilder_p.h
View File

@ -76,9 +76,9 @@ namespace NSDoctRenderer
JSSmart<CJSValue> m_value;
public:
CDocBuilderValue_Private();
~CDocBuilderValue_Private();
void Clear();
CDocBuilderValue_Private() { m_context = NULL; }
~CDocBuilderValue_Private() {}
void Clear() { m_value.Release(); }
};
}

417
DesktopEditor/doctrenderer/doctrenderer.cpp
View File

@ -36,7 +36,7 @@
#undef BOOL
#endif
#include "nativecontrol.h"
#include "js_internal/embed/NativeControlEmbed.h"
#include "../xml/include/xmlutils.h"
@ -390,22 +390,22 @@ namespace NSDoctRenderer
}
static bool Doct_renderer_SaveFile(CExecuteParams* pParams,
NSNativeControl::CNativeControl* pNative,
v8::Isolate* isolate,
v8::Local<v8::Context> context,
v8::Local<v8::Object>& global_js,
v8::Handle<v8::Value>* args,
v8::TryCatch& try_catch,
std::wstring& strError,
v8::Local<v8::Object>& api_js_maybe_null,
bool bIsPdfBase64 = false)
NSNativeControl::CNativeControl* pNative,
JSSmart<CJSContext> context,
JSSmart<CJSValue>* args,
std::wstring& strError,
JSSmart<CJSObject>& api_js_maybe_null,
bool bIsPdfBase64 = false)
{
v8::Local<v8::Object> js_objectApi = api_js_maybe_null;
if (js_objectApi.IsEmpty())
js_objectApi = global_js->Get(v8::String::NewFromUtf8(isolate, "Api"))->ToObject();
JSSmart<CJSTryCatch> try_catch = context->GetExceptions();
JSSmart<CJSObject> global_js = context->GetGlobal();
JSSmart<CJSObject> js_objectApi = api_js_maybe_null;
if (js_objectApi->isUndefined())
js_objectApi = global_js->get("Api")->toObject();
bool bIsBreak = false;
if (js_objectApi.IsEmpty() || !js_objectApi->IsObject())
if (js_objectApi->isUndefined() || !js_objectApi->isObject())
{
_LOGGING_ERROR_(L"save_code_api", L"");
_LOGGING_ERROR_(L"save_api", L"");
@ -421,82 +421,57 @@ namespace NSDoctRenderer
case DoctRendererFormat::PPTT:
case DoctRendererFormat::XLST:
{
v8::Handle<v8::Value> js_func_get_file_s = js_objectApi->Get(v8::String::NewFromUtf8(isolate, "asc_nativeGetFileData"));
if (js_func_get_file_s->IsFunction())
JSSmart<CJSValue> js_result2 = js_objectApi->call_func("asc_nativeGetFileData", 1, args);
if(try_catch->Check())
{
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(js_objectApi, 1, args);
strError = L"code=\"save\"";
bIsBreak = true;
}
else
{
const BYTE* pData = js_result2->toTypedArray()->getData();
if (try_catch.HasCaught())
NSFile::CFileBinary oFile;
if (true == oFile.CreateFileW(pParams->m_strDstFilePath))
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"save_code", strCode);
_LOGGING_ERROR_(L"save", strException);
strError = L"code=\"save\"";
bIsBreak = true;
}
else
{
v8::Local<v8::Uint8Array> pArray = v8::Local<v8::Uint8Array>::Cast(js_result2);
BYTE* pData = (BYTE*)pArray->Buffer()->Externalize().Data();
NSFile::CFileBinary oFile;
if (true == oFile.CreateFileW(pParams->m_strDstFilePath))
if (pNative->m_sHeader.find(";v10;") == std::string::npos)
{
if (pNative->m_sHeader.find(";v10;") == std::string::npos)
{
oFile.WriteFile((BYTE*)pNative->m_sHeader.c_str(), (DWORD)pNative->m_sHeader.length());
oFile.WriteFile((BYTE*)pNative->m_sHeader.c_str(), (DWORD)pNative->m_sHeader.length());
char* pDst64 = NULL;
int nDstLen = 0;
NSFile::CBase64Converter::Encode(pData, pNative->m_nSaveBinaryLen, pDst64, nDstLen, NSBase64::B64_BASE64_FLAG_NOCRLF);
char* pDst64 = NULL;
int nDstLen = 0;
NSFile::CBase64Converter::Encode(const_cast<BYTE*>(pData), pNative->m_nSaveBinaryLen, pDst64, nDstLen, NSBase64::B64_BASE64_FLAG_NOCRLF);
oFile.WriteFile((BYTE*)pDst64, (DWORD)nDstLen);
oFile.WriteFile((BYTE*)pDst64, (DWORD)nDstLen);
RELEASEARRAYOBJECTS(pDst64);
}
else
{
oFile.WriteFile(pData, (DWORD)pNative->m_nSaveBinaryLen);
}
oFile.CloseFile();
RELEASEARRAYOBJECTS(pDst64);
}
else
{
oFile.WriteFile(pData, (DWORD)pNative->m_nSaveBinaryLen);
}
oFile.CloseFile();
}
}
break;
}
case DoctRendererFormat::HTML:
{
v8::Handle<v8::Value> js_func_get_file_s = js_objectApi->Get(v8::String::NewFromUtf8(isolate, "asc_nativeGetHtml"));
if (js_func_get_file_s->IsFunction())
JSSmart<CJSValue> js_result2 = js_objectApi->call_func("asc_nativeGetHtml", 1, args);
if(try_catch->Check())
{
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(js_objectApi, 1, args);
strError = L"code=\"save\"";
bIsBreak = true;
}
else
{
std::string sHTML_Utf8 = js_result2->toStringA();
if (try_catch.HasCaught())
NSFile::CFileBinary oFile;
if (true == oFile.CreateFileW(pParams->m_strDstFilePath))
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"save_code", strCode);
_LOGGING_ERROR_(L"save", strException);
strError = L"code=\"save\"";
bIsBreak = true;
}
else
{
std::string sHTML_Utf8 = CV8Convert::ToStringA(js_result2);
NSFile::CFileBinary oFile;
if (true == oFile.CreateFileW(pParams->m_strDstFilePath))
{
oFile.WriteFile((BYTE*)sHTML_Utf8.c_str(), (DWORD)sHTML_Utf8.length());
oFile.CloseFile();
}
oFile.WriteFile((BYTE*)sHTML_Utf8.c_str(), (DWORD)sHTML_Utf8.length());
oFile.CloseFile();
}
}
break;
@ -504,186 +479,130 @@ namespace NSDoctRenderer
case DoctRendererFormat::PDF:
case DoctRendererFormat::PPTX_THEME_THUMBNAIL:
{
v8::Handle<v8::Value> js_func_calculate = js_objectApi->Get(v8::String::NewFromUtf8(isolate, "asc_nativeCalculateFile"));
v8::Handle<v8::Value> js_func_pages_count = js_objectApi->Get(v8::String::NewFromUtf8(isolate, "asc_nativePrintPagesCount"));
// CALCULATE
if (js_func_calculate->IsFunction())
if (pParams->m_sJsonParams.empty())
args[0] = NULL;
else
{
v8::Handle<v8::Function> func_calculate = v8::Handle<v8::Function>::Cast(js_func_calculate);
std::string sTmp = U_TO_UTF8((pParams->m_sJsonParams));
if (pParams->m_sJsonParams.empty())
args[0] = v8::Undefined(isolate);
else
#ifndef V8_OS_XP
args[0] = js_value(v8::JSON::Parse(context->m_internal->m_context, v8::String::NewFromUtf8(context->m_internal->m_isolate, sTmp.c_str())).FromMaybe(v8::Local<v8::Value>()));
#else
args[0] = js_value(v8::JSON::Parse(v8::String::NewFromUtf8(context->m_internal->m_isolate, sTmp.c_str())));
#endif
}
JSSmart<CJSValue> js_result2 = js_objectApi->call_func("asc_nativeCalculateFile", 1, args);
if(try_catch->Check())
{
strError = L"code=\"calculate\"";
bIsBreak = true;
}
// PAGESCOUNT
LONG lPagesCount = 0;
if (!bIsBreak)
{
JSSmart<CJSValue> js_result1 = js_objectApi->call_func("asc_nativePrintPagesCount", 1, args);
if(try_catch->Check())
{
std::string sTmp = U_TO_UTF8((pParams->m_sJsonParams));
#ifndef V8_OS_XP
args[0] = v8::JSON::Parse(context, v8::String::NewFromUtf8(isolate, (char*)sTmp.c_str())).FromMaybe(v8::Local<v8::Value>());
#else
args[0] = v8::JSON::Parse(v8::String::NewFromUtf8(isolate, (char*)sTmp.c_str()));
#endif
}
func_calculate->Call(js_objectApi, 1, args);
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"calculate_code", strCode);
_LOGGING_ERROR_(L"calculate", strException);
strError = L"code=\"calculate\"";
bIsBreak = true;
}
}
LONG lPagesCount = 0;
// PAGESCOUNT
if (!bIsBreak)
{
if (js_func_pages_count->IsFunction())
{
v8::Handle<v8::Function> func_pages_count = v8::Handle<v8::Function>::Cast(js_func_pages_count);
v8::Local<v8::Value> js_result1 = func_pages_count->Call(js_objectApi, 1, args);
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"calculate_code", strCode);
_LOGGING_ERROR_(L"calculate", strException);
strError = L"code=\"calculate\"";
bIsBreak = true;
}
else
{
lPagesCount = (LONG)CV8Convert::ToInt(js_result1);
}
}
else
lPagesCount = (LONG)js_result1->toInt32();
}
// RENDER
if (!bIsBreak && DoctRendererFormat::PDF == pParams->m_eDstFormat)
{
v8::Handle<v8::Value> js_func_get_file_s = js_objectApi->Get(v8::String::NewFromUtf8(isolate, "asc_nativeGetPDF"));
if (js_func_get_file_s->IsFunction())
if (pParams->m_sJsonParams.empty())
args[0] = NULL;
else
{
v8::Handle<v8::Function> func_get_file_s = v8::Handle<v8::Function>::Cast(js_func_get_file_s);
std::string sTmp = U_TO_UTF8((pParams->m_sJsonParams));
if (pParams->m_sJsonParams.empty())
args[0] = v8::Undefined(isolate);
else
#ifndef V8_OS_XP
args[0] = js_value(v8::JSON::Parse(context->m_internal->m_context, v8::String::NewFromUtf8(context->m_internal->m_isolate, sTmp.c_str())).FromMaybe(v8::Local<v8::Value>()));
#else
args[0] = js_value(v8::JSON::Parse(v8::String::NewFromUtf8(context->m_internal->m_isolate, sTmp.c_str())));
#endif
}
JSSmart<CJSValue> js_result2 = js_objectApi->call_func("asc_nativeGetPDF", 1, args);
if(try_catch->Check())
{
strError = L"code=\"save\"";
bIsBreak = true;
}
else
{
const BYTE* pData = js_result2->toTypedArray()->getData();
NSFile::CFileBinary oFile;
if (true == oFile.CreateFileW(pParams->m_strDstFilePath))
{
std::string sTmp = U_TO_UTF8((pParams->m_sJsonParams));
#ifndef V8_OS_XP
args[0] = v8::JSON::Parse(context, v8::String::NewFromUtf8(isolate, (char*)sTmp.c_str())).FromMaybe(v8::Local<v8::Value>());
#else
args[0] = v8::JSON::Parse(v8::String::NewFromUtf8(isolate, (char*)sTmp.c_str()));
#endif
}
v8::Local<v8::Value> js_result2 = func_get_file_s->Call(js_objectApi, 1, args);
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"save_code", strCode);
_LOGGING_ERROR_(L"save", strException);
strError = L"code=\"save\"";
bIsBreak = true;
}
else
{
v8::Local<v8::Uint8Array> pArray = v8::Local<v8::Uint8Array>::Cast(js_result2);
BYTE* pData = (BYTE*)pArray->Buffer()->Externalize().Data();
NSFile::CFileBinary oFile;
if (true == oFile.CreateFileW(pParams->m_strDstFilePath))
if (!bIsPdfBase64)
{
if (!bIsPdfBase64)
{
oFile.WriteFile(pData, (DWORD)pNative->m_nSaveBinaryLen);
}
else
{
char* pDataDst = NULL;
int nDataDst = 0;
if (NSFile::CBase64Converter::Encode(pData, pNative->m_nSaveBinaryLen, pDataDst, nDataDst))
{
oFile.WriteFile((BYTE*)pDataDst, (DWORD)nDataDst);
RELEASEARRAYOBJECTS(pDataDst);
}
}
oFile.CloseFile();
oFile.WriteFile(pData, (DWORD)pNative->m_nSaveBinaryLen);
}
else
{
char* pDataDst = NULL;
int nDataDst = 0;
if (NSFile::CBase64Converter::Encode(const_cast<BYTE*>(pData), pNative->m_nSaveBinaryLen, pDataDst, nDataDst))
{
oFile.WriteFile((BYTE*)pDataDst, (DWORD)nDataDst);
RELEASEARRAYOBJECTS(pDataDst);
}
}
oFile.CloseFile();
}
}
}
if (!bIsBreak && DoctRendererFormat::PPTX_THEME_THUMBNAIL == pParams->m_eDstFormat)
{
v8::Handle<v8::Value> js_func_get_file_thumbnail = js_objectApi->Get(v8::String::NewFromUtf8(isolate, "asc_nativeGetThemeThumbnail"));
if (js_func_get_file_thumbnail->IsFunction())
JSSmart<CJSValue> js_result2;
int nSizeArgs = (int)pParams->m_arThemesThumbnailsParams.size();
if (0 == nSizeArgs)
{
v8::Handle<v8::Function> func_get_file_thumbnail = v8::Handle<v8::Function>::Cast(js_func_get_file_thumbnail);
v8::Local<v8::Value> js_result2;
js_result2 = js_objectApi->call_func("asc_nativeGetThemeThumbnail", 1, args);
}
else
{
JSSmart<CJSArray> arrArgs = CJSContext::createArray(nSizeArgs);
int nCurArg = 0;
for (std::vector<int>::iterator iter = pParams->m_arThemesThumbnailsParams.begin(); iter != pParams->m_arThemesThumbnailsParams.end(); iter++)
arrArgs->set(nCurArg++, CJSContext::createInt(*iter));
int nSizeArgs = (int)pParams->m_arThemesThumbnailsParams.size();
if (0 == nSizeArgs)
args[0] = arrArgs->toValue();
js_result2 = js_objectApi->call_func("asc_nativeGetThemeThumbnail", 1, args);
}
if(try_catch->Check())
{
strError = L"code=\"save\"";
bIsBreak = true;
}
else
{
if (!js_result2->isNull())
{
js_result2 = func_get_file_thumbnail->Call(js_objectApi, 1, args);
}
else
{
v8::Local<v8::Array> arrArgs = v8::Array::New(isolate, nSizeArgs);
int nCurArg = 0;
for (std::vector<int>::iterator iter = pParams->m_arThemesThumbnailsParams.begin(); iter != pParams->m_arThemesThumbnailsParams.end(); iter++)
arrArgs->Set(nCurArg++, v8::Int32::New(isolate, *iter));
JSSmart<CJSObject> objNative = js_result2->toObject();
args[0] = arrArgs;
js_result2 = func_get_file_thumbnail->Call(js_objectApi, 1, args);
}
const BYTE* pData = objNative->get("data")->toTypedArray()->getData();
std::wstring sThemeName = objNative->get("name")->toStringW();
int nDataLen = objNative->get("dataLen")->toInt32();
if (try_catch.HasCaught())
{
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
if (sThemeName.empty())
sThemeName = L"Default";
_LOGGING_ERROR_(L"save_code", strCode);
_LOGGING_ERROR_(L"save", strException);
strError = L"code=\"save\"";
bIsBreak = true;
}
else
{
if (!js_result2->IsNull())
NSFile::CFileBinary oFile;
if (true == oFile.CreateFileW(pParams->m_strDstFilePath + L"/" + sThemeName + L".theme"))
{
v8::Local<v8::Object> objNative = js_result2->ToObject();
v8::Local<v8::Uint8Array> pArray = v8::Local<v8::Uint8Array>::Cast(objNative->Get(v8::String::NewFromUtf8(isolate, "data")));
std::wstring sThemeName = CV8Convert::ToString(objNative->Get(v8::String::NewFromUtf8(isolate, "name")));
int nDataLen = CV8Convert::ToInt(objNative->Get(v8::String::NewFromUtf8(isolate, "dataLen")));
if (sThemeName.empty())
sThemeName = L"Default";
BYTE* pData = (BYTE*)pArray->Buffer()->Externalize().Data();
NSFile::CFileBinary oFile;
if (true == oFile.CreateFileW(pParams->m_strDstFilePath + L"/" + sThemeName + L".theme"))
{
oFile.WriteFile(pData, (DWORD)nDataLen);
oFile.CloseFile();
}
oFile.WriteFile(pData, (DWORD)nDataLen);
oFile.CloseFile();
}
}
}
@ -696,7 +615,6 @@ namespace NSDoctRenderer
return bIsBreak;
}
bool ExecuteScript(const std::string& strScript, const std::wstring& sCachePath, std::wstring& strError, std::wstring& strReturnParams)
{
LOGGER_SPEED_START
@ -711,8 +629,8 @@ namespace NSDoctRenderer
v8::HandleScope handle_scope(isolate);
v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
global->Set(isolate, "CreateNativeEngine", v8::FunctionTemplate::New(isolate, CreateNativeObject));
global->Set(isolate, "CreateNativeMemoryStream", v8::FunctionTemplate::New(isolate, CreateNativeMemoryStream));
//CNativeControlEmbed::CreateObjectInContext("CreateNativeEngine", context);
// CMemoryStreamEmbed::CreateObjectInContext("CreateNativeMemoryStream", context);
v8::Local<v8::Context> context = v8::Context::New(isolate, NULL, global);
@ -736,11 +654,13 @@ namespace NSDoctRenderer
// COMPILE
if (try_catch.HasCaught())
{
/*
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"compile_code", strCode);
_LOGGING_ERROR_(L"compile", strException);
*/
strError = L"code=\"compile\"";
bIsBreak = true;
@ -753,11 +673,13 @@ namespace NSDoctRenderer
if (try_catch.HasCaught())
{
/*
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"run_code", strCode);
_LOGGING_ERROR_(L"run", strException);
*/
strError = L"code=\"run\"";
bIsBreak = true;
@ -771,7 +693,7 @@ namespace NSDoctRenderer
v8::Handle<v8::Value> args[1];
args[0] = v8::Int32::New(isolate, 0);
CNativeControl* pNative = NULL;
NSNativeControl::CNativeControl* pNative = NULL;
// GET_NATIVE_ENGINE
if (!bIsBreak)
@ -785,11 +707,13 @@ namespace NSDoctRenderer
if (try_catch.HasCaught())
{
/*
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"run_code", strCode);
_LOGGING_ERROR_(L"run", strException);
*/
strError = L"code=\"run\"";
bIsBreak = true;
@ -799,7 +723,7 @@ namespace NSDoctRenderer
objNative = js_result2->ToObject();
v8::Handle<v8::External> field = v8::Handle<v8::External>::Cast(objNative->GetInternalField(0));
pNative = static_cast<CNativeControl*>(field->Value());
pNative = static_cast<NSNativeControl::CNativeControl*>(field->Value());
pNative->m_sConsoleLogFile = m_sConsoleLogFile;
}
}
@ -834,7 +758,7 @@ namespace NSDoctRenderer
int nVersion = oWorkerLoader.OpenNative(pNative->GetFilePath());
v8::Handle<v8::Value> args_open[4];
args_open[0] = oWorkerLoader.GetDataFull();
// args_open[0] = oWorkerLoader.GetDataFull();
args_open[1] = v8::Integer::New(isolate, nVersion);
std::wstring sXlsx = NSCommon::GetDirectoryName(pNative->GetFilePath()) + L"/Editor.xlsx";
@ -859,11 +783,13 @@ namespace NSDoctRenderer
if (try_catch.HasCaught())
{
/*
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"open_code", strCode);
_LOGGING_ERROR_(L"open", strException);
*/
strError = L"code=\"open\"";
bIsBreak = true;
@ -872,11 +798,13 @@ namespace NSDoctRenderer
js_objectApi = global_js->Get(v8::String::NewFromUtf8(isolate, "Api"))->ToObject();
if (try_catch.HasCaught())
{
/*
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"api_code", strCode);
_LOGGING_ERROR_(L"api", strException);
*/
strError = L"code=\"open\"";
bIsBreak = true;
@ -911,18 +839,20 @@ namespace NSDoctRenderer
{
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[0] = oWorker.GetData();
args_changes[1] = v8::Boolean::New(isolate, bIsFull);
func_apply_changes->Call(js_objectApi, 2, args_changes);
if (try_catch.HasCaught())
{
/*
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"change_code", strCode);
_LOGGING_ERROR_(L"change", strException);
*/
char buffer[50];
sprintf(buffer, "index=\"%d\"", pNative->m_nCurrentChangesNumber - 1);
@ -1006,11 +936,13 @@ namespace NSDoctRenderer
if (try_catch.HasCaught())
{
/*
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"change_code", strCode);
_LOGGING_ERROR_(L"change", strException);
*/
strError = L"mailmerge=\"databaseopenjs\"";
bIsBreak = true;
@ -1022,11 +954,13 @@ namespace NSDoctRenderer
if (try_catch.HasCaught())
{
/*
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"change_code", strCode);
_LOGGING_ERROR_(L"change", strException);
*/
strError = L"mailmerge=\"databaseopenjs\"";
bIsBreak = true;
@ -1060,11 +994,13 @@ namespace NSDoctRenderer
if (try_catch.HasCaught())
{
/*
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"change_code", strCode);
_LOGGING_ERROR_(L"change", strException);
*/
strError = L"mailmerge=\"preview" + std::to_wstring(nIndexMM) + L"\"";
bIsBreak = true;
@ -1100,17 +1036,19 @@ namespace NSDoctRenderer
if (try_catch.HasCaught())
{
/*
std::wstring strCode = CV8Convert::GetSourceLine(try_catch.Message());
std::wstring strException = CV8Convert::GetMessage(try_catch.Message());
_LOGGING_ERROR_(L"change_code", strCode);
_LOGGING_ERROR_(L"change", strException);
*/
strError = L"mailmerge=\"field" + std::to_wstring(nIndexMM) + L"\"";
bIsBreak = true;
}
std::wstring sField = CV8Convert::ToString(js_result2);
std::wstring sField = js_value(js_result2)->toStringW();
NSDoctRenderer::replace_for_xml(sField);
NSDoctRenderer::replace_for_xml(sSaveFile);
@ -1322,19 +1260,16 @@ namespace NSDoctRenderer
}
bool Doct_renderer_SaveFile_ForBuilder(int nFormat, const std::wstring& strDstFile,
CNativeControl* pNative,
v8::Isolate* isolate,
v8::Local<v8::Context> context,
v8::Local<v8::Object>& global_js,
v8::Handle<v8::Value>* args,
v8::TryCatch& try_catch,
std::wstring& strError)
NSNativeControl::CNativeControl* pNative,
JSSmart<CJSContext> context,
JSSmart<CJSValue>* args,
std::wstring& strError)
{
NSDoctRenderer::CExecuteParams oParams;
oParams.m_eDstFormat = (NSDoctRenderer::DoctRendererFormat::FormatFile)nFormat;
oParams.m_strDstFilePath = strDstFile;
v8::Local<v8::Object> js_objectApi; // empty
JSSmart<CJSObject> js_objectApi; // empty
return NSDoctRenderer::CDoctRenderer_Private::Doct_renderer_SaveFile(&oParams,
pNative, isolate, context, global_js, args, try_catch, strError, js_objectApi, false);
pNative, context, args, strError, js_objectApi, false);
}

2
DesktopEditor/doctrenderer/doctrenderer.pro
View File

@ -67,7 +67,6 @@ HEADERS += \
js_internal/embed/GraphicsEmbed.h \
js_internal/embed/MemoryStreamEmbed.h \
js_internal/embed/NativeControlEmbed.h \
js_internal/embed/NativeBuilderEmbed.h \
js_internal/js_base.h \
js_internal/v8/v8_base.h
@ -75,7 +74,6 @@ SOURCES += \
js_internal/embed/GraphicsEmbed.cpp \
js_internal/embed/MemoryStreamEmbed.cpp \
js_internal/embed/NativeControlEmbed.cpp \
js_internal/embed/NativeBuilderEmbed.cpp \
js_internal/embed/v8/v8_Graphics.cpp \
js_internal/embed/v8/v8_MemoryStream.cpp \
js_internal/embed/v8/v8_NativeControl.cpp \

1
DesktopEditor/doctrenderer/js_internal/embed/NativeBuilderEmbed.cpp
View File

@ -1 +0,0 @@
#include "NativeBuilderEmbed.h"

7
DesktopEditor/doctrenderer/js_internal/embed/NativeBuilderEmbed.h
View File

@ -1,7 +0,0 @@
#ifndef _BUILD_NATIVE_NATIVEBUILDER_EMBED_H_
#define _BUILD_NATIVE_NATIVEBUILDER_EMBED_H_
#include "../../nativebuilder.h"
#include "../js_base.h"
#endif // _BUILD_NATIVE_NATIVEBUILDER_EMBED_H_

1
DesktopEditor/doctrenderer/js_internal/js_base.h
View File

@ -33,6 +33,7 @@ namespace NSJSBase
virtual bool isTypedArray() = 0;
virtual bool isObject() = 0;
virtual bool isFunction() = 0;
virtual bool isEmpty() = 0;
virtual void doUndefined() = 0;
virtual void doNull() = 0;

4
DesktopEditor/doctrenderer/js_internal/v8/v8_base.h
View File

@ -171,6 +171,10 @@ namespace NSJSBase
{
return value.IsEmpty() ? false : value->IsFunction();
}
virtual bool isEmpty()
{
return value.IsEmpty();
}
virtual void doUndefined()
{

228
DesktopEditor/doctrenderer/nativebuilder.cpp
View File

@ -70,123 +70,23 @@ void CBuilderDocumentEmbed::CloseFile()
m_sFolder = L"";
}
CBuilderEmbed* unwrap_builder_embed(v8::Handle<v8::Object> obj)
{
v8::Handle<v8::External> field = v8::Handle<v8::External>::Cast(obj->GetInternalField(0));
return static_cast<CBuilderEmbed*>(field->Value());
}
CBuilderDocumentEmbed* unwrap_builder_doc_embed(v8::Handle<v8::Object> obj)
{
v8::Handle<v8::External> field = v8::Handle<v8::External>::Cast(obj->GetInternalField(0));
return static_cast<CBuilderDocumentEmbed*>(field->Value());
}
#define CURRENTWRAPPER CBuilderEmbed
JSSmart<CJSValue> builder_OpenFile(JSSmart<CJSValue> sPath, JSSmart<CJSValue> sParams)
{
CBuilderEmbed* builder = unwrap_builder_embed(args.This());
std::wstring sPath = CV8Convert::ToString(args[0]);
std::wstring sParams = (args.Length() > 1) ? CV8Convert::ToString(args[1]) : L"";
int ret = builder->m_pBuilder->OpenFile(sPath.c_str(), sParams.c_str());
args.GetReturnValue().Set(v8::Int32::New(v8::Isolate::GetCurrent(), ret));
}
void _builder_CreateFile(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CBuilderEmbed* builder = unwrap_builder_embed(args.This());
bool ret = builder->m_pBuilder->CreateFile(CV8Convert::ToInt(args[0]));
args.GetReturnValue().Set(v8::Boolean::New(v8::Isolate::GetCurrent(), ret));
}
void _builder_SetTmpFolder(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CBuilderEmbed* builder = unwrap_builder_embed(args.This());
std::wstring sPath = CV8Convert::ToString(args[0]);
builder->m_pBuilder->SetTmpFolder(sPath.c_str());
}
void _builder_SaveFile(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CBuilderEmbed* builder = unwrap_builder_embed(args.This());
int type = CV8Convert::ToInt(args[0]);
std::wstring sPath = CV8Convert::ToString(args[1]);
std::wstring sParams = (args.Length() > 2) ? CV8Convert::ToString(args[2]) : L"";
int ret = builder->m_pBuilder->SaveFile(type, sPath.c_str(), sParams.empty() ? NULL : sParams.c_str());
args.GetReturnValue().Set(v8::Int32::New(v8::Isolate::GetCurrent(), ret));
}
void _builder_CloseFile(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CBuilderEmbed* builder = unwrap_builder_embed(args.This());
builder->m_pBuilder->CloseFile();
}
void _builder_OpenTmpFile(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CBuilderEmbed* builder = unwrap_builder_embed(args.This());
std::wstring sPath = CV8Convert::ToString(args[0]);
std::wstring sParams = (args.Length() > 1) ? CV8Convert::ToString(args[1]) : L"";
v8::Local<v8::Value> obj = _builder_CreateNativeTmpDoc(v8::Isolate::GetCurrent(), builder->m_pBuilder, sPath, sParams);
args.GetReturnValue().Set(obj);
}
/////////////////////////////////////////////////////////////////////////////////
void _builder_doc_IsValid(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CBuilderDocumentEmbed* doc = unwrap_builder_doc_embed(args.This());
args.GetReturnValue().Set(v8::Boolean::New(v8::Isolate::GetCurrent(), doc->m_bIsValid));
}
void _builder_doc_GetBinary(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CBuilderDocumentEmbed* doc = unwrap_builder_doc_embed(args.This());
BYTE* pData = NULL;
DWORD dwSize = 0;
NSFile::CFileBinary::ReadAllBytes(doc->m_sFolder + L"/Editor.bin", &pData, dwSize);
if (0 == dwSize)
{
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
}
else
{
v8::Local<v8::ArrayBuffer> _buffer = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), (void*)pData, (size_t)dwSize);
v8::Local<v8::Uint8Array> _array = v8::Uint8Array::New(_buffer, 0, (size_t)dwSize);
args.GetReturnValue().Set(_array);
}
}
void _builder_doc_GetFolder(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CBuilderDocumentEmbed* doc = unwrap_builder_doc_embed(args.This());
std::string sUtf8 = U_TO_UTF8((doc->m_sFolder));
args.GetReturnValue().Set(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sUtf8.c_str()));
}
void _builder_doc_CloseFile(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CBuilderDocumentEmbed* doc = unwrap_builder_doc_embed(args.This());
doc->CloseFile();
}
void _builder_doc_GetImageMap(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CBuilderDocumentEmbed* doc = unwrap_builder_doc_embed(args.This());
std::vector<std::wstring> files = NSDirectory::GetFiles(doc->m_sFolder + L"/media");
v8::Local<v8::Object> obj = v8::Object::New(v8::Isolate::GetCurrent());
for (std::vector<std::wstring>::iterator i = files.begin(); i != files.end(); i++)
{
std::wstring sFile = *i; NSCommon::string_replace(sFile, L"\\", L"/");
std::wstring sName = L"media/" + NSFile::GetFileName(sFile);
std::string sFileA = U_TO_UTF8(sFile);
std::string sNameA = U_TO_UTF8(sName);
v8::Local<v8::String> _k = v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sNameA.c_str(), v8::String::kNormalString, -1);
v8::Local<v8::String> _v = v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sFileA.c_str(), v8::String::kNormalString, -1);
obj->Set(_k, _v);
}
args.GetReturnValue().Set(obj);
}
/////////////////////////////////////////////////////////////////////////////////
FUNCTION_WRAPPER_V8_2(_builder_OpenFile, builder_OpenFile)
FUNCTION_WRAPPER_V8_1(_builder_CreateFile, builder_CreateFile)
FUNCTION_WRAPPER_V8_1(_builder_SetTmpFolder, builder_SetTmpFolder)
FUNCTION_WRAPPER_V8_3(_builder_SaveFile, builder_SaveFile)
FUNCTION_WRAPPER_V8 (_builder_CloseFile, builder_CloseFile)
FUNCTION_WRAPPER_V8_2(_builder_OpenTmpFile, builder_OpenTmpFile)
#undef CURRENTWRAPPER
#define CURRENTWRAPPER CBuilderDocumentEmbed
FUNCTION_WRAPPER_V8(_builder_doc_IsValid, builder_doc_IsValid)
FUNCTION_WRAPPER_V8(_builder_doc_GetBinary, builder_doc_GetBinary)
FUNCTION_WRAPPER_V8(_builder_doc_GetFolder, builder_doc_GetFolder)
FUNCTION_WRAPPER_V8(_builder_doc_CloseFile, builder_doc_CloseFile)
FUNCTION_WRAPPER_V8(_builder_doc_GetImageMap, builder_doc_GetImageMap)
v8::Local<v8::Value> _builder_CreateNativeTmpDoc(v8::Isolate* isolate, NSDoctRenderer::CDocBuilder* pBuilder, const std::wstring& sFile, const std::wstring& sParams)
{
@ -229,29 +129,91 @@ v8::Local<v8::Value> _builder_CreateNative(v8::Isolate* isolate, NSDoctRenderer:
return obj;
}
JSSmart<CJSValue> CBuilderEmbed::builder_OpenFile(JSSmart<CJSValue> sPath, JSSmart<CJSValue> sParams)
{
std::wstring Path = sPath->toStringW();
std::wstring Params = sParams->toStringW();
int ret = m_pBuilder->OpenFile(Path.c_str(), Params.c_str());
return CJSContext::createInt(ret);
}
JSSmart<CJSValue> CBuilderEmbed::builder_CreateFile(JSSmart<CJSValue> type)
{
bool ret = m_pBuilder->CreateFile(type->toInt32());
return CJSContext::createBool(ret);
}
JSSmart<CJSValue> CBuilderEmbed::builder_SetTmpFolder(JSSmart<CJSValue> path)
{
std::wstring sPath = path->toStringW();
m_pBuilder->SetTmpFolder(sPath.c_str());
return NULL;
}
JSSmart<CJSValue> CBuilderEmbed::builder_SaveFile(JSSmart<CJSValue> t, JSSmart<CJSValue> path, JSSmart<CJSValue> params)
{
int type = t->toInt32();
std::wstring sPath = path->toStringW();
std::wstring sParams = params->toStringW();
int ret = m_pBuilder->SaveFile(type, sPath.c_str(), sParams.empty() ? NULL : sParams.c_str());
return CJSContext::createInt(ret);
}
JSSmart<CJSValue> CBuilderEmbed::builder_CloseFile()
{
m_pBuilder->CloseFile();
return NULL;
}
JSSmart<CJSValue> CBuilderEmbed::builder_OpenTmpFile(JSSmart<CJSValue> path, JSSmart<CJSValue> params)
{
std::wstring sPath = path->toStringW();
std::wstring sParams = params->toStringW();
v8::Local<v8::Value> obj = _builder_CreateNativeTmpDoc(v8::Isolate::GetCurrent(), m_pBuilder, sPath, sParams);
CJSValueV8* res = new CJSValueV8();
res->value = obj;
return res;
}
JSSmart<CJSValue> CBuilderDocumentEmbed::builder_doc_IsValid()
{
return CJSContext::createBool(m_bIsValid);
}
JSSmart<CJSValue> CBuilderDocumentEmbed::builder_doc_GetBinary()
{
BYTE* pData = NULL;
DWORD dwSize = 0;
NSFile::CFileBinary::ReadAllBytes(m_sFolder + L"/Editor.bin", &pData, dwSize);
return 0 == dwSize ? NULL : CJSContext::createUint8Array(pData, (int)dwSize);
}
JSSmart<CJSValue> CBuilderDocumentEmbed::builder_doc_GetFolder()
{
return CJSContext::createString(m_sFolder);
}
JSSmart<CJSValue> CBuilderDocumentEmbed::builder_doc_CloseFile()
{
CloseFile();
return NULL;
}
JSSmart<CJSValue> CBuilderDocumentEmbed::builder_doc_GetImageMap()
{
std::vector<std::wstring> files = NSDirectory::GetFiles(m_sFolder + L"/media");
JSSmart<CJSObject> obj = CJSContext::createObject();
for (std::vector<std::wstring>::iterator i = files.begin(); i != files.end(); i++)
{
std::wstring sFile = *i; NSCommon::string_replace(sFile, L"\\", L"/");
std::wstring sName = L"media/" + NSFile::GetFileName(sFile);
obj->set(U_TO_UTF8(sName).c_str(), CJSContext::createString(sFile));
}
return obj->toValue();
}
void builder_CreateNativeTmpDoc(const std::string& name, JSSmart<CJSContext> context, NSDoctRenderer::CDocBuilder* builder, const std::wstring& sFile, const std::wstring& sParams)
{
v8::Isolate* current = CV8Worker::GetCurrent();
context->m_internal->m_global->Set(current, v8::String::NewFromUtf8(current, name.c_str()), _builder_CreateNative(current, builder));
context->m_internal->m_global->Set(current, name.c_str(), _builder_CreateNativeTmpDoc(current, builder, sFile, sParams));
}
void builder_CreateNative(const std::string& name, JSSmart<CJSContext> context, NSDoctRenderer::CDocBuilder* builder)
void builder_CreateNative (const std::string& name, JSSmart<CJSContext> context, NSDoctRenderer::CDocBuilder* builder)
{
v8::Isolate* current = CV8Worker::GetCurrent();
context->m_internal->m_global->Set(current, v8::String::NewFromUtf8(current, name.c_str()), _builder_CreateNative(current, builder));
context->m_internal->m_global->Set(current, name.c_str(), _builder_CreateNative(current, builder));
}
FUNCTION_WRAPPER_V8_2(_builder_OpenFile, builder_OpenFile)
void _builder_OpenFile(const v8::FunctionCallbackInfo<v8::Value>& args);
void _builder_CreateFile(const v8::FunctionCallbackInfo<v8::Value>& args);
void _builder_SetTmpFolder(const v8::FunctionCallbackInfo<v8::Value>& args);
void _builder_SaveFile(const v8::FunctionCallbackInfo<v8::Value>& args);
void _builder_CloseFile(const v8::FunctionCallbackInfo<v8::Value>& args);
void _builder_OpenTmpFile(const v8::FunctionCallbackInfo<v8::Value>& args);
void _builder_doc_IsValid(const v8::FunctionCallbackInfo<v8::Value>& args);
void _builder_doc_GetBinary(const v8::FunctionCallbackInfo<v8::Value>& args);
void _builder_doc_GetFolder(const v8::FunctionCallbackInfo<v8::Value>& args);
void _builder_doc_CloseFile(const v8::FunctionCallbackInfo<v8::Value>& args);
void _builder_doc_GetImageMap(const v8::FunctionCallbackInfo<v8::Value>& args);

34
DesktopEditor/doctrenderer/nativebuilder.h
View File

@ -48,16 +48,26 @@ namespace NSDoctRenderer
};
}
class CBuilderEmbed : public NSDoctRenderer::CDocBuilderJS
class CBuilderEmbed : public CJSEmbedObject
{
public:
NSDoctRenderer::CDocBuilder* m_pBuilder;
CBuilderEmbed() { m_pBuilder = NULL; }
~CBuilderEmbed() {}
CBuilderEmbed() : m_pBuilder(NULL) {}
~CBuilderEmbed() { if(m_pBuilder) RELEASEOBJECT(m_pBuilder); }
virtual void* getObject() { return (void*)m_pBuilder; }
public:
JSSmart<CJSValue> builder_OpenFile(JSSmart<CJSValue> sPath, JSSmart<CJSValue> sParams);
JSSmart<CJSValue> builder_CreateFile(JSSmart<CJSValue> type);
JSSmart<CJSValue> builder_SetTmpFolder(JSSmart<CJSValue> path);
JSSmart<CJSValue> builder_SaveFile(JSSmart<CJSValue> t, JSSmart<CJSValue> path, JSSmart<CJSValue> params);
JSSmart<CJSValue> builder_CloseFile();
JSSmart<CJSValue> builder_OpenTmpFile(JSSmart<CJSValue> path, JSSmart<CJSValue> params);
};
class CBuilderDocumentEmbed : public NSDoctRenderer::CDocBuilderJS
class CBuilderDocumentEmbed : public CJSEmbedObject
{
public:
NSDoctRenderer::CDocBuilder* m_pBuilder;
@ -65,15 +75,21 @@ public:
std::wstring m_sFolder;
public:
CBuilderDocumentEmbed()
{
m_pBuilder = NULL;
m_bIsValid = false;
}
CBuilderDocumentEmbed() : m_pBuilder(NULL), m_bIsValid(false) {}
~CBuilderDocumentEmbed() { if(m_pBuilder) RELEASEOBJECT(m_pBuilder); }
virtual void* getObject() { return (void*)m_pBuilder; }
public:
void OpenFile(const std::wstring& sFile, const std::wstring& sParams);
void CloseFile();
public:
JSSmart<CJSValue> builder_doc_IsValid();
JSSmart<CJSValue> builder_doc_GetBinary();
JSSmart<CJSValue> builder_doc_GetFolder();
JSSmart<CJSValue> builder_doc_CloseFile();
JSSmart<CJSValue> builder_doc_GetImageMap();
};
void builder_CreateNative(const std::string& name, JSSmart<CJSContext> context, NSDoctRenderer::CDocBuilder* builder);

27
DesktopEditor/doctrenderer/nativecontrol.h
View File

@ -42,6 +42,7 @@
#include "../../OfficeUtils/src/OfficeUtils.h"
#include "js_internal/embed/MemoryStreamEmbed.h"
#include "js_internal/v8/v8_base.h"
#include "../fontengine/application_generate_fonts_common.h"
#if defined(CreateDirectory)
@ -467,7 +468,7 @@ private:
int m_nLen;
int m_nMaxUnionSize = 100 * 1024 * 1024; // 100Mb
v8::Local<v8::ArrayBuffer> m_oArrayBuffer;
JSSmart<CJSTypedArray> m_oArrayBuffer;
int m_nFileType; // 0 - docx; 1 - excel
@ -528,7 +529,7 @@ public:
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);
m_oArrayBuffer = CJSContext::createUint8Array(m_pData, m_nLen);
}
inline int Open(CArray<std::wstring>& oFiles, int nStart)
@ -638,11 +639,9 @@ public:
return i;
}
v8::Local<v8::Uint8Array> GetData()
const BYTE* GetData()
{
size_t len = (size_t)(m_pDataCur - m_pData);
v8::Local<v8::Uint8Array> _array = v8::Uint8Array::New(m_oArrayBuffer, 0, len);
return _array;
return m_oArrayBuffer->getData();
}
public:
@ -754,12 +753,11 @@ public:
*((int*)m_pData) = nCountData;
}
v8::Local<v8::Uint8Array> GetDataFull()
JSSmart<CJSTypedArray> 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;
JSSmart<CJSTypedArray> _buffer = CJSContext::createUint8Array(m_pData, len);
return _buffer;
}
int OpenNative(std::wstring strFile)
@ -1151,12 +1149,9 @@ public:
#endif
bool Doct_renderer_SaveFile_ForBuilder(int nFormat, const std::wstring& strDstFile,
CNativeControl* pNative,
v8::Isolate* isolate,
v8::Local<v8::Context> context,
v8::Local<v8::Object>& global_js,
v8::Handle<v8::Value>* args,
v8::TryCatch& try_catch,
NSNativeControl::CNativeControl* pNative,
JSSmart<CJSContext> context,
JSSmart<CJSValue>* args,
std::wstring& strError);
class CCacheDataScript