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

"doctrenderer like CJS" begin

Browse Source
This commit is contained in:
Kulikova Svetlana
2020-10-15 18:29:13 +03:00
parent 02fb5d5068
commit dbd7ed3e1c
20 changed files with 742 additions and 1019 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
DesktopEditor/doctrenderer/docbuilder_p.cpp
View File

@ -42,7 +42,7 @@ namespace NSDoctRenderer
}
void CDocBuilderValue_Private::Clear()
{
m_value.Clear();
m_value.Release();
}
}
@ -54,36 +54,32 @@ void CV8RealTimeWorker::_LOGGING_ERROR_(const std::wstring& strType, const std::
std::cerr << sT << ": " << sE << std::endl;
}
using namespace NSJSBase;
CV8RealTimeWorker::CV8RealTimeWorker(NSDoctRenderer::CDocBuilder* pBuilder)
{
m_nFileType = -1;
m_isolate = v8::Isolate::GetCurrent(); // CV8Worker::getInitializer()->CreateNew();
m_context = new CJSContext();
m_context->Initialize();
m_isolate_scope = new v8::Isolate::Scope(m_isolate);
m_isolate_locker = new v8::Locker(m_isolate);
m_handle_scope = new CScopeWrapper<v8::HandleScope>(m_isolate);
m_isolate_scope = m_context->CreateIsolateScope();
m_handle_scope = m_context->CreateLocalScope() ;
v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(m_isolate);
global->Set(m_isolate, "CreateNativeEngine", v8::FunctionTemplate::New(m_isolate, CreateNativeObjectBuilder));
global->Set(m_isolate, "CreateNativeMemoryStream", v8::FunctionTemplate::New(m_isolate, CreateNativeMemoryStream));
m_context = v8::Context::New(m_isolate, NULL, global);
m_context->CreateGlobalForContext();
CNativeControlEmbed::CreateObjectBuilderInContext("CreateNativeEngine", m_context);
CMemoryStreamEmbed::CreateObjectInContext("CreateNativeMemoryStream", m_context);
m_context->CreateContext();
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();
m_context->Global()->Set(m_context, v8::String::NewFromUtf8(m_isolate, "builderJS"), _builder_CreateNative(m_isolate, pBuilder));
builder_CreateNative("builderJS", m_context, pBuilder);
// m_context->GetGlobal()->set("builderJS", _builder_CreateNative(m_isolate, pBuilder));
}
CV8RealTimeWorker::~CV8RealTimeWorker()
{
RELEASEOBJECT(m_handle_scope);
m_context.Clear();
RELEASEOBJECT(m_isolate_locker);
RELEASEOBJECT(m_isolate_scope);
m_isolate->Dispose();
m_isolate = NULL;
m_context->Dispose();
}
bool CV8RealTimeWorker::ExecuteCommand(const std::wstring& command, NSDoctRenderer::CDocBuilderValue* retValue)
@ -96,46 +92,21 @@ bool CV8RealTimeWorker::ExecuteCommand(const std::wstring& command, NSDoctRender
std::string commandA = U_TO_UTF8(command);
//commandA = "Api." + commandA;
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>());
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")
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<CJSValue> retNativeVal = m_context->runScript(commandA, try_catch);
if(try_catch->Check())
return false;
}
else
if (retValue)
{
v8::Local<v8::Value> retNativeVal = 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 false;
}
if (retValue)
{
NSDoctRenderer::CDocBuilderValue_Private* privateRet = (NSDoctRenderer::CDocBuilderValue_Private*)retValue->private_get_internal();
privateRet->m_isolate = m_isolate;
privateRet->m_value = retNativeVal;
}
NSDoctRenderer::CDocBuilderValue_Private* privateRet = (NSDoctRenderer::CDocBuilderValue_Private*)retValue->private_get_internal();
privateRet->m_context = m_context;
privateRet->m_value = retNativeVal;
}
LOGGER_SPEED_LAP("run_command")

34
DesktopEditor/doctrenderer/docbuilder_p.h
View File

@ -47,6 +47,9 @@
#include "nativebuilder.h"
#include <list>
#include "js_internal/embed/NativeControlEmbed.h"
#include "js_internal/embed/MemoryStreamEmbed.h"
#ifdef LINUX
#include <unistd.h>
#include <sys/wait.h>
@ -58,6 +61,7 @@
#endif
#include "../fontengine/ApplicationFontsWorker.h"
#include "js_internal/js_base.h"
#ifdef CreateFile
#undef CreateFile
@ -68,8 +72,8 @@ namespace NSDoctRenderer
class CDocBuilderValue_Private
{
public:
v8::Isolate* m_isolate;
v8::Local<v8::Value> m_value;
JSSmart<CJSContext> m_context;
JSSmart<CJSValue> m_value;
public:
CDocBuilderValue_Private();
@ -78,35 +82,15 @@ namespace NSDoctRenderer
};
}
template <typename T>
class CScopeWrapper
{
private:
T m_handler;
private:
CScopeWrapper(const CScopeWrapper&) {}
void operator=(const CScopeWrapper&) {}
public:
CScopeWrapper(v8::Isolate* isolate) : m_handler(isolate) {}
};
class CV8RealTimeWorker
{
public:
v8::Isolate* m_isolate;
v8::Isolate::Scope* m_isolate_scope;
v8::Locker* m_isolate_locker;
CScopeWrapper<v8::HandleScope>* m_handle_scope;
v8::Local<v8::Context> m_context;
JSSmart<CJSIsolateScope> m_isolate_scope;
JSSmart<CJSLocalScope> m_handle_scope;
JSSmart<CJSContext> m_context;
int m_nFileType;
std::string m_sUtf8ArgumentJSON;
std::string m_sGlobalVariable;
public:

41
DesktopEditor/doctrenderer/doctrenderer.cpp
View File

@ -198,45 +198,6 @@ namespace NSDoctRenderer
};
}
void CreateNativeObject(const v8::FunctionCallbackInfo<v8::Value>& args)
{
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::Handle<v8::ObjectTemplate> NativeObjectTemplate = CreateNativeControlTemplate(isolate);
CNativeControl* pNativeObject = new CNativeControl();
v8::Local<v8::Object> obj = NativeObjectTemplate->NewInstance();
obj->SetInternalField(0, v8::External::New(v8::Isolate::GetCurrent(), pNativeObject));
args.GetReturnValue().Set(obj);
}
void CreateNativeObjectBuilder(const v8::FunctionCallbackInfo<v8::Value>& args)
{
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::Handle<v8::ObjectTemplate> NativeObjectTemplate = CreateNativeControlTemplateBuilder(isolate);
CNativeControl* pNativeObject = new CNativeControl();
v8::Local<v8::Object> obj = NativeObjectTemplate->NewInstance();
obj->SetInternalField(0, v8::External::New(v8::Isolate::GetCurrent(), pNativeObject));
args.GetReturnValue().Set(obj);
}
void CreateNativeMemoryStream(const v8::FunctionCallbackInfo<v8::Value>& args)
{
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::Handle<v8::ObjectTemplate> MemoryObjectTemplate = CreateMemoryStreamTemplate(isolate);
CMemoryStream* pMemoryObject = new CMemoryStream();
v8::Local<v8::Object> obj = MemoryObjectTemplate->NewInstance();
obj->SetInternalField(0, v8::External::New(v8::Isolate::GetCurrent(), pMemoryObject));
args.GetReturnValue().Set(obj);
}
namespace NSDoctRenderer
{
std::wstring string_replaceAll(std::wstring str, const std::wstring& from, const std::wstring& to)
@ -429,7 +390,7 @@ namespace NSDoctRenderer
}
static bool Doct_renderer_SaveFile(CExecuteParams* pParams,
CNativeControl* pNative,
NSNativeControl::CNativeControl* pNative,
v8::Isolate* isolate,
v8::Local<v8::Context> context,
v8::Local<v8::Object>& global_js,

9
DesktopEditor/doctrenderer/doctrenderer.pro
View File

@ -43,7 +43,6 @@ HEADERS += \
docbuilder.h
SOURCES += \
memorystream.cpp \
nativecontrol.cpp \
doctrenderer.cpp \
docbuilder.cpp \
@ -66,12 +65,20 @@ HEADERS += \
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
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 \
js_internal/v8/v8_base.cpp
}

2
DesktopEditor/doctrenderer/js_internal/embed/GraphicsEmbed.cpp
View File

