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

linux build

Browse Source 
git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@58961 954022d7-b5bf-4e40-9824-e11837661b57
This commit is contained in:
Ivan.Shulga
2014-10-16 15:04:19 +00:00
committed by Alexander Trofimov
parent c081265e9d
commit b972455aeb
6 changed files with 169 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
ASCOfficePPTXFile/ASCOfficeDrawingConverter.cpp
View File

@ -3808,6 +3808,22 @@ HRESULT CDrawingConverter::SetFontPicker(COfficeFontPicker* pFontPicker)
m_pBinaryWriter->m_pCommon->CreateFontPicker(pFontPicker);
return S_OK;
}
HRESULT CDrawingConverter::SetAdditionalParam(const CString& ParamName, BYTE *pArray, size_t szCount)
{
CString name = (CString)ParamName;
if (name == _T("SerializeImageManager"))
{
NSBinPptxRW::CBinaryFileReader oReader;
oReader.Deserialize(m_pBinaryWriter->m_pCommon->m_pImageManager, pArray, szCount);
}
else if (name == _T("SerializeImageManager2"))
{
NSBinPptxRW::CBinaryFileReader oReader;
oReader.Deserialize(m_pImageManager, pArray, szCount);
}
return S_OK;
}
HRESULT CDrawingConverter::SetAdditionalParam(const CString& ParamName, VARIANT ParamValue)
{
CString name = (CString)ParamName;
@ -3827,40 +3843,70 @@ HRESULT CDrawingConverter::SetAdditionalParam(const CString& ParamName, VARIANT
{
m_bIsUseConvertion2007 = (ParamValue.boolVal == VARIANT_TRUE) ? true : false;
}
else if (name == _T("SerializeImageManager"))
else if (name == _T("SerializeImageManager"))
{
NSBinPptxRW::CBinaryFileReader oReader;
oReader.Deserialize(m_pBinaryWriter->m_pCommon->m_pImageManager, ParamValue.parray);
// moved to CDrawingConverter::SetAdditionalParam(const CString& ParamName, BYTE **pArray, size_t& szCount)
return S_FALSE;
//NSBinPptxRW::CBinaryFileReader oReader;
//oReader.Deserialize(m_pBinaryWriter->m_pCommon->m_pImageManager, ParamValue.parray);
}
else if (name == _T("SerializeImageManager2"))
{
NSBinPptxRW::CBinaryFileReader oReader;
oReader.Deserialize(m_pImageManager, ParamValue.parray);
}
// moved to CDrawingConverter::SetAdditionalParam(const CString& ParamName, BYTE **pArray, size_t& szCount)
return S_FALSE;
//NSBinPptxRW::CBinaryFileReader oReader;
//oReader.Deserialize(m_pImageManager, ParamValue.parray);
}
else if (name == _T("DocumentChartsCount") && ParamValue.vt == VT_I4)
{
m_pReader->m_lChartNumber = ParamValue.lVal + 1;
}
return S_OK;
}
HRESULT CDrawingConverter::GetAdditionalParam(const CString& ParamName, BYTE **pArray, size_t& szCount)
{
CString name = (CString)ParamName;
if (name == _T("SerializeImageManager"))
{
NSBinPptxRW::CBinaryFileWriter oWriter;
return oWriter.Serialize(m_pBinaryWriter->m_pCommon->m_pImageManager, pArray, szCount) ? S_OK : S_FALSE;
}
else if (name == _T("SerializeImageManager2"))
{
NSBinPptxRW::CBinaryFileWriter oWriter;
return oWriter.Serialize(m_pImageManager, pArray, szCount) ? S_OK : S_FALSE;
}
return S_OK;
}
HRESULT CDrawingConverter::GetAdditionalParam(const CString& ParamName, VARIANT* ParamValue)
{
CString name = (CString)ParamName;
if (name == _T("SerializeImageManager"))
if (name == _T("SerializeImageManager"))
{
// moved to GetAdditionalParam(const CString& ParamName, BYTE **pArray, size_t& szCount)
return S_FALSE;
/*
NSBinPptxRW::CBinaryFileWriter oWriter;
ParamValue->vt = VT_ARRAY;
ParamValue->parray = oWriter.Serialize(m_pBinaryWriter->m_pCommon->m_pImageManager);
*/
}
else if (name == _T("SerializeImageManager2"))
{
// moved to GetAdditionalParam(const CString& ParamName, BYTE **pArray, size_t& szCount)
return S_FALSE;
/*
NSBinPptxRW::CBinaryFileWriter oWriter;
ParamValue->vt = VT_ARRAY;
ParamValue->parray = oWriter.Serialize(m_pImageManager);
*/
}
else if (name == _T("DocumentChartsCount"))
else if (name == _T("DocumentChartsCount"))
{
ParamValue->vt = VT_I4;
ParamValue->lVal = m_pReader->m_lChartNumber;
@ -3868,7 +3914,11 @@ HRESULT CDrawingConverter::GetAdditionalParam(const CString& ParamName, VARIANT*
else if (name == _T("ContentTypes"))
{
ParamValue->vt = VT_BSTR;
#ifdef _WIN32
ParamValue->bstrVal = m_pReader->m_strContentTypes.AllocSysString();
#else
ParamValue->bstrVal = m_pReader->m_strContentTypes;
#endif
}
return S_OK;
}

2
ASCOfficePPTXFile/ASCOfficeDrawingConverter.h
View File

@ -203,7 +203,9 @@ namespace NSBinPptxRW
HRESULT(SetFontDir)(const CString& bsFontDir);
HRESULT SetFontPicker(COfficeFontPicker* pFontPicker);
HRESULT(SetAdditionalParam)(const CString& ParamName, BYTE **pArray, size_t& szCount);
HRESULT(SetAdditionalParam)(const CString& ParamName, VARIANT ParamValue);
HRESULT(GetAdditionalParam)(const CString& ParamName, BYTE **pArray, size_t& szCount);
HRESULT(GetAdditionalParam)(const CString& ParamName, VARIANT* ParamValue);
public:
void SetFontManager(CFontManager* pFontManager);

37
ASCOfficePPTXFile/ASCOfficeDrawingConverterComInterface.h
View File

@ -219,10 +219,43 @@ public:
STDMETHOD(SetAdditionalParam)(BSTR ParamName, VARIANT ParamValue)
{
return m_oDrawingConverter.SetAdditionalParam(CString(ParamName), ParamValue);
CString name = (CString)ParamName;
if (name == _T("SerializeImageManager") || name == _T("SerializeImageManager2"))
{
#ifdef _WIN32
return m_oDrawingConverter.SetAdditionalParam(CString(ParamName), (BYTE*) pArray->pvData, pArrayData->rgsabound[0].cElements);
#endif
return S_OK;
}
else
return m_oDrawingConverter.SetAdditionalParam(CString(ParamName), ParamValue);
}
STDMETHOD(GetAdditionalParam)(BSTR ParamName, VARIANT* ParamValue)
{
return m_oDrawingConverter.GetAdditionalParam(CString(ParamName), ParamValue);
// convert
CString name = (CString)ParamName;
if (name == _T("SerializeImageManager") || name == _T("SerializeImageManager2"))
{
BYTE* pBuffer = NULL;
size_t nCount = 0;
HRESULT hRes = m_oDrawingConverter.GetAdditionalParam(CString(ParamName), &pBuffer, nCount);
if (S_OK == hRes && NULL != pBuffer)
{
#ifdef _WIN32
SAFEARRAY* pArray = SafeArrayCreateVector(VT_UI1, nCount);
BYTE* pDataD = (BYTE*) pArray->pvData;
memcpy(pDataD, pBuffer, nCount);
ParamValue->vt = VT_ARRAY;
ParamValue->parray = pArray;
#endif
}
delete [] pBuffer;
return hRes;
}
else
return m_oDrawingConverter.GetAdditionalParam(CString(ParamName), ParamValue);
}
};

72
ASCOfficePPTXFile/Editor/BinaryFileReaderWriter.cpp
View File

@ -730,17 +730,33 @@ namespace NSBinPptxRW
}
// serialize ImageManagers
LPSAFEARRAY CBinaryFileWriter::Serialize(NSBinPptxRW::CImageManager2* pManager)
bool CBinaryFileWriter::Serialize(NSBinPptxRW::CImageManager2* pManager, BYTE **ppArray, size_t& szCount)
{
pManager->Serialize(this);
return GetSafearray();
return GetSafearray(ppArray, szCount);
}
LPSAFEARRAY CBinaryFileWriter::Serialize(NSShapeImageGen::CImageManager* pManager)
bool CBinaryFileWriter::Serialize(NSShapeImageGen::CImageManager* pManager, BYTE **ppArray, size_t& szCount)
{
pManager->Serialize(this);
return GetSafearray();
return GetSafearray(ppArray, szCount);
}
bool CBinaryFileWriter::GetSafearray(BYTE **ppArray, size_t& szCount)
{
if (NULL == ppArray)
return false;
ULONG lBinarySize = this->GetPosition();
if (0 == lBinarySize)
return false;
*ppArray = new BYTE [lBinarySize];
szCount = lBinarySize;
memcpy(*ppArray, this->GetBuffer(), lBinarySize);
return true;
}
/*
LPSAFEARRAY CBinaryFileWriter::GetSafearray()
{
ULONG lBinarySize = this->GetPosition();
@ -755,6 +771,7 @@ namespace NSBinPptxRW
return pArray;
}
*/
CSlideMasterInfo::CSlideMasterInfo() : m_arLayouts()
{
m_lThemeIndex = -1;
@ -1189,23 +1206,40 @@ namespace NSBinPptxRW
return res;
}
LPSAFEARRAY CBinaryFileReader::GetArray(LONG len)
bool CBinaryFileReader::GetArray(BYTE **pBuffer, LONG len)
{
if (0 == len)
return NULL;
return false;
if (m_lPos + len > m_lSize)
return NULL;
return false;
SAFEARRAY* pArray = SafeArrayCreateVector(VT_UI1, (ULONG)len);
*pBuffer = new BYTE [len];
BYTE* pDataD = (BYTE*)pArray->pvData;
memcpy(pDataD, m_pDataCur, len);
memcpy(pBuffer, m_pDataCur, len);
m_lPos += len;
m_pDataCur += len;
return pArray;
return true;
}
/*LPSAFEARRAY CBinaryFileReader::GetArray(LONG len)
{
if (0 == len)
return NULL;
if (m_lPos + len > m_lSize)
return NULL;
SAFEARRAY* pArray = SafeArrayCreateVector(VT_UI1, (ULONG)len);
BYTE* pDataD = (BYTE*)pArray->pvData;
memcpy(pDataD, m_pDataCur, len);
m_lPos += len;
m_pDataCur += len;
return pArray;
}
*/
CStringA CBinaryFileReader::GetString2A()
{
@ -1244,18 +1278,20 @@ namespace NSBinPptxRW
return res;
}
void CBinaryFileReader::Deserialize(NSBinPptxRW::CImageManager2* pManager, LPSAFEARRAY pArray)
void CBinaryFileReader::Deserialize(NSBinPptxRW::CImageManager2* pManager, BYTE* pData, LONG nSize/*, LPSAFEARRAY pArray*/)
{
BYTE* pData = (BYTE*)pArray->pvData;
this->Init(pData, 0, pArray->rgsabound[0].cElements);
//BYTE* pData = (BYTE*)pArray->pvData;
//this->Init(pData, 0, pArray->rgsabound[0].cElements);
this->Init(pData, 0, nSize);
pManager->Deserialize(this);
}
void CBinaryFileReader::Deserialize(NSShapeImageGen::CImageManager* pManager, LPSAFEARRAY pArray)
void CBinaryFileReader::Deserialize(NSShapeImageGen::CImageManager* pManager, BYTE* pData, LONG nSize/*, LPSAFEARRAY pArray*/)
{
BYTE* pData = (BYTE*)pArray->pvData;
this->Init(pData, 0, pArray->rgsabound[0].cElements);
//BYTE* pData = (BYTE*)pArray->pvData;
//this->Init(pData, 0, pArray->rgsabound[0].cElements);
this->Init(pData, 0, nSize);
pManager->Deserialize(this);
}
}
}