@ -1,4 +1,4 @@
#include "./GraphicsEmbed.h"
#include "GraphicsEmbed.h"
JSSmart<CJSValue> CGraphicsEmbed::init(JSSmart<CJSValue> context, JSSmart<CJSValue> width_px, JSSmart<CJSValue> height_px, JSSmart<CJSValue> width_mm, JSSmart<CJSValue> height_mm)
{

66
DesktopEditor/doctrenderer/js_internal/embed/MemoryStreamEmbed.cpp Normal file
View File

@ -0,0 +1,66 @@
#include "MemoryStreamEmbed.h"
JSSmart<CJSValue> CMemoryStreamEmbed::Copy(JSSmart<CJSValue> stream, JSSmart<CJSValue> pos, JSSmart<CJSValue> len)
{
JSSmart<CJSObject> _obj = stream->toObject();
NSMemoryStream::CMemoryStream* pStream = (NSMemoryStream::CMemoryStream*)(_obj->getNative());
m_pInternal->Copy(pStream, pos->toInt32(), len->toInt32());
return NULL;
}
JSSmart<CJSValue> CMemoryStreamEmbed::ClearNoAttack()
{
m_pInternal->ClearNoAttack();
return NULL;
}
JSSmart<CJSValue> CMemoryStreamEmbed::WriteByte(JSSmart<CJSValue> value)
{
m_pInternal->WriteBYTE((BYTE)value->toInt32());
return NULL;
}
JSSmart<CJSValue> CMemoryStreamEmbed::WriteBool(JSSmart<CJSValue> value)
{
m_pInternal->WriteBYTE(value->toBool() ? 1 : 0);
return NULL;
}
JSSmart<CJSValue> CMemoryStreamEmbed::WriteLong(JSSmart<CJSValue> value)
{
m_pInternal->WriteLONG((LONG)value->toInt32());
return NULL;
}
JSSmart<CJSValue> CMemoryStreamEmbed::WriteDouble(JSSmart<CJSValue> value)
{
m_pInternal->WriteLONG((LONG)(value->toDouble() * 100000));
return NULL;
}
JSSmart<CJSValue> CMemoryStreamEmbed::WriteDouble2(JSSmart<CJSValue> value)
{
m_pInternal->WriteDouble(value->toDouble());
return NULL;
}
JSSmart<CJSValue> CMemoryStreamEmbed::WriteStringA(JSSmart<CJSValue> value)
{
std::string param = value->toStringA();
m_pInternal->WriteStringA2(param.c_str(), (int)param.length());
return NULL;
}
JSSmart<CJSValue> CMemoryStreamEmbed::WriteString(JSSmart<CJSValue> value)
{
std::wstring param = value->toStringW();
m_pInternal->WriteString(param.c_str(), (int)param.length());
return NULL;
}
JSSmart<CJSValue> CMemoryStreamEmbed::WriteString2(JSSmart<CJSValue> value)
{
std::wstring param = value->toStringW();
m_pInternal->WriteString2(param.c_str(), (int)param.length());
return NULL;
}

35
DesktopEditor/doctrenderer/js_internal/embed/MemoryStreamEmbed.h Normal file
View File

@ -0,0 +1,35 @@
#ifndef _BUILD_NATIVE_MEMORYSTREAM_EMBED_H_
#define _BUILD_NATIVE_MEMORYSTREAM_EMBED_H_
#include "../../memorystream.h"
#include "../js_base.h"
using namespace NSJSBase;
class CMemoryStreamEmbed : public CJSEmbedObject
{
public:
NSMemoryStream::CMemoryStream* m_pInternal;
public:
CMemoryStreamEmbed() : m_pInternal(new NSMemoryStream::CMemoryStream()) {}
~CMemoryStreamEmbed() { RELEASEOBJECT(m_pInternal); }
virtual void* getObject() { return (void*)m_pInternal; }
public:
JSSmart<CJSValue> Copy(JSSmart<CJSValue> stream, JSSmart<CJSValue> pos, JSSmart<CJSValue> len);
JSSmart<CJSValue> ClearNoAttack();
JSSmart<CJSValue> WriteByte(JSSmart<CJSValue> value);
JSSmart<CJSValue> WriteBool(JSSmart<CJSValue> value);
JSSmart<CJSValue> WriteLong(JSSmart<CJSValue> value);
JSSmart<CJSValue> WriteDouble(JSSmart<CJSValue> value);
JSSmart<CJSValue> WriteDouble2(JSSmart<CJSValue> value);
JSSmart<CJSValue> WriteStringA(JSSmart<CJSValue> value);
JSSmart<CJSValue> WriteString(JSSmart<CJSValue> value);
JSSmart<CJSValue> WriteString2(JSSmart<CJSValue> value);
static void CreateObjectInContext(const std::string& name, JSSmart<CJSContext> context);
};
#endif // _BUILD_NATIVE_MEMORYSTREAM_EMBED_H_

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

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

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

@ -0,0 +1,7 @@
#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_

251
DesktopEditor/doctrenderer/js_internal/embed/NativeControlEmbed.cpp Normal file
View File

@ -0,0 +1,251 @@
#include "NativeControlEmbed.h"
JSSmart<CJSValue> CNativeControlEmbed::SetFilePath(JSSmart<CJSValue> path)
{
m_pInternal->SetFilePath(path->toStringW());
return NULL;
}
JSSmart<CJSValue> CNativeControlEmbed::GetFilePath()
{
return CJSContext::createString(m_pInternal->GetFilePath());
}
JSSmart<CJSValue> CNativeControlEmbed::SetFileId(JSSmart<CJSValue> fileId)
{
m_pInternal->SetFileId(fileId->toStringW());
return NULL;
}
JSSmart<CJSValue> CNativeControlEmbed::GetFileId()
{
return CJSContext::createString(m_pInternal->GetFileId());
}
JSSmart<CJSValue> CNativeControlEmbed::GetFileBinary(JSSmart<CJSValue> file)
{
BYTE* pData = NULL;
DWORD len = 0;
m_pInternal->getFileData(file->toStringW(), pData, len);
// TODO: copy (use gc)
return CJSContext::createUint8Array(pData, (int)len);
}
JSSmart<CJSValue> CNativeControlEmbed::GetFontBinary(JSSmart<CJSValue> file)
{
BYTE* pData = NULL;
DWORD len = 0;
std::wstring strDir = m_pInternal->m_strFontsDirectory;
#if 0
if (!strDir.empty())
{
strDir += L"/";
strDir += file->toStringW();
}
#endif
// TODO:
// по идее файлы могут совпадать по имени, но лежать в разных директориях.
// и поэтому в AllFonts.js надо бы писать пути полные.
// пока оставим по-старому
std::wstring sFind = file->toStringW();
bool bIsFullFilePath = (std::wstring::npos != sFind.find('\\') || std::wstring::npos != sFind.find('/'));
if (bIsFullFilePath)
{
bIsFullFilePath = NSFile::CFileBinary::Exists(sFind);
}
if (!bIsFullFilePath)
{
std::map<std::wstring, std::wstring>::iterator pair = m_pInternal->m_map_fonts.find(sFind);
if (pair != m_pInternal->m_map_fonts.end())
strDir = pair->second;
else
strDir = m_pInternal->m_sDefaultFont;
}
else
{
strDir = sFind;
}
m_pInternal->getFileData(strDir, pData, len);
// TODO: copy (use gc)
return CJSContext::createUint8Array(pData, (int)len);
}
JSSmart<CJSValue> CNativeControlEmbed::GetFontsDirectory()
{
return CJSContext::createString(m_pInternal->m_strFontsDirectory);
}
JSSmart<CJSValue> CNativeControlEmbed::GetFileString(JSSmart<CJSValue> file)
{
BYTE* pData = NULL;
DWORD len = 0;
m_pInternal->getFileData(file->toStringW(), pData, len);
if (pData != NULL && len > 0)
{
JSSmart<CJSValue> _ret = CJSContext::createUint8Array((BYTE* )pData, (int)len);
return _ret;
}
return CJSContext::createNull();
}
JSSmart<CJSValue> CNativeControlEmbed::GetEditorType()
{
return CJSContext::createString(m_pInternal->m_strEditorType);
}
JSSmart<CJSValue> CNativeControlEmbed::CheckNextChange()
{
m_pInternal->m_nCurrentChangesNumber++;
if (-1 != m_pInternal->m_nMaxChangesNumber)
{
if (m_pInternal->m_nCurrentChangesNumber >= m_pInternal->m_nMaxChangesNumber)
{
return CJSContext::createBool(false);
}
}
return CJSContext::createBool(true);
}
JSSmart<CJSValue> CNativeControlEmbed::GetCountChanges()
{
int nCount = 0;
if (m_pInternal->m_pChanges != NULL)
{
nCount = (int)m_pInternal->m_pChanges->GetCount();
}
return CJSContext::createInt(nCount);
}
JSSmart<CJSValue> CNativeControlEmbed::GetChangesFile(JSSmart<CJSValue> index)
{
int nIndex = index->toInt32();
std::wstring strFile = L"";
if (m_pInternal->m_pChanges != NULL)
strFile = (*m_pInternal->m_pChanges)[nIndex];
return CJSContext::createString(strFile);
}
JSSmart<CJSValue> CNativeControlEmbed::Save_AllocNative(JSSmart<CJSValue> nLen)
{
int Len = nLen->toInt32();
m_pInternal->Save_Alloc(Len);
return CJSContext::createUint8Array(m_pInternal->m_pSaveBinary, m_pInternal->m_nSaveLen);
}
JSSmart<CJSValue> CNativeControlEmbed::Save_ReAllocNative(JSSmart<CJSValue> pos, JSSmart<CJSValue> len)
{
int _pos = pos->toInt32();
int _len = len->toInt32();
m_pInternal->Save_ReAlloc(_pos, _len);
return CJSContext::createUint8Array(m_pInternal->m_pSaveBinary, m_pInternal->m_nSaveLen);
}
JSSmart<CJSValue> CNativeControlEmbed::Save_End(JSSmart<CJSValue> pos, JSSmart<CJSValue> len)
{
std::string sHeader = pos->toStringA();
int _len = len->toInt32();
m_pInternal->Save_End(sHeader, _len);
return NULL;
}
JSSmart<CJSValue> CNativeControlEmbed::AddImageInChanges(JSSmart<CJSValue> img)
{
std::wstring sImage = img->toStringW();
if (sImage.empty())
return NULL;
std::map<std::wstring, bool>::const_iterator iter = m_pInternal->m_mapImagesInChanges.find(sImage);
if (iter == m_pInternal->m_mapImagesInChanges.end())
m_pInternal->m_mapImagesInChanges.insert(std::pair<std::wstring, bool>(sImage, true));
return NULL;
}
JSSmart<CJSValue> CNativeControlEmbed::ConsoleLog(JSSmart<CJSValue> message)
{
m_pInternal->ConsoleLog(message->toStringA());
return NULL;
}
JSSmart<CJSValue> CNativeControlEmbed::SaveChanges(JSSmart<CJSValue> sParam, JSSmart<CJSValue> nDeleteIndex, JSSmart<CJSValue> nCount)
{
m_pInternal->DumpChanges(sParam->toStringA(), nDeleteIndex->toInt32(), nCount->toInt32());
return NULL;
}
JSSmart<CJSValue> CNativeControlEmbed::zipOpenFile(JSSmart<CJSValue> name)
{
bool bIsOpen = m_pInternal->m_oZipWorker.Open(name->toStringW());
if (!bIsOpen)
return CJSContext::createNull();
JSSmart<CJSObject> obj = CJSContext::createObject();
for (std::vector<std::wstring>::iterator i = m_pInternal->m_oZipWorker.m_arFiles.begin(); i != m_pInternal->m_oZipWorker.m_arFiles.end(); i++)
{
std::string sFile = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(*i);
obj->set(sFile.c_str(), CJSContext::createString(sFile));
}
return obj->toValue();
}
JSSmart<CJSValue> CNativeControlEmbed::zipOpenFileBase64(JSSmart<CJSValue> name)
{
bool bIsOpen = m_pInternal->m_oZipWorker.OpenBase64(name->toStringA());
if (!bIsOpen)
return CJSContext::createNull();
JSSmart<CJSObject> obj = CJSContext::createObject();
for (std::vector<std::wstring>::iterator i = m_pInternal->m_oZipWorker.m_arFiles.begin(); i != m_pInternal->m_oZipWorker.m_arFiles.end(); i++)
{
std::string sFile = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(*i);
obj->set(sFile.c_str(), CJSContext::createString(sFile));
}
return obj->toValue();
}
JSSmart<CJSValue> CNativeControlEmbed::zipGetFileAsString(JSSmart<CJSValue> name)
{
BYTE* pData = NULL;
DWORD len = 0;
m_pInternal->m_oZipWorker.GetFileData(name->toStringW(), pData, len);
return CJSContext::createString((char*)pData, len);
}
JSSmart<CJSValue> CNativeControlEmbed::zipGetFileAsBinary(JSSmart<CJSValue> name)
{
BYTE* pData = NULL;
DWORD len = 0;
m_pInternal->m_oZipWorker.GetFileData(name->toStringW(), pData, len);
return CJSContext::createUint8Array(pData, (int)len);
}
JSSmart<CJSValue> CNativeControlEmbed::zipCloseFile()
{
m_pInternal->m_oZipWorker.Close();
return NULL;
}
JSSmart<CJSValue> CNativeControlEmbed::GetImageUrl(JSSmart<CJSValue> sUrl)
{
std::wstring Url = sUrl->toStringW();
if (!m_pInternal->m_pWorker)
m_pInternal->m_pWorker = new CImagesWorker(m_pInternal->m_strImagesDirectory);
std::wstring sRet = m_pInternal->m_pWorker->GetImage(Url);
return CJSContext::createString(sRet);
}
JSSmart<CJSValue> CNativeControlEmbed::GetImagesPath()
{
return CJSContext::createString(m_pInternal->m_strImagesDirectory);
}

51
DesktopEditor/doctrenderer/js_internal/embed/NativeControlEmbed.h Normal file
View File

@ -0,0 +1,51 @@
#ifndef _BUILD_NATIVE_NATIVECONTROL_EMBED_H_
#define _BUILD_NATIVE_NATIVECONTROL_EMBED_H_
#include "../../nativecontrol.h"
#include "../js_base.h"
using namespace NSJSBase;
class CNativeControlEmbed : public CJSEmbedObject
{
public:
NSNativeControl::CNativeControl* m_pInternal;
// ASC::CZipWorker m_oZipWorker;
public:
CNativeControlEmbed() : m_pInternal(new NSNativeControl::CNativeControl()) {}
~CNativeControlEmbed() { RELEASEOBJECT(m_pInternal); }
virtual void* getObject() { return (void*)m_pInternal; }
public:
JSSmart<CJSValue> SetFilePath(JSSmart<CJSValue> path);
JSSmart<CJSValue> GetFilePath();
JSSmart<CJSValue> SetFileId(JSSmart<CJSValue> fileId);
JSSmart<CJSValue> GetFileId();
JSSmart<CJSValue> GetFileBinary(JSSmart<CJSValue> file);
JSSmart<CJSValue> GetFontBinary(JSSmart<CJSValue> file);
JSSmart<CJSValue> GetFontsDirectory();
JSSmart<CJSValue> GetFileString(JSSmart<CJSValue> file);
JSSmart<CJSValue> GetEditorType();
JSSmart<CJSValue> CheckNextChange();
JSSmart<CJSValue> GetCountChanges();
JSSmart<CJSValue> GetChangesFile(JSSmart<CJSValue> index);
JSSmart<CJSValue> Save_AllocNative(JSSmart<CJSValue> nLen);
JSSmart<CJSValue> Save_ReAllocNative(JSSmart<CJSValue> pos, JSSmart<CJSValue> len);
JSSmart<CJSValue> Save_End(JSSmart<CJSValue> pos, JSSmart<CJSValue> len);
JSSmart<CJSValue> AddImageInChanges(JSSmart<CJSValue> img);
JSSmart<CJSValue> ConsoleLog(JSSmart<CJSValue> message);
JSSmart<CJSValue> SaveChanges(JSSmart<CJSValue> sParam, JSSmart<CJSValue> nDeleteIndex, JSSmart<CJSValue> nCount);
JSSmart<CJSValue> zipOpenFile(JSSmart<CJSValue> name);
JSSmart<CJSValue> zipOpenFileBase64(JSSmart<CJSValue> name);
JSSmart<CJSValue> zipGetFileAsString(JSSmart<CJSValue> name);
JSSmart<CJSValue> zipGetFileAsBinary(JSSmart<CJSValue> name);
JSSmart<CJSValue> zipCloseFile();
JSSmart<CJSValue> GetImageUrl(JSSmart<CJSValue> sUrl);
JSSmart<CJSValue> GetImagesPath();
static void CreateObjectInContext(const std::string& name, JSSmart<CJSContext> context);
static void CreateObjectBuilderInContext(const std::string& name, JSSmart<CJSContext> context);
};
#endif // _BUILD_NATIVE_NATIVECONTROL_EMBED_H_

9
DesktopEditor/doctrenderer/js_internal/embed/v8/v8_Graphics.cpp
View File

@ -195,12 +195,13 @@ namespace NSGraphics
PROPERTY_GET(_g_IsUseFonts2, g_IsUseFonts2, v8::Boolean)
PROPERTY_GET(_g_ClearMode, g_ClearMode, v8::Boolean)
PROPERTY_GET(_g_IsRetina, g_IsRetina, v8::Boolean)
//PROPERTY_GET_OBJECT(_g_m_oCurFont, g_m_oCurFont)
//PROPERTY_GET_OBJECT(_g_LastFontOriginInfo, g_LastFontOriginInfo)
// PROPERTY_GET_OBJECT(_g_m_oCurFont, g_m_oCurFont)
// PROPERTY_GET_OBJECT(_g_LastFontOriginInfo, g_LastFontOriginInfo)
PROPERTY_GET(_g_TextureFillTransformScaleX, g_TextureFillTransformScaleX, v8::Int32)
PROPERTY_GET(_g_TextureFillTransformScaleY, g_TextureFillTransformScaleY, v8::Int32)
PROPERTY_GET(_g_globalAlpha, g_globalAlpha, v8::Int32)
// PROPERTY SET
PROPERTY_SET_OBJECT(_s_m_oContext, s_m_oContext)
PROPERTY_SET_OBJECT(_s_m_oPen, s_m_oPen)
PROPERTY_SET_OBJECT(_s_m_oBrush, s_m_oBrush)
@ -236,8 +237,8 @@ namespace NSGraphics
PROPERTY_SET_BOOL(_s_IsUseFonts2, s_IsUseFonts2)
PROPERTY_SET_BOOL(_s_ClearMode, s_ClearMode)
PROPERTY_SET_BOOL(_s_IsRetina, s_IsRetina)
//PROPERTY_SET_OBJECT(_s_m_oCurFont, s_m_oCurFont)
//PROPERTY_SET_OBJECT(_s_LastFontOriginInfo, s_LastFontOriginInfo)
// PROPERTY_SET_OBJECT(_s_m_oCurFont, s_m_oCurFont)
// PROPERTY_SET_OBJECT(_s_LastFontOriginInfo, s_LastFontOriginInfo)
PROPERTY_SET_INT(_s_TextureFillTransformScaleX, s_TextureFillTransformScaleX)
PROPERTY_SET_INT(_s_TextureFillTransformScaleY, s_TextureFillTransformScaleY)
PROPERTY_SET_INT(_s_globalAlpha, s_globalAlpha)

68
DesktopEditor/doctrenderer/js_internal/embed/v8/v8_MemoryStream.cpp Normal file
View File

@ -0,0 +1,68 @@
#include "../MemoryStreamEmbed.h"
#include "../../v8/v8_base.h"
namespace NSMemoryStream
{
#define CURRENTWRAPPER CMemoryStreamEmbed
FUNCTION_WRAPPER_V8_1(_ms_write_byte, WriteByte)
FUNCTION_WRAPPER_V8_1(_ms_write_bool, WriteBool)
FUNCTION_WRAPPER_V8_1(_ms_write_long, WriteLong)
FUNCTION_WRAPPER_V8_1(_ms_write_double, WriteDouble)
FUNCTION_WRAPPER_V8_1(_ms_write_double2, WriteDouble2)
FUNCTION_WRAPPER_V8_1(_ms_writestringA, WriteStringA)
FUNCTION_WRAPPER_V8_1(_ms_writestring1, WriteString)
FUNCTION_WRAPPER_V8_1(_ms_writestring2, WriteString2)
FUNCTION_WRAPPER_V8_3(_ms_copy, Copy)
FUNCTION_WRAPPER_V8(_ms_clearnoattack, ClearNoAttack)
void _ms_pos(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& args)
{
CMemoryStreamEmbed* _this = (CMemoryStreamEmbed*)unwrap_native(args.This());
args.GetReturnValue().Set(v8::Integer::New(CV8Worker::GetCurrent(), _this->m_pInternal->GetSize()));
}
v8::Handle<v8::ObjectTemplate> CreateMemoryStreamTemplate(v8::Isolate* isolate)
{
v8::EscapableHandleScope handle_scope(isolate);
v8::Local<v8::ObjectTemplate> result = v8::ObjectTemplate::New();
result->SetInternalFieldCount(1);
// property
result->SetAccessor(v8::String::NewFromUtf8(CV8Worker::GetCurrent(), "pos"), _ms_pos);
NSV8Objects::Template_Set(result, "Copy", _ms_copy);
NSV8Objects::Template_Set(result, "ClearNoAttack", _ms_clearnoattack);
NSV8Objects::Template_Set(result, "WriteByte", _ms_write_byte);
NSV8Objects::Template_Set(result, "WriteBool", _ms_write_bool);
NSV8Objects::Template_Set(result, "WriteLong", _ms_write_long);
NSV8Objects::Template_Set(result, "WriteDouble", _ms_write_double);
NSV8Objects::Template_Set(result, "WriteDouble2", _ms_write_double2);
NSV8Objects::Template_Set(result, "WriteStringA", _ms_writestringA);
NSV8Objects::Template_Set(result, "WriteString", _ms_writestring1);
NSV8Objects::Template_Set(result, "WriteString2", _ms_writestring2);
return handle_scope.Escape(result);
}
void CreateNativeMemoryStream(const v8::FunctionCallbackInfo<v8::Value>& args)
{
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
v8::Handle<v8::ObjectTemplate> MemoryObjectTemplate = NSMemoryStream::CreateMemoryStreamTemplate(isolate);
CMemoryStreamEmbed* pMemoryObject = new CMemoryStreamEmbed();
v8::Local<v8::Object> obj = MemoryObjectTemplate->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
obj->SetInternalField(0, v8::External::New(CV8Worker::GetCurrent(), pMemoryObject));
args.GetReturnValue().Set(obj);
}
}
void CMemoryStreamEmbed::CreateObjectInContext(const std::string& name, JSSmart<CJSContext> context)
{
v8::Isolate* current = CV8Worker::GetCurrent();
context->m_internal->m_global->Set(current, name.c_str(), v8::FunctionTemplate::New(current, NSMemoryStream::CreateNativeMemoryStream));
}

146
DesktopEditor/doctrenderer/js_internal/embed/v8/v8_NativeControl.cpp Normal file
View File

@ -0,0 +1,146 @@
#include "../NativeControlEmbed.h"
#include "../../v8/v8_base.h"
namespace NSNativeControl
{
#define CURRENTWRAPPER CNativeControlEmbed
FUNCTION_WRAPPER_V8(_GetFilePath, GetFilePath)
FUNCTION_WRAPPER_V8_1(_SetFilePath, SetFilePath)
FUNCTION_WRAPPER_V8(_GetFileId, GetFileId)
FUNCTION_WRAPPER_V8_1(_SetFileId, SetFileId)
FUNCTION_WRAPPER_V8_1(_GetFileArrayBuffer, GetFileBinary)
FUNCTION_WRAPPER_V8_1(_GetFontArrayBuffer, GetFontBinary)
FUNCTION_WRAPPER_V8(_GetFontsDirectory, GetFontsDirectory)
FUNCTION_WRAPPER_V8_1(_GetFileString, GetFileString)
FUNCTION_WRAPPER_V8(_GetEditorType, GetEditorType)
FUNCTION_WRAPPER_V8(_CheckNextChange, CheckNextChange)
FUNCTION_WRAPPER_V8(_GetChangesCount, GetCountChanges)
FUNCTION_WRAPPER_V8_1(_GetChangesFile, GetChangesFile)
FUNCTION_WRAPPER_V8_1(_Save_AllocNative, Save_AllocNative)
FUNCTION_WRAPPER_V8_2(_Save_ReAllocNative, Save_ReAllocNative)
FUNCTION_WRAPPER_V8_2(_Save_End, Save_End)
FUNCTION_WRAPPER_V8_1(_AddImageInChanges, AddImageInChanges)
FUNCTION_WRAPPER_V8_1(_ConsoleLog, ConsoleLog)
FUNCTION_WRAPPER_V8_3(_SaveChanges, SaveChanges)
FUNCTION_WRAPPER_V8_1(_zipOpenFile, zipOpenFile)
FUNCTION_WRAPPER_V8_1(_zipOpenFileBase64, zipOpenFileBase64)
FUNCTION_WRAPPER_V8_1(_zipGetFileAsString, zipGetFileAsString)
FUNCTION_WRAPPER_V8_1(_zipGetFileAsBinary, zipGetFileAsBinary)
FUNCTION_WRAPPER_V8(_zipCloseFile, zipCloseFile)
FUNCTION_WRAPPER_V8_1(_GetImageUrl, GetImageUrl)
FUNCTION_WRAPPER_V8(_GetImagesPath, GetImagesPath)
v8::Handle<v8::ObjectTemplate> CreateNativeControlTemplate(v8::Isolate* isolate)
{
v8::EscapableHandleScope handle_scope(isolate);
v8::Local<v8::ObjectTemplate> result = v8::ObjectTemplate::New();
result->SetInternalFieldCount(1);
NSV8Objects::Template_Set(result, "SetFilePath", _SetFilePath);
NSV8Objects::Template_Set(result, "GetFilePath", _GetFilePath);
NSV8Objects::Template_Set(result, "SetFileId", _SetFileId);
NSV8Objects::Template_Set(result, "GetFileId", _GetFileId);
NSV8Objects::Template_Set(result, "GetFileBinary", _GetFileArrayBuffer);
NSV8Objects::Template_Set(result, "GetFontBinary", _GetFontArrayBuffer);
NSV8Objects::Template_Set(result, "GetFontsDirectory", _GetFontsDirectory);
NSV8Objects::Template_Set(result, "GetFileString", _GetFileString);
NSV8Objects::Template_Set(result, "GetEditorType", _GetEditorType);
NSV8Objects::Template_Set(result, "CheckNextChange", _CheckNextChange);
NSV8Objects::Template_Set(result, "GetCountChanges", _GetChangesCount);
NSV8Objects::Template_Set(result, "GetChangesFile", _GetChangesFile);
NSV8Objects::Template_Set(result, "Save_AllocNative", _Save_AllocNative);
NSV8Objects::Template_Set(result, "Save_ReAllocNative", _Save_ReAllocNative);
NSV8Objects::Template_Set(result, "Save_End", _Save_End);
NSV8Objects::Template_Set(result, "AddImageInChanges", _AddImageInChanges);
NSV8Objects::Template_Set(result, "ConsoleLog", _ConsoleLog);
NSV8Objects::Template_Set(result, "SaveChanges", _SaveChanges);
NSV8Objects::Template_Set(result, "ZipOpen", _zipOpenFile);
NSV8Objects::Template_Set(result, "ZipOpenBase64", _zipOpenFileBase64);
NSV8Objects::Template_Set(result, "ZipFileAsString", _zipGetFileAsString);
NSV8Objects::Template_Set(result, "ZipFileAsBinary", _zipGetFileAsBinary);
NSV8Objects::Template_Set(result, "ZipClose", _zipCloseFile);
NSV8Objects::Template_Set(result, "getImageUrl", _GetImageUrl);
NSV8Objects::Template_Set(result, "getImagesDirectory", _GetImagesPath);
return handle_scope.Escape(result);
}
// Без SaveChanges
v8::Handle<v8::ObjectTemplate> CreateNativeControlTemplateBuilder(v8::Isolate* isolate)
{
v8::EscapableHandleScope handle_scope(isolate);
v8::Local<v8::ObjectTemplate> result = v8::ObjectTemplate::New();
result->SetInternalFieldCount(1);
NSV8Objects::Template_Set(result, "SetFilePath", _SetFilePath);
NSV8Objects::Template_Set(result, "GetFilePath", _GetFilePath);
NSV8Objects::Template_Set(result, "SetFileId", _SetFileId);
NSV8Objects::Template_Set(result, "GetFileId", _GetFileId);
NSV8Objects::Template_Set(result, "GetFileBinary", _GetFileArrayBuffer);
NSV8Objects::Template_Set(result, "GetFontBinary", _GetFontArrayBuffer);
NSV8Objects::Template_Set(result, "GetFontsDirectory", _GetFontsDirectory);
NSV8Objects::Template_Set(result, "GetFileString", _GetFileString);
NSV8Objects::Template_Set(result, "GetEditorType", _GetEditorType);
NSV8Objects::Template_Set(result, "CheckNextChange", _CheckNextChange);
NSV8Objects::Template_Set(result, "GetCountChanges", _GetChangesCount);
NSV8Objects::Template_Set(result, "GetChangesFile", _GetChangesFile);
NSV8Objects::Template_Set(result, "Save_AllocNative", _Save_AllocNative);
NSV8Objects::Template_Set(result, "Save_ReAllocNative", _Save_ReAllocNative);
NSV8Objects::Template_Set(result, "Save_End", _Save_End);
NSV8Objects::Template_Set(result, "AddImageInChanges", _AddImageInChanges);
NSV8Objects::Template_Set(result, "ConsoleLog", _ConsoleLog);
NSV8Objects::Template_Set(result, "ZipOpen", _zipOpenFile);
NSV8Objects::Template_Set(result, "ZipOpenBase64", _zipOpenFileBase64);
NSV8Objects::Template_Set(result, "ZipFileAsString", _zipGetFileAsString);
NSV8Objects::Template_Set(result, "ZipFileAsBinary", _zipGetFileAsBinary);
NSV8Objects::Template_Set(result, "ZipClose", _zipCloseFile);
NSV8Objects::Template_Set(result, "getImageUrl", _GetImageUrl);
NSV8Objects::Template_Set(result, "getImagesDirectory", _GetImagesPath);
return handle_scope.Escape(result);
}
void CreateNativeObject(const v8::FunctionCallbackInfo<v8::Value>& args)
{
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
v8::Handle<v8::ObjectTemplate> NativeObjectTemplate = CreateNativeControlTemplate(isolate);
CNativeControlEmbed* pNativeObject = new CNativeControlEmbed();
v8::Local<v8::Object> obj = NativeObjectTemplate->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
obj->SetInternalField(0, v8::External::New(CV8Worker::GetCurrent(), pNativeObject));
args.GetReturnValue().Set(obj);
}
// Без SaveChanges
void CreateNativeObjectBuilder(const v8::FunctionCallbackInfo<v8::Value>& args)
{
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope scope(isolate);
v8::Handle<v8::ObjectTemplate> NativeObjectTemplate = CreateNativeControlTemplateBuilder(isolate);
CNativeControlEmbed* pNativeObject = new CNativeControlEmbed();
v8::Local<v8::Object> obj = NativeObjectTemplate->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
obj->SetInternalField(0, v8::External::New(CV8Worker::GetCurrent(), pNativeObject));
args.GetReturnValue().Set(obj);
}
}
void CNativeControlEmbed::CreateObjectInContext(const std::string& name, JSSmart<CJSContext> context)
{
v8::Isolate* current = CV8Worker::GetCurrent();
context->m_internal->m_global->Set(current, name.c_str(), v8::FunctionTemplate::New(current, NSNativeControl::CreateNativeObject));
}
void CNativeControlEmbed::CreateObjectBuilderInContext(const std::string& name, JSSmart<CJSContext> context)
{
v8::Isolate* current = CV8Worker::GetCurrent();
context->m_internal->m_global->Set(current, name.c_str(), v8::FunctionTemplate::New(current, NSNativeControl::CreateNativeObjectBuilder));
}

147
DesktopEditor/doctrenderer/memorystream.cpp
View File

@ -1,147 +0,0 @@
/*
* (c) Copyright Ascensio System SIA 2010-2019
*
* 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-12 Ernesta Birznieka-Upisha
* 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 "memorystream.h"
// wrap_methods -------------
CMemoryStream* unwrap_memorystream(v8::Handle<v8::Object> obj)
{
v8::Handle<v8::External> field = v8::Handle<v8::External>::Cast(obj->GetInternalField(0));
return static_cast<CMemoryStream*>(field->Value());
}
void _ms_write_byte(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CMemoryStream* pNative = unwrap_memorystream(args.This());
BYTE arg = (BYTE)CV8Convert::ToInt(args[0]);
pNative->WriteBYTE(arg);
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
}
void _ms_write_bool(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CMemoryStream* pNative = unwrap_memorystream(args.This());
BYTE arg = (BYTE)CV8Convert::ToBool(args[0]);
pNative->WriteBYTE(arg ? 1 : 0);
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
}
void _ms_write_long(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CMemoryStream* pNative = unwrap_memorystream(args.This());
LONG arg = (LONG)CV8Convert::ToInt(args[0]);
pNative->WriteLONG(arg);
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
}
void _ms_write_double(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CMemoryStream* pNative = unwrap_memorystream(args.This());
double arg = CV8Convert::ToDouble(args[0]);
pNative->WriteLONG((LONG)(arg * 100000));
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
}
void _ms_writestring1(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CMemoryStream* pNative = unwrap_memorystream(args.This());
v8::String::Value data(ISOLATE_IF_7 args[0]);
pNative->WriteString((wchar_t*)*data, data.length());
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
}
void _ms_writestring2(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CMemoryStream* pNative = unwrap_memorystream(args.This());
v8::String::Value data(ISOLATE_IF_7 args[0]);
pNative->WriteString2((wchar_t*)*data, data.length());
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
}
void _ms_copy(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CMemoryStream* pNative = unwrap_memorystream(args.This());
CMemoryStream* pNative2 = unwrap_memorystream(args[0]->ToObject());
size_t pos = (size_t)CV8Convert::ToUint(args[1]);
size_t len = (size_t)CV8Convert::ToUint(args[2]);
pNative->Copy(pNative2, pos, len);
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
}
void _ms_clearnoattack(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CMemoryStream* pNative = unwrap_memorystream(args.This());
pNative->ClearNoAttack();
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
}
void _ms_pos(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
{
CMemoryStream* pNative = unwrap_memorystream(info.Holder());
info.GetReturnValue().Set(v8::Integer::New(v8::Isolate::GetCurrent(), pNative->GetSize()));
}
v8::Handle<v8::ObjectTemplate> CreateMemoryStreamTemplate(v8::Isolate* isolate)
{
//v8::HandleScope handle_scope(isolate);
v8::Local<v8::ObjectTemplate> result = v8::ObjectTemplate::New(isolate);
result->SetInternalFieldCount(1); // отводим в нем место для хранения CNativeControl
v8::Isolate* current = v8::Isolate::GetCurrent();
// property
result->SetAccessor(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), "pos"), _ms_pos); // получить код ошибки
// прописываем функции - методы объекта
result->Set(current, "Copy", v8::FunctionTemplate::New(current, _ms_copy));
result->Set(current, "ClearNoAttack", v8::FunctionTemplate::New(current, _ms_clearnoattack));
result->Set(current, "WriteByte", v8::FunctionTemplate::New(current, _ms_write_byte));
result->Set(current, "WriteBool", v8::FunctionTemplate::New(current, _ms_write_bool));
result->Set(current, "WriteLong", v8::FunctionTemplate::New(current, _ms_write_long));
result->Set(current, "WriteDouble", v8::FunctionTemplate::New(current, _ms_write_double));
result->Set(current, "WriteString", v8::FunctionTemplate::New(current, _ms_writestring1));
result->Set(current, "WriteString2", v8::FunctionTemplate::New(current, _ms_writestring2));
// возвращаем временный хэндл хитрым образом, который переносит наш хэндл в предыдущий HandleScope и не дает ему
// уничтожиться при уничтожении "нашего" HandleScope - handle_scope
//return handle_scope.Close(result);
return result;
}

101
DesktopEditor/doctrenderer/memorystream.h
View File

@ -36,60 +36,8 @@
#include "../common/Types.h"
#include "../common/File.h"
#include "v8.h"
#include "libplatform/libplatform.h"
#if V8_MAJOR_VERSION < 7
#define ISOLATE_IF_7
#else
#define ISOLATE_IF_7 v8::Isolate::GetCurrent(),
#endif
class CV8Convert
namespace NSMemoryStream
{
public:
static int ToInt(const v8::Local<v8::Value>& v)
{
return v->ToInt32(v8::Isolate::GetCurrent()->GetCurrentContext()).FromMaybe(v8::Local<v8::Int32>())->Value();
}
static unsigned int ToUint(const v8::Local<v8::Value>& v)
{
return v->ToUint32(v8::Isolate::GetCurrent()->GetCurrentContext()).FromMaybe(v8::Local<v8::Uint32>())->Value();
}
static double ToDouble(const v8::Local<v8::Value>& v)
{
return v->ToNumber(v8::Isolate::GetCurrent()->GetCurrentContext()).FromMaybe(v8::Local<v8::Number>())->Value();
}
static bool ToBool(const v8::Local<v8::Value>& v)
{
return v->ToBoolean(v8::Isolate::GetCurrent()->GetCurrentContext()).FromMaybe(v8::Local<v8::Boolean>())->Value();
}
static std::wstring ToString(v8::Local<v8::Value> v)
{
v8::String::Utf8Value data(ISOLATE_IF_7 v);
if (NULL == *data)
return L"";
return NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)(*data), data.length());
}
static std::string ToStringA(v8::Local<v8::Value> v)
{
v8::String::Utf8Value data(ISOLATE_IF_7 v);
const char* p = (char*)*data;
if (NULL == p)
return "";
return std::string(p);
}
static std::wstring GetSourceLine(const v8::Local<v8::Message>& m)
{
return ToString(m->GetSourceLine(v8::Isolate::GetCurrent()->GetCurrentContext()).FromMaybe(v8::Local<v8::String>()));
}
static std::wstring GetMessage(const v8::Local<v8::Message>& m)
{
return ToString(m->Get());
}
};
class CMemoryStream
{
private:
@ -216,7 +164,19 @@ public:
m_pBufferMem += sizeof(USHORT);
int nLen2 = nLen << 1;
memcpy(m_pBufferMem, pData, nLen2);
if (sizeof(wchar_t) == 2)
{
memcpy(m_pBufferMem, pData, nLen2);
}
else
{
int len = nLen >> 1;
USHORT* mass = new USHORT[len];
for (int i = 0; i < len; ++i)
mass[i] = (USHORT)pData[i];
memcpy(m_pBufferMem, mass, nLen2);
RELEASEARRAYOBJECTS(mass);
}
m_pBufferMem += nLen2;
}
inline void WriteString2(const wchar_t* pData, int nLen)
@ -227,29 +187,22 @@ public:
*((LONG*)(m_pBufferMem)) = (LONG)nLen2;
m_pBufferMem += sizeof(LONG);
memcpy(m_pBufferMem, pData, nLen2);
if (sizeof(wchar_t) == 2)
{
memcpy(m_pBufferMem, pData, nLen2);
}
else
{
USHORT* mass = new USHORT[nLen];
for (int i = 0; i < nLen; ++i)
mass[i] = (USHORT)pData[i];
memcpy(m_pBufferMem, mass, nLen2);
RELEASEARRAYOBJECTS(mass);
}
m_pBufferMem += nLen2;
}
};
// wrap_methods -------------
CMemoryStream* unwrap_memorystream(v8::Handle<v8::Object> obj);
void _ms_write_byte(const v8::FunctionCallbackInfo<v8::Value>& args);
void _ms_write_bool(const v8::FunctionCallbackInfo<v8::Value>& args);
void _ms_write_long(const v8::FunctionCallbackInfo<v8::Value>& args);
void _ms_write_double(const v8::FunctionCallbackInfo<v8::Value>& args);
void _ms_writestring1(const v8::FunctionCallbackInfo<v8::Value>& args);
void _ms_writestring2(const v8::FunctionCallbackInfo<v8::Value>& args);
void _ms_copy(const v8::FunctionCallbackInfo<v8::Value>& args);
void _ms_clearnoattack(const v8::FunctionCallbackInfo<v8::Value>& args);
void _ms_pos(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info);
v8::Handle<v8::ObjectTemplate> CreateMemoryStreamTemplate(v8::Isolate* isolate);
}
#endif // MEMORYSTREAM

33
DesktopEditor/doctrenderer/nativebuilder.cpp
View File

@ -31,6 +31,7 @@
*/
#include "nativebuilder.h"
#include "docbuilder_p.h"
#include "js_internal/v8/v8_base.h"
void CBuilderDocumentEmbed::OpenFile(const std::wstring& sFile, const std::wstring& sParams)
{
@ -80,7 +81,7 @@ CBuilderDocumentEmbed* unwrap_builder_doc_embed(v8::Handle<v8::Object> obj)
return static_cast<CBuilderDocumentEmbed*>(field->Value());
}
void _builder_OpenFile(const v8::FunctionCallbackInfo<v8::Value>& args)
JSSmart<CJSValue> builder_OpenFile(JSSmart<CJSValue> sPath, JSSmart<CJSValue> sParams)
{
CBuilderEmbed* builder = unwrap_builder_embed(args.This());
std::wstring sPath = CV8Convert::ToString(args[0]);
@ -184,6 +185,9 @@ void _builder_doc_GetImageMap(const v8::FunctionCallbackInfo<v8::Value>& args)
}
/////////////////////////////////////////////////////////////////////////////////
v8::Local<v8::Value> _builder_CreateNativeTmpDoc(v8::Isolate* isolate, NSDoctRenderer::CDocBuilder* pBuilder, const std::wstring& sFile, const std::wstring& sParams)
{
v8::Local<v8::ObjectTemplate> _template = v8::ObjectTemplate::New(isolate);
@ -224,3 +228,30 @@ v8::Local<v8::Value> _builder_CreateNative(v8::Isolate* isolate, NSDoctRenderer:
return obj;
}
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));
}
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));
}
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);

19
DesktopEditor/doctrenderer/nativebuilder.h
View File

@ -34,6 +34,7 @@
#include "nativecontrol.h"
#include "docbuilder.h"
#include "js_internal/js_base.h"
namespace NSDoctRenderer
{
@ -75,21 +76,7 @@ public:
void CloseFile();
};
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);
v8::Local<v8::Value> _builder_CreateNativeTmpDoc(v8::Isolate* isolate, NSDoctRenderer::CDocBuilder* pBuilder, const std::wstring& sFile, const std::wstring& sParams);
v8::Local<v8::Value> _builder_CreateNative(v8::Isolate* isolate, NSDoctRenderer::CDocBuilder* builder);
void builder_CreateNative(const std::string& name, JSSmart<CJSContext> context, NSDoctRenderer::CDocBuilder* builder);
void builder_CreateNativeTmpDoc(const std::string& name, JSSmart<CJSContext> context, NSDoctRenderer::CDocBuilder* builder, const std::wstring& sFile, const std::wstring& sParams);
#endif // NATIVECONTROLBUILDER

526
DesktopEditor/doctrenderer/nativecontrol.cpp
View File

@ -121,529 +121,3 @@ std::wstring CImagesWorker::GetImage(const std::wstring& sUrl)
return sUrlFile;
return L"error";
}
// wrap_methods -------------
CNativeControl* unwrap_nativeobject(v8::Handle<v8::Object> obj)
{
v8::Handle<v8::External> field = v8::Handle<v8::External>::Cast(obj->GetInternalField(0));
return static_cast<CNativeControl*>(field->Value());
}
void _GetFilePath(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CNativeControl* pNative = unwrap_nativeobject(args.This());
std::string sReturn = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(pNative->GetFilePath());
args.GetReturnValue().Set(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sReturn.c_str()));
}
void _SetFilePath(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());
pNative->SetFilePath(CV8Convert::ToString(args[0]));
}
void _GetImagesPath(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CNativeControl* pNative = unwrap_nativeobject(args.This());
std::string sReturn = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(pNative->m_strImagesDirectory);
args.GetReturnValue().Set(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sReturn.c_str()));
}
void _GetFontsDirectory(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CNativeControl* pNative = unwrap_nativeobject(args.This());
std::string sReturn = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(pNative->m_strFontsDirectory);
args.GetReturnValue().Set(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sReturn.c_str()));
}
void _GetEditorType(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CNativeControl* pNative = unwrap_nativeobject(args.This());
std::string sReturn = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(pNative->m_strEditorType);
args.GetReturnValue().Set(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sReturn.c_str()));
}
void _GetChangesCount(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CNativeControl* pNative = unwrap_nativeobject(args.This());
int nCount = 0;
if (pNative->m_pChanges != NULL)
nCount = (int)pNative->m_pChanges->GetCount();
args.GetReturnValue().Set(v8::Integer::New(v8::Isolate::GetCurrent(), nCount));
}
void _GetChangesFile(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CNativeControl* pNative = unwrap_nativeobject(args.This());
if (args.Length() < 1)
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
int nIndex = CV8Convert::ToInt(args[0]);
std::string strFile = "";
if (pNative->m_pChanges != NULL)
strFile = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(pNative->m_pChanges->operator []((int)nIndex));
args.GetReturnValue().Set(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), strFile.c_str()));
}
void _GetFileId(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CNativeControl* pNative = unwrap_nativeobject(args.This());
std::string sReturn = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(pNative->GetFileId());
args.GetReturnValue().Set(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sReturn.c_str()));
}
void _SetFileId(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());
pNative->SetFileId(CV8Convert::ToString(args[0]));
}
void _CheckNextChange(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CNativeControl* pNative = unwrap_nativeobject(args.This());
pNative->m_nCurrentChangesNumber++;
if (-1 != pNative->m_nMaxChangesNumber)
{
if (pNative->m_nCurrentChangesNumber >= pNative->m_nMaxChangesNumber)
{
args.GetReturnValue().Set(v8::Boolean::New(v8::Isolate::GetCurrent(), false));
return;
}
}
args.GetReturnValue().Set(v8::Boolean::New(v8::Isolate::GetCurrent(), true));
}
void _GetFileArrayBuffer(const v8::FunctionCallbackInfo<v8::Value>& args)
{
if (args.Length() < 1)
{
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
return;
}
CNativeControl* pNative = unwrap_nativeobject(args.This());
BYTE* pData = NULL;
DWORD len = 0;
pNative->getFileData(CV8Convert::ToString(args[0]), pData, len);
v8::Local<v8::ArrayBuffer> _buffer = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), (void*)pData, (size_t)len);
v8::Local<v8::Uint8Array> _array = v8::Uint8Array::New(_buffer, 0, (size_t)len);
args.GetReturnValue().Set(_array);
}
void _GetFontArrayBuffer(const v8::FunctionCallbackInfo<v8::Value>& args)
{
if (args.Length() < 1)
{
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
return;
}
CNativeControl* pNative = unwrap_nativeobject(args.This());
BYTE* pData = NULL;
DWORD len = 0;
std::wstring strDir = pNative->m_strFontsDirectory;
#if 0
if (strDir.length() != 0)
{
strDir += L"/";
strDir += CV8Convert::ToString(args[0]);
}
else
#endif
// TODO:
// по идее файлы могут совпадать по имени, но лежать в разных директориях.
// и поэтому в AllFonts.js надо бы писать пути полные.
// пока оставим по-старому
std::wstring sFind = CV8Convert::ToString(args[0]);
bool bIsFullFilePath = (std::wstring::npos != sFind.find('\\') || std::wstring::npos != sFind.find('/'));
if (bIsFullFilePath)
{
bIsFullFilePath = NSFile::CFileBinary::Exists(sFind);
}
if (!bIsFullFilePath)
{
std::map<std::wstring, std::wstring>::iterator pair = pNative->m_map_fonts.find(sFind);
if (pair != pNative->m_map_fonts.end())
strDir = pair->second;
else
strDir = pNative->m_sDefaultFont;
}
else
{
strDir = sFind;
}
pNative->getFileData(strDir, pData, len);
v8::Local<v8::ArrayBuffer> _buffer = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), (void*)pData, (size_t)len);
v8::Local<v8::Uint8Array> _array = v8::Uint8Array::New(_buffer, 0, (size_t)len);
args.GetReturnValue().Set(_array);
}
void _GetFileString(const v8::FunctionCallbackInfo<v8::Value>& args)
{
if (args.Length() < 1)
{
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
return;
}
CNativeControl* pNative = unwrap_nativeobject(args.This());
BYTE* pData = NULL;
DWORD len = 0;
pNative->getFileData(CV8Convert::ToString(args[0]), pData, len);
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());
int nLen = CV8Convert::ToInt(args[0]);
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 = CV8Convert::ToInt(args[0]);
int _len = CV8Convert::ToInt(args[1]);
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());
std::string sHeader = CV8Convert::ToStringA(args[0]);
int _len = CV8Convert::ToInt(args[1]);
pNative->Save_End(sHeader, _len);
}
void _ConsoleLog(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());
pNative->ConsoleLog(CV8Convert::ToStringA(args[0]));
}
void _SaveChanges(const v8::FunctionCallbackInfo<v8::Value>& args)
{
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
if (args.Length() < 3)
return;
CNativeControl* pNative = unwrap_nativeobject(args.This());
pNative->DumpChanges(CV8Convert::ToStringA(args[0]), CV8Convert::ToInt(args[1]), CV8Convert::ToInt(args[2]));
}
/// ZIP -----
void _zipOpenFile(const v8::FunctionCallbackInfo<v8::Value>& args)
{
if (args.Length() < 1)
{
args.GetReturnValue().Set(v8::Null(v8::Isolate::GetCurrent()));
return;
}
CNativeControl* pNative = unwrap_nativeobject(args.This());
bool bIsOpen = pNative->m_oZipWorker.Open(CV8Convert::ToString(args[0]));
if (!bIsOpen)
{
args.GetReturnValue().Set(v8::Null(v8::Isolate::GetCurrent()));
return;
}
v8::Local<v8::Object> obj = v8::Object::New(v8::Isolate::GetCurrent());
for (std::vector<std::wstring>::iterator i = pNative->m_oZipWorker.m_arFiles.begin(); i != pNative->m_oZipWorker.m_arFiles.end(); i++)
{
std::string sFile = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(*i);
v8::Local<v8::String> _k = v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sFile.c_str(), v8::String::kNormalString, -1);
v8::Local<v8::String> _v = v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sFile.c_str(), v8::String::kNormalString, -1);
obj->Set(_k, _v);
}
args.GetReturnValue().Set(obj);
}
void _zipOpenFileBase64(const v8::FunctionCallbackInfo<v8::Value>& args)
{
if (args.Length() < 1)
{
args.GetReturnValue().Set(v8::Null(v8::Isolate::GetCurrent()));
return;
}
CNativeControl* pNative = unwrap_nativeobject(args.This());
bool bIsOpen = pNative->m_oZipWorker.OpenBase64(CV8Convert::ToStringA(args[0]));
if (!bIsOpen)
{
args.GetReturnValue().Set(v8::Null(v8::Isolate::GetCurrent()));
return;
}
v8::Local<v8::Object> obj = v8::Object::New(v8::Isolate::GetCurrent());
for (std::vector<std::wstring>::iterator i = pNative->m_oZipWorker.m_arFiles.begin(); i != pNative->m_oZipWorker.m_arFiles.end(); i++)
{
std::string sFile = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(*i);
v8::Local<v8::String> _k = v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sFile.c_str(), v8::String::kNormalString, -1);
v8::Local<v8::String> _v = v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sFile.c_str(), v8::String::kNormalString, -1);
obj->Set(_k, _v);
}
args.GetReturnValue().Set(obj);
}
void _zipGetFileAsString(const v8::FunctionCallbackInfo<v8::Value>& args)
{
if (args.Length() < 1)
{
args.GetReturnValue().Set(v8::Null(v8::Isolate::GetCurrent()));
return;
}
CNativeControl* pNative = unwrap_nativeobject(args.This());
BYTE* pData = NULL;
DWORD len = 0;
pNative->m_oZipWorker.GetFileData(CV8Convert::ToString(args[0]), pData, len);
args.GetReturnValue().Set(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), (char*)pData, v8::String::kNormalString, len));
}
void _zipGetFileAsBinary(const v8::FunctionCallbackInfo<v8::Value>& args)
{
if (args.Length() < 1)
{
args.GetReturnValue().Set(v8::Null(v8::Isolate::GetCurrent()));
return;
}
CNativeControl* pNative = unwrap_nativeobject(args.This());
BYTE* pData = NULL;
DWORD len = 0;
pNative->m_oZipWorker.GetFileData(CV8Convert::ToString(args[0]), pData, len);
v8::Local<v8::ArrayBuffer> _buffer = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), (void*)pData, (size_t)len);
v8::Local<v8::Uint8Array> _array = v8::Uint8Array::New(_buffer, 0, (size_t)len);
args.GetReturnValue().Set(_array);
}
void _zipCloseFile(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CNativeControl* pNative = unwrap_nativeobject(args.This());
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
pNative->m_oZipWorker.Close();
}
/// ---------
void _AddImageInChanges(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());
std::wstring sImage = CV8Convert::ToString(args[0]);
if (sImage.empty())
return;
std::map<std::wstring, bool>::const_iterator iter = pNative->m_mapImagesInChanges.find(sImage);
if (iter == pNative->m_mapImagesInChanges.end())
pNative->m_mapImagesInChanges.insert(std::pair<std::wstring, bool>(sImage, true));
}
// GetImageUrl
void _GetImageUrl(const v8::FunctionCallbackInfo<v8::Value>& args)
{
CNativeControl* pNative = unwrap_nativeobject(args.This());
std::wstring sUrl = CV8Convert::ToString(args[0]);
if (!pNative->m_pWorker)
pNative->m_pWorker = new CImagesWorker(pNative->m_strImagesDirectory);
std::wstring sRet = pNative->m_pWorker->GetImage(sUrl);
std::string sRetA = U_TO_UTF8(sRet);
args.GetReturnValue().Set(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), (char*)sRetA.c_str(), v8::String::kNormalString, (int)sRetA.length()));
}
v8::Handle<v8::ObjectTemplate> CreateNativeControlTemplate(v8::Isolate* isolate)
{
//v8::HandleScope handle_scope(isolate);
v8::Local<v8::ObjectTemplate> result = v8::ObjectTemplate::New(isolate);
result->SetInternalFieldCount(1); // отводим в нем место для хранения CNativeControl
v8::Isolate* current = v8::Isolate::GetCurrent();
// прописываем функции - методы объекта
result->Set(current, "SetFilePath", v8::FunctionTemplate::New(current, _SetFilePath));
result->Set(current, "GetFilePath", v8::FunctionTemplate::New(current, _GetFilePath));
result->Set(current, "SetFileId", v8::FunctionTemplate::New(current, _SetFileId));
result->Set(current, "GetFileId", v8::FunctionTemplate::New(current, _GetFileId));
result->Set(current, "GetFileBinary", v8::FunctionTemplate::New(current, _GetFileArrayBuffer));
result->Set(current, "GetFontBinary", v8::FunctionTemplate::New(current, _GetFontArrayBuffer));
result->Set(current, "GetFontsDirectory", v8::FunctionTemplate::New(current, _GetFontsDirectory));
result->Set(current, "GetFileString", v8::FunctionTemplate::New(current, _GetFileString));
result->Set(current, "GetEditorType", v8::FunctionTemplate::New(current, _GetEditorType));
result->Set(current, "CheckNextChange", v8::FunctionTemplate::New(current, _CheckNextChange));
result->Set(current, "GetCountChanges", v8::FunctionTemplate::New(current, _GetChangesCount));
result->Set(current, "GetChangesFile", v8::FunctionTemplate::New(current, _GetChangesFile));
result->Set(current, "Save_AllocNative", v8::FunctionTemplate::New(current, _Save_AllocNative));
result->Set(current, "Save_ReAllocNative", v8::FunctionTemplate::New(current, _Save_ReAllocNative));
result->Set(current, "Save_End", v8::FunctionTemplate::New(current, _Save_End));
result->Set(current, "AddImageInChanges", v8::FunctionTemplate::New(current, _AddImageInChanges));
result->Set(current, "ConsoleLog", v8::FunctionTemplate::New(current, _ConsoleLog));
result->Set(current, "ZipOpen", v8::FunctionTemplate::New(current, _zipOpenFile));
result->Set(current, "ZipOpenBase64", v8::FunctionTemplate::New(current, _zipOpenFileBase64));
result->Set(current, "ZipFileAsString", v8::FunctionTemplate::New(current, _zipGetFileAsString));
result->Set(current, "ZipFileAsBinary", v8::FunctionTemplate::New(current, _zipGetFileAsBinary));
result->Set(current, "ZipClose", v8::FunctionTemplate::New(current, _zipCloseFile));
result->Set(current, "getImageUrl", v8::FunctionTemplate::New(current, _GetImageUrl));
result->Set(current, "getImagesDirectory", v8::FunctionTemplate::New(current, _GetImagesPath));
// возвращаем временный хэндл хитрым образом, который переносит наш хэндл в предыдущий HandleScope и не дает ему
// уничтожиться при уничтожении "нашего" HandleScope - handle_scope
//return handle_scope.Close(result);
return result;
}
v8::Handle<v8::ObjectTemplate> CreateNativeControlTemplateBuilder(v8::Isolate* isolate)
{
//v8::HandleScope handle_scope(isolate);
v8::Local<v8::ObjectTemplate> result = v8::ObjectTemplate::New(isolate);
result->SetInternalFieldCount(1); // отводим в нем место для хранения CNativeControl
v8::Isolate* current = v8::Isolate::GetCurrent();
// прописываем функции - методы объекта
result->Set(current, "SetFilePath", v8::FunctionTemplate::New(current, _SetFilePath));
result->Set(current, "GetFilePath", v8::FunctionTemplate::New(current, _GetFilePath));
result->Set(current, "SetFileId", v8::FunctionTemplate::New(current, _SetFileId));
result->Set(current, "GetFileId", v8::FunctionTemplate::New(current, _GetFileId));
result->Set(current, "GetFileBinary", v8::FunctionTemplate::New(current, _GetFileArrayBuffer));
result->Set(current, "GetFontBinary", v8::FunctionTemplate::New(current, _GetFontArrayBuffer));
result->Set(current, "GetFontsDirectory", v8::FunctionTemplate::New(current, _GetFontsDirectory));
result->Set(current, "GetFileString", v8::FunctionTemplate::New(current, _GetFileString));
result->Set(current, "GetEditorType", v8::FunctionTemplate::New(current, _GetEditorType));
result->Set(current, "CheckNextChange", v8::FunctionTemplate::New(current, _CheckNextChange));
result->Set(current, "GetCountChanges", v8::FunctionTemplate::New(current, _GetChangesCount));
result->Set(current, "GetChangesFile", v8::FunctionTemplate::New(current, _GetChangesFile));
result->Set(current, "Save_AllocNative", v8::FunctionTemplate::New(current, _Save_AllocNative));
result->Set(current, "Save_ReAllocNative", v8::FunctionTemplate::New(current, _Save_ReAllocNative));
result->Set(current, "Save_End", v8::FunctionTemplate::New(current, _Save_End));
result->Set(current, "AddImageInChanges", v8::FunctionTemplate::New(current, _AddImageInChanges));
result->Set(current, "ConsoleLog", v8::FunctionTemplate::New(current, _ConsoleLog));
result->Set(current, "SaveChanges", v8::FunctionTemplate::New(current, _SaveChanges));
result->Set(current, "ZipOpen", v8::FunctionTemplate::New(current, _zipOpenFile));
result->Set(current, "ZipOpenBase64", v8::FunctionTemplate::New(current, _zipOpenFileBase64));
result->Set(current, "ZipFileAsString", v8::FunctionTemplate::New(current, _zipGetFileAsString));
result->Set(current, "ZipFileAsBinary", v8::FunctionTemplate::New(current, _zipGetFileAsBinary));
result->Set(current, "ZipClose", v8::FunctionTemplate::New(current, _zipCloseFile));
result->Set(current, "getImageUrl", v8::FunctionTemplate::New(current, _GetImageUrl));
result->Set(current, "getImagesDirectory", v8::FunctionTemplate::New(current, _GetImagesPath));
// возвращаем временный хэндл хитрым образом, который переносит наш хэндл в предыдущий HandleScope и не дает ему
// уничтожиться при уничтожении "нашего" HandleScope - handle_scope
//return handle_scope.Close(result);
return result;
}
// --------------------------
/*
void CV8Worker::Initialize()
{
if (NULL == m_pInitializer)
m_pInitializer = new CV8Initializer();
}
void CV8Worker::Dispose()
{
if (NULL != m_pInitializer)
delete m_pInitializer;
m_pInitializer = NULL;
}
CV8Initializer* CV8Worker::getInitializer()
{
if (NULL == m_pInitializer)
{
m_pInitializer = new CV8Initializer();
}
return CV8Worker::m_pInitializer;
}
CV8Initializer* CV8Worker::m_pInitializer = NULL;*/
// --------------------------