13
ASCOfficePPTXFile/Editor/BinaryFileReaderWriter.h
View File

@ -324,10 +324,10 @@ namespace NSBinPptxRW
void WriteEmbeddedFonts();
// serialize ImageManagers
LPSAFEARRAY Serialize(NSBinPptxRW::CImageManager2* pManager);
LPSAFEARRAY Serialize(NSShapeImageGen::CImageManager* pManager);
bool Serialize(NSBinPptxRW::CImageManager2* pManager, BYTE **ppArray, size_t& szCount);
bool Serialize(NSShapeImageGen::CImageManager* pManager, BYTE **ppArray, size_t& szCount);
LPSAFEARRAY GetSafearray();
bool GetSafearray(BYTE **ppArray, size_t& szCount);
};
class CSlideMasterInfo
{
@ -445,7 +445,8 @@ namespace NSBinPptxRW
CString GetString2();
CString GetString3(LONG len);
LPSAFEARRAY GetArray(LONG len);
//LPSAFEARRAY GetArray(LONG len);
bool GetArray(BYTE **pBuffer, LONG len);
CStringA GetString2A();
void SkipRecord();
@ -457,7 +458,7 @@ namespace NSBinPptxRW
BYTE* GetData();
BYTE* GetPointer(int nSize);
public:
void Deserialize(NSBinPptxRW::CImageManager2* pManager, LPSAFEARRAY pArray);
void Deserialize(NSShapeImageGen::CImageManager* pManager, LPSAFEARRAY pArray);
void Deserialize(NSBinPptxRW::CImageManager2* pManager, BYTE* pData, LONG nSize/*, LPSAFEARRAY pArray*/);
void Deserialize(NSShapeImageGen::CImageManager* pManager, BYTE* pData, LONG nSize/*, LPSAFEARRAY pArray*/);
};
}

14
Common/DocxFormat/Source/SystemUtility/File.h
View File

@ -343,6 +343,11 @@ namespace CDirectory
{
return ::CreateDirectory(strFolderPath, NULL);
}
static BOOL DeleteFile (CString strFileName)
{
::DeleteFile (strFileName);
return TRUE;
}
static BOOL MoveFile(CString strExists, CString strNew, LPPROGRESS_ROUTINE lpFunc, LPVOID lpData)
{
@ -676,7 +681,9 @@ namespace StreamUtils
#else
#include <iostream>
#include <fstream>
#include <fstream> // instream
#include <unistd.h> // unlink
#include "../../../DesktopEditor/common/Types.h"
#include "../../../DesktopEditor/common/File.h"
class CFile: public NSFile::CFileBinary
@ -972,6 +979,11 @@ namespace CDirectory
fwrite (aContentUtf8.c_str() , sizeof(char), aContentUtf8.size(), pFile);
fclose (pFile);
}
static bool DeleteFile (CString strFileName)
{
std::string aFileNameUtf8 = stringWstingToUtf8String (strFileName);
return 0 == unlink (aFileNameUtf8.c_str());
}
static CString ToString(DWORD val)
{
CString str = _T("");