134
DesktopEditor/doctrenderer/nativecontrol.h
View File

@ -41,7 +41,7 @@
#include "../common/Array.h"
#include "../../OfficeUtils/src/OfficeUtils.h"
#include "memorystream.h"
#include "js_internal/embed/MemoryStreamEmbed.h"
#include "../fontengine/application_generate_fonts_common.h"
#if defined(CreateDirectory)
@ -193,6 +193,8 @@ public:
std::wstring GetImage(const std::wstring& sUrl);
};
namespace NSNativeControl
{
class CNativeControl
{
private:
@ -233,7 +235,7 @@ public:
CImagesWorker* m_pWorker;
public:
CMemoryStream* m_pStream;
CMemoryStreamEmbed* m_pStream;
CNativeControl()
{
@ -455,56 +457,7 @@ public:
}
}
};
// wrap_methods -------------
CNativeControl* unwrap_nativeobject(v8::Handle<v8::Object> obj);
void _GetFilePath(const v8::FunctionCallbackInfo<v8::Value>& args);
void _SetFilePath(const v8::FunctionCallbackInfo<v8::Value>& args);
void _GetImagesPath(const v8::FunctionCallbackInfo<v8::Value>& args);
void _GetFontsDirectory(const v8::FunctionCallbackInfo<v8::Value>& args);
void _GetEditorType(const v8::FunctionCallbackInfo<v8::Value>& args);
void _GetChangesCount(const v8::FunctionCallbackInfo<v8::Value>& args);
void _GetChangesFile(const v8::FunctionCallbackInfo<v8::Value>& args);
void _GetFileId(const v8::FunctionCallbackInfo<v8::Value>& args);
void _SetFileId(const v8::FunctionCallbackInfo<v8::Value>& args);
void _CheckNextChange(const v8::FunctionCallbackInfo<v8::Value>& args);
void _GetFileArrayBuffer(const v8::FunctionCallbackInfo<v8::Value>& args);
void _GetFontArrayBuffer(const v8::FunctionCallbackInfo<v8::Value>& args);
void _GetFileString(const v8::FunctionCallbackInfo<v8::Value>& args);
void _Save_AllocNative(const v8::FunctionCallbackInfo<v8::Value>& args);
void _Save_ReAllocNative(const v8::FunctionCallbackInfo<v8::Value>& args);
void _Save_End(const v8::FunctionCallbackInfo<v8::Value>& args);
void _ConsoleLog(const v8::FunctionCallbackInfo<v8::Value>& args);
void _SaveChanges(const v8::FunctionCallbackInfo<v8::Value>& args);
void _GetImageUrl(const v8::FunctionCallbackInfo<v8::Value>& args);
/// ZIP -----
void _zipOpenFile(const v8::FunctionCallbackInfo<v8::Value>& args);
void _zipOpenFileBase64(const v8::FunctionCallbackInfo<v8::Value>& args);
void _zipGetFileAsString(const v8::FunctionCallbackInfo<v8::Value>& args);
void _zipGetFileAsBinary(const v8::FunctionCallbackInfo<v8::Value>& args);
void _zipCloseFile(const v8::FunctionCallbackInfo<v8::Value>& args);
/// ---------
void _AddImageInChanges(const v8::FunctionCallbackInfo<v8::Value>& args);
v8::Handle<v8::ObjectTemplate> CreateNativeControlTemplate(v8::Isolate* isolate);
v8::Handle<v8::ObjectTemplate> CreateNativeControlTemplateBuilder(v8::Isolate* isolate);
// --------------------------
}
class CChangesWorker
{
@ -1041,10 +994,6 @@ private:
//////////////////////////////////////////////////////////////////////////////
void CreateNativeObject(const v8::FunctionCallbackInfo<v8::Value>& args);
void CreateNativeObjectBuilder(const v8::FunctionCallbackInfo<v8::Value>& args);
void CreateNativeMemoryStream(const v8::FunctionCallbackInfo<v8::Value>& args);
#if 0
class CLoggerSpeed
{
@ -1201,79 +1150,6 @@ public:
#endif
//////////////////////////////////////////////////////////////////////////////
class CV8Initializer
{
private:
v8::Platform* m_platform;
v8::ArrayBuffer::Allocator* m_pAllocator;
public:
CV8Initializer()
{
std::wstring sPrW = NSFile::GetProcessPath();
std::string sPrA = U_TO_UTF8(sPrW);
m_pAllocator = NULL;
#ifndef V8_OS_XP
v8::V8::InitializeICUDefaultLocation(sPrA.c_str());
v8::V8::InitializeExternalStartupData(sPrA.c_str());
m_platform = v8::platform::CreateDefaultPlatform();
v8::V8::InitializePlatform(m_platform);
v8::V8::Initialize();
#else
m_platform = v8::platform::CreateDefaultPlatform();
v8::V8::InitializePlatform(m_platform);
v8::V8::Initialize();
v8::V8::InitializeICU();
#endif
}
~CV8Initializer()
{
v8::V8::Dispose();
v8::V8::ShutdownPlatform();
delete m_platform;
if (m_pAllocator)
delete m_pAllocator;
}
v8::ArrayBuffer::Allocator* getAllocator()
{
return m_pAllocator;
}
v8::Isolate* CreateNew()
{
v8::Isolate::CreateParams create_params;
#ifndef V8_OS_XP
m_pAllocator = v8::ArrayBuffer::Allocator::NewDefaultAllocator();
#else
m_pAllocator = new ExternalMallocArrayBufferAllocator();
#endif
create_params.array_buffer_allocator = m_pAllocator;
return v8::Isolate::New(create_params);
}
};
/*
class CV8Worker
{
private:
static CV8Initializer* m_pInitializer;
public:
CV8Worker() {}
~CV8Worker() {}
static void Initialize();
static void Dispose();
static CV8Initializer* getInitializer();
};
*/
bool Doct_renderer_SaveFile_ForBuilder(int nFormat, const std::wstring& strDstFile,
CNativeControl* pNative,
v8::Isolate* isolate,