Yajbir-Malik/DocumentServer-v-9.2.0
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
DocumentServer-v-9.2.0/core/OOXML/Binary/Presentation/BinaryFileReaderWriter.cpp
T
Yajbir Singh f1b860b25c
check / markdownlint (push) Has been cancelled
Details
check / spellchecker (push) Has been cancelled
Details
updated
2025-12-11 19:03:17 +05:30

2436 lines
67 KiB
C++
Raw Permalink Blame History

/*
* (c) Copyright Ascensio System SIA 2010-2023
*
* This program is a free software product. You can redistribute it and/or
* modify it under the terms of the GNU Affero General Public License (AGPL)
* version 3 as published by the Free Software Foundation. In accordance with
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
* that Ascensio System SIA expressly excludes the warranty of non-infringement
* of any third-party rights.
*
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
*
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
* street, Riga, Latvia, EU, LV-1050.
*
* The interactive user interfaces in modified source and object code versions
* of the Program must display Appropriate Legal Notices, as required under
* Section 5 of the GNU AGPL version 3.
*
* Pursuant to Section 7(b) of the License you must retain the original Product
* logo when distributing the program. Pursuant to Section 7(e) we decline to
* grant you any rights under trademark law for use of our trademarks.
*
* All the Product's GUI elements, including illustrations and icon sets, as
* well as technical writing content are licensed under the terms of the
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
*
*/
#include "BinaryFileReaderWriter.h"
#include "BinReaderWriterDefines.h"
#include "../../Base/Nullable.h"
#include "../../DocxFormat/WritingElement.h"
#include "../../DocxFormat/Media/OleObject.h"
#include "../../DocxFormat/Media/ActiveX.h"
#include "../../DocxFormat/Media/Video.h"
#include "../../DocxFormat/Media/Audio.h"
#include "../../DocxFormat/Media/VbaProject.h"
#include "../../DocxFormat/Media/JsaProject.h"
#include "../../../Common/Base64.h"
#include "./imagemanager.h"
#include "./XmlWriter.h"
#include "./FontPicker.h"
#include "../../Binary/Document/DocWrapper/DocxSerializer.h"
#include "../../../DesktopEditor/common/File.h"
#include "../../../DesktopEditor/common/Directory.h"
#include "../../../DesktopEditor/raster/ImageFileFormatChecker.h"
#include "../../../DesktopEditor/raster/Metafile/MetaFile.h"
#include "../../PPTXFormat/FileContainer.h"
#include <iostream>
#ifndef DISABLE_FILE_DOWNLOADER
#include "../../../Common/Network/FileTransporter/include/FileTransporter.h"
#endif
#define BYTE_SIZEOF sizeof(BYTE)
#define UINT16_SIZEOF sizeof(_UINT16)
#define UINT32_SIZEOF sizeof(_UINT32)
#define DOUBLE_SIZEOF sizeof(double)
#define CHAR_SIZEOF sizeof(CHAR)
#define INT16_SIZEOF sizeof(_INT16)
#define INT32_SIZEOF sizeof(_INT32)
#define INT64_SIZEOF sizeof(_INT64)
#define DOUBLE_MAIN 10000
#if defined(_WIN32) || defined (_WIN64)
#include "../../Base/unicode_util.h"
#endif
namespace NSBinPptxRW
{
template <typename T,unsigned S>
inline unsigned arraysize(const T (&v)[S]) { return S; }
CCommonWriter::CCommonWriter()
{
m_pNativePicker = NULL;
m_pFontPicker = NULL;
m_bDeleteFontPicker = true;
m_pMediaManager = new NSShapeImageGen::CMediaManager();
}
CCommonWriter::~CCommonWriter()
{
m_pNativePicker = NULL;
if (m_bDeleteFontPicker)
RELEASEOBJECT(m_pFontPicker);
RELEASEOBJECT(m_pMediaManager);
}
void CCommonWriter::CreateFontPicker(COfficeFontPicker* pPicker)
{
if (m_bDeleteFontPicker)
RELEASEOBJECT(m_pFontPicker);
m_pNativePicker = NULL;
if (pPicker != NULL)
{
m_pFontPicker = pPicker;
m_bDeleteFontPicker = false;
}
else
{
m_pFontPicker = new COfficeFontPicker();
m_bDeleteFontPicker = true;
}
m_pNativePicker = m_pFontPicker->GetNativePicker();
}
void CCommonWriter::CheckFontPicker()
{
if (NULL == m_pFontPicker)
CreateFontPicker(NULL);
}
CImageManager2::CImageManager2() : m_mapImages(), m_lIndexNextImage(0), m_lIndexCounter(0)
{
m_nDocumentType = XMLWRITER_DOC_TYPE_PPTX;
m_pContentTypes = new OOX::CContentTypes();
}
CImageManager2::~CImageManager2()
{
delete m_pContentTypes;
}
void CImageManager2::Clear()
{
m_mapImages.clear();
m_lIndexNextImage = 0;
m_lIndexCounter = 0;
}
void CImageManager2::SetDstFolder(const std::wstring& strDst)
{
m_strDstFolder = strDst;
m_strDstMedia = m_strDstFolder + FILE_SEPARATOR_STR + L"media";
m_strDstEmbed = m_strDstFolder + FILE_SEPARATOR_STR + L"embeddings";
NSDirectory::CreateDirectory(m_strDstMedia);
NSDirectory::CreateDirectory(m_strDstEmbed);
}
std::wstring CImageManager2::GetDstFolder()
{
return m_strDstFolder;
}
void CImageManager2::SetDstMedia(const std::wstring& strDst)
{
m_strDstMedia = strDst;
}
std::wstring CImageManager2::GetDstMedia()
{
return m_strDstMedia;
}
void CImageManager2::SetDstCharts(const std::wstring& strDst)
{
m_strDstCharts = strDst;
}
std::wstring CImageManager2::GetDstCharts()
{
return m_strDstCharts;
}
void CImageManager2::SetDstEmbed(const std::wstring& strDst)
{
m_strDstEmbed = strDst;
}
std::wstring CImageManager2::GetDstEmbed()
{
return m_strDstEmbed;
}
std::wstring CImageManager2::GetDstDiagram()
{
return m_strDstDiagram;
}
void CImageManager2::SetDstDiagram(const std::wstring& strDst)
{
m_strDstDiagram = strDst;
}
int CImageManager2::IsDisplayedImage(const std::wstring& strInput)
{
int nRes = 0;
//шаблон display[N]image.ext
std::wstring sFind1 = L"display";
int nIndex1 = (int)strInput.find(sFind1);
if (-1 != nIndex1)
{
if (nIndex1 + sFind1.length() < strInput.length())
{
wchar_t cRes1 = strInput[nIndex1 + sFind1.length()];
if ('1' <= cRes1 && cRes1 <= '9')
{
wchar_t cRes2 = strInput[nIndex1 + sFind1.length() + 1];
int nImageIndex = nIndex1 + (int)sFind1.length() + 1;
if (std::wstring::npos != strInput.find(L"image", nImageIndex))
{
nRes = cRes1 - '0';
if ('0' <= cRes2 && cRes2 <= '9')
{
nRes = nRes * 10 + (cRes2 - '0');
}
}
}
}
}
return nRes;
}
_imageManager2Info CImageManager2::GenerateMedia(const std::wstring& strInput)
{
std::map<std::wstring, _imageManager2Info>::const_iterator pPair = m_mapImages.find(strInput);
if (pPair != m_mapImages.end())
{
return pPair->second;
}
_imageManager2Info oImageManagerInfo = GenerateMediaExec(strInput);
m_mapImages[strInput] = oImageManagerInfo;
return oImageManagerInfo;
}
_imageManager2Info CImageManager2::GenerateImage(const std::wstring& strInput, std::vector<NSCommon::smart_ptr<OOX::File>>& additionalFiles, const std::wstring& oleData, std::wstring strBase64Image)
{
if (IsNeedDownload(strInput))
return DownloadImage(strInput);
std::map<std::wstring, _imageManager2Info>::const_iterator pPair = m_mapImages.find((strBase64Image.empty()) ? strInput + oleData : strBase64Image + oleData);
std::wstring strExts = L".jpg";
std::wstring strImage = strInput;
//use GetFileName to avoid defining '.' in the directory as extension
std::wstring strFileName = NSFile::GetFileName(strInput);
int sizeExt = (int)strFileName.rfind(wchar_t('.'));
if (-1 != sizeExt)
{
strExts = strFileName.substr(sizeExt);
sizeExt = (int)strFileName.length() - sizeExt;
}
else sizeExt = 0;
int nDisplayType = IsDisplayedImage(strInput);
size_t nFileNameLength = strFileName.length();
std::vector<std::pair<std::wstring, int>> addit;
for (auto additionalFile : additionalFiles)
{
if (pPair != m_mapImages.end())
{
for (auto sFilepathAdditional : pPair->second.sFilepathAdditionals)
{
smart_ptr<OOX::Media> mediaFile = additionalFile.smart_dynamic_cast<OOX::Media>();
if (mediaFile.IsInit())
mediaFile->set_filename(sFilepathAdditional, false);
}
return pPair->second;
}
int typeAdditional = 0;
std::wstring strAdditional;
if (0 != nDisplayType && nFileNameLength > sizeExt)
{
OOX::CPath oPath = strInput;
std::wstring strFolder = oPath.GetDirectory();
std::wstring strFileName = oPath.GetFilename();
strFileName.erase(strFileName.length() - sizeExt, sizeExt);
if (0 != (nDisplayType & 1))
{
std::wstring strVector = strFolder + strFileName + L".wmf";
if (OOX::CSystemUtility::IsFileExist(strVector))
{
strImage = strVector;
strExts = L".wmf";
}
}
if (0 != (nDisplayType & 2))
{
std::wstring strVector = strFolder + strFileName + L".emf";
if (OOX::CSystemUtility::IsFileExist(strVector))
{
m_pContentTypes->AddDefault(L"emf");
strImage = strVector;
strExts = L".emf";
}
}
if (0 != (nDisplayType & 4))
{
smart_ptr<OOX::OleObject> oleFile = additionalFile.smart_dynamic_cast<OOX::OleObject>();
if (oleFile.IsInit())
{
if (OOX::CSystemUtility::IsFileExist(oleFile->filename()) == false)
{
typeAdditional = 1;
std::wstring strOle = strFolder + strFileName + oleFile->filename().GetExtention();
if (OOX::CSystemUtility::IsFileExist(strOle))
{
m_pContentTypes->AddDefault(oleFile->filename().GetExtention(false));
strAdditional = strOle;
}
else
{
strOle = strFolder + strFileName + L".bin";
if (OOX::CSystemUtility::IsFileExist(strOle))
strAdditional = strOle;
}
}
}
}
if (0 != (nDisplayType & 8))
{
smart_ptr<OOX::Media> mediaFile = additionalFile.smart_dynamic_cast<OOX::Media>();
if (mediaFile.IsInit())
{
if (OOX::CSystemUtility::IsFileExist(mediaFile->filename()) == false)
{
typeAdditional = 2;
if (!mediaFile->IsExternal())
{
std::wstring strMedia = strFolder + strFileName + mediaFile->filename().GetExtention();
if (OOX::CSystemUtility::IsFileExist(strMedia))
{
m_pContentTypes->AddDefault(mediaFile->filename().GetExtention(false));
strAdditional = strMedia;
}
else
{
strMedia = strFolder + strFileName;
if (mediaFile.is<OOX::Audio>()) strMedia += L".wav";
if (mediaFile.is<OOX::Video>()) strMedia += L".avi";
if (OOX::CSystemUtility::IsFileExist(strMedia))
strAdditional = strMedia;
}
}
}
}
}
}
if (oleData.empty() == false)
{
//plugins data - generate ole
typeAdditional = 1;
}
addit.push_back(std::make_pair(strAdditional, typeAdditional));
}
if (pPair != m_mapImages.end())
{
return pPair->second;
}
if (false == strExts.empty())
{
m_pContentTypes->AddDefault(strExts.substr(1));
}
if (strExts == L".svg")
{
additionalFiles.emplace_back();
additionalFiles.back() = new OOX::SvgBlip(NULL);
smart_ptr<OOX::Media> mediaFile = additionalFiles.back().smart_dynamic_cast<OOX::Media>();
if (mediaFile.IsInit())
{
mediaFile->set_filename(strImage, false);
addit.push_back(std::make_pair(strImage, 3));
}
}
_imageManager2Info oImageManagerInfo = GenerateImageExec(strImage, strExts, addit, oleData);
//oImageManagerInfo.sFilepathAdditionals <-> additionalFiles
for (size_t i = 0; i < oImageManagerInfo.sFilepathAdditionals.size(); ++i)
{
if (!oImageManagerInfo.sFilepathAdditionals[i].empty())
{
smart_ptr<OOX::Media> mediaFile = additionalFiles[i].smart_dynamic_cast<OOX::Media>();
if (false == mediaFile.IsInit()) //???
{
mediaFile = new OOX::Media(NULL);
additionalFiles[i] = mediaFile.smart_dynamic_cast<OOX::File>();
}
if (mediaFile.IsInit())
{
mediaFile->set_filename(oImageManagerInfo.sFilepathAdditionals[i], false);
}
}
}
if (strBase64Image.empty())
m_mapImages[strInput + oleData] = oImageManagerInfo;
else
m_mapImages[strBase64Image + oleData] = oImageManagerInfo;
return oImageManagerInfo;
}
bool CImageManager2::WriteOleData(const std::wstring& sFilePath, const std::wstring& sData)
{
bool bRes = false;
//EncodingMode.unparsed https://github.com/tonyqus/npoi/blob/master/main/POIFS/FileSystem/Ole10Native.cs
POLE::Storage oStorage(sFilePath.c_str());
if (oStorage.open(true, true))
{
//CompObj Stream
BYTE dataCompObj[] = {0x01,0x00,0xfe,0xff,0x03,0x0a,0x00,0x00,0xff,0xff,0xff,0xff,0x0c,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,0x0c,0x00,0x00,0x00,0x4f,0x4c,0x45,0x20,0x50,0x61,0x63,0x6b,0x61,0x67,0x65,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x50,0x61,0x63,0x6b,0x61,0x67,0x65,0x00,0xf4,0x39,0xb2,0x71,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
POLE::Stream oStream1(&oStorage, L"\001CompObj", true, arraysize(dataCompObj));
oStream1.write(dataCompObj, arraysize(dataCompObj));
oStream1.flush();
//ObjInfo Stream
BYTE dataObjInfo[] = {0x00,0x00,0x03,0x00,0x0d,0x00};
POLE::Stream oStream2(&oStorage, L"\003ObjInfo", true, arraysize(dataObjInfo));
oStream2.write(dataObjInfo, arraysize(dataObjInfo));
oStream2.flush();
//Ole10Native Stream
std::string sDataUtf8 = NSFile::CUtf8Converter::GetUtf8StringFromUnicode2(sData.c_str(), (LONG)sData.size());
BYTE head[] = {0x00,0x00,0x00,0x00};
//LittleEndian
unsigned char* aData = (unsigned char*)sDataUtf8.c_str();
_UINT32 nDataSize = (_UINT32)sDataUtf8.size();
memcpy(head, &nDataSize, sizeof(_UINT32));
POLE::Stream oStream(&oStorage, L"\001Ole10Native", true, arraysize(head) + nDataSize);
oStream.write(head, arraysize(head));
oStream.write(aData, nDataSize);
oStream.flush();
oStorage.close();
bRes = true;
}
return bRes;
}
_imageManager2Info CImageManager2::GenerateMediaExec(const std::wstring& strInput)
{
OOX::CPath oPathOutput;
_imageManager2Info oImageManagerInfo;
std::wstring strExts;
std::wstring strMedia = L"media" + std::to_wstring(++m_lIndexNextImage);
size_t pos = (int)strInput.rfind(L".");
if (pos != std::wstring::npos)
{
strExts = strInput.substr(pos);
m_pContentTypes->AddDefault(strExts.substr(1));
}
oPathOutput = m_strDstMedia + FILE_SEPARATOR_STR + strMedia + strExts;
if (oPathOutput.GetPath() != strInput && NSFile::CFileBinary::Exists(strInput))
{
NSFile::CFileBinary::Copy(strInput, oPathOutput.GetPath());
oImageManagerInfo.sFilepathImage = oPathOutput.GetPath();
}
return oImageManagerInfo;
}
_imageManager2Info CImageManager2::GenerateImageExec(const std::wstring& strInput, const std::wstring& sExts, std::vector<std::pair<std::wstring, int>>& additional, const std::wstring& oleData)
{
OOX::CPath oPathOutput;
_imageManager2Info oImageManagerInfo;
std::wstring strExts = sExts;
std::wstring strImage = L"image" + std::to_wstring(++m_lIndexNextImage);
CImageFileFormatChecker checker(strInput);
switch (checker.eFileType)
{
case _CXIMAGE_FORMAT_JPG:
case _CXIMAGE_FORMAT_PNG:
case _CXIMAGE_FORMAT_WMF:
case _CXIMAGE_FORMAT_EMF:
case _CXIMAGE_FORMAT_GIF:
{
oPathOutput = m_strDstMedia + FILE_SEPARATOR_STR + strImage + strExts;
if (oPathOutput.GetPath() != strInput && NSFile::CFileBinary::Exists(strInput))
{
NSFile::CFileBinary::Copy(strInput, oPathOutput.GetPath());
oImageManagerInfo.sFilepathImage = oPathOutput.GetPath();
}
}break;
case _CXIMAGE_FORMAT_SVG:
{
try
{
strExts = L".png";
oPathOutput = m_strDstMedia + FILE_SEPARATOR_STR + strImage + strExts;
NSFonts::IApplicationFonts* appFonts = NSFonts::NSApplication::Create();
appFonts->Initialize();
MetaFile::IMetaFile* pSvg = MetaFile::Create(appFonts);
if (pSvg->LoadFromFile(strInput.c_str()))
{
double x = 0, y = 0, w = 0, h = 0;
pSvg->GetBounds(&x, &y, &w, &h);
pSvg->ConvertToRaster(oPathOutput.GetPath().c_str(), _CXIMAGE_FORMAT_PNG, w, h);
}
RELEASEOBJECT(pSvg);
RELEASEOBJECT(appFonts);
oImageManagerInfo.sFilepathImage = oPathOutput.GetPath();
}
catch (...)
{
}
}break;
default:
{
strExts = L".png";
oPathOutput = m_strDstMedia + FILE_SEPARATOR_STR + strImage + strExts;
SaveImageAsPng(strInput, oPathOutput.GetPath());
oImageManagerInfo.sFilepathImage = oPathOutput.GetPath();
}break;
}
for (auto add : additional)
{
std::wstring& strAdditionalImage = add.first;
int nAdditionalType = add.second;
if ((!strAdditionalImage.empty() || !oleData.empty()) && (nAdditionalType == 1))
{
std::wstring strAdditionalExt = L".bin";
size_t pos = strAdditionalImage.rfind(L".");
if (pos != std::wstring::npos) strAdditionalExt = strAdditionalImage.substr(pos);
std::wstring strImageAdditional = L"oleObject" + std::to_wstring(++m_lIndexCounter) + strAdditionalExt;
OOX::CPath pathOutput = m_strDstEmbed + FILE_SEPARATOR_STR + strImageAdditional;
std::wstring strAdditionalImageOut = pathOutput.GetPath();
oImageManagerInfo.sFilepathAdditionals.emplace_back();
if (!oleData.empty())
{
WriteOleData(strAdditionalImageOut, oleData);
oImageManagerInfo.sFilepathAdditionals.back() = strAdditionalImageOut;
}
else if (NSFile::CFileBinary::Exists(strAdditionalImage))
{
NSFile::CFileBinary::Copy(strAdditionalImage, strAdditionalImageOut);
oImageManagerInfo.sFilepathAdditionals.back() = strAdditionalImageOut;
}
}
else if (!strAdditionalImage.empty() && (nAdditionalType == 2 || nAdditionalType == 3)) //nAdditionalType -> enum
{
std::wstring strAdditionalExt;
size_t pos = (int)strAdditionalImage.rfind(L".");
if (pos != std::wstring::npos) strAdditionalExt = strAdditionalImage.substr(pos);
std::wstring strImageAdditional = L"media" + std::to_wstring(++m_lIndexCounter) + strAdditionalExt;
OOX::CPath pathOutput = m_strDstMedia + FILE_SEPARATOR_STR + strImageAdditional;
std::wstring strAdditionalImageOut = pathOutput.GetPath();
if (NSFile::CFileBinary::Exists(strAdditionalImage))
{
NSFile::CFileBinary::Copy(strAdditionalImage, strAdditionalImageOut);
oImageManagerInfo.sFilepathAdditionals.emplace_back();
oImageManagerInfo.sFilepathAdditionals.back() = strAdditionalImageOut;
}
}
}
return oImageManagerInfo;
}
bool CImageManager2::SaveImageAsPng(const std::wstring& strFileSrc, const std::wstring& strFileDst)
{
CBgraFrame oBgraFrame;
if (oBgraFrame.OpenFile(strFileSrc))
{
return oBgraFrame.SaveFile(strFileDst, _CXIMAGE_FORMAT_PNG);
}
return false;
}
bool CImageManager2::SaveImageAsJPG(const std::wstring& strFileSrc, const std::wstring& strFileDst)
{
CBgraFrame oBgraFrame;
if (oBgraFrame.OpenFile(strFileSrc))
{
return oBgraFrame.SaveFile(strFileDst, _CXIMAGE_FORMAT_JPG);
}
return false;
}
bool CImageManager2::IsNeedDownload(const std::wstring& strFile)
{
size_t n1 = strFile.find(L"www");
size_t n2 = strFile.find(L"http");
size_t n3 = strFile.find(L"ftp");
size_t n4 = strFile.find(L"https://");
//если nI сранивать не с 0, то будут проблемы
//потому что в инсталяции мы кладем файлы в /var/www...
if (0 == n1 || 0 == n2 || 0 == n3 || 0 == n4)
return true;
return false;
}
_imageManager2Info CImageManager2::DownloadImage(const std::wstring& strUrl)
{
std::map<std::wstring, _imageManager2Info>::const_iterator pPair = m_mapImages.find (strUrl);
if (pPair != m_mapImages.end())
return pPair->second;
std::wstring strExts = L".jpg";
size_t nIndexExt = strUrl.rfind(wchar_t('.'));
if (nIndexExt!= std::wstring::npos)
strExts = strUrl.substr(nIndexExt);
std::wstring strImage;
int nDisplayType = IsDisplayedImage(strUrl);
if (0 != nDisplayType)
{
std::wstring strInputMetafile = strUrl.substr(0, strUrl.length() - strExts.length());
std::wstring sDownloadRes;
if (0 != (nDisplayType & 1))
{
strImage = DownloadImageExec(strInputMetafile + L".wmf");
strExts = L".wmf";
}
else if (0 != (nDisplayType & 2))
{
strImage = DownloadImageExec(strInputMetafile + L".emf");
strExts = L".emf";
}
else
{
strImage = DownloadImageExec(strUrl);
}
}
else
{
strImage = DownloadImageExec(strUrl);
}
if (!strExts.empty())
{
m_pContentTypes->AddDefault(strExts.substr(1));
}
_imageManager2Info oImageManagerInfo;
if (!strImage.empty())
{
std::vector<std::pair<std::wstring, int>> additional;
oImageManagerInfo = GenerateImageExec(strImage, strExts, additional, L"");
CDirectory::DeleteFile(strImage);
}
m_mapImages[strUrl] = oImageManagerInfo;
return oImageManagerInfo;
}
std::wstring CImageManager2::DownloadImageExec(const std::wstring& strFile)
{
#ifndef DISABLE_FILE_DOWNLOADER
NSNetwork::NSFileTransport::CFileDownloader oDownloader(strFile, false);
if ( oDownloader.DownloadSync() )
{
std::wstring file_name = oDownloader.GetFilePath();
CImageFileFormatChecker checker;
if (checker.isImageFile(file_name))
{
return file_name;
}
}
#endif
return L"";
}
CBinaryFileWriter::CSeekTableEntry::CSeekTableEntry()
{
Type = 0;
SeekPos = 0;
}
BYTE* CBinaryFileWriter::GetBuffer()
{
return m_pStreamData;
}
_UINT32 CBinaryFileWriter::GetPosition()
{
return m_lPosition;
}
void CBinaryFileWriter::SetPosition(const _UINT32& lPosition)
{
m_lPosition = lPosition;
m_pStreamCur = m_pStreamData + m_lPosition;
}
void CBinaryFileWriter::Skip(const _UINT32& lSize)
{
CheckBufferSize(lSize);
m_lPosition += lSize;
m_pStreamCur = m_pStreamData + m_lPosition;
}
double CBinaryFileWriter::GetShapeHeight()
{
if (m_dCyCurShape < 0.001)
return -1;
return m_dCyCurShape / 36000; //mm
}
double CBinaryFileWriter::GetShapeWidth()
{
if (m_dCxCurShape < 0.001)
return -1;
return m_dCxCurShape / 36000;
}
double CBinaryFileWriter::GetShapeY()
{
return m_dYCurShape / 36000;
}
double CBinaryFileWriter::GetShapeX()
{
return m_dXCurShape / 36000; //mm
}
void CBinaryFileWriter::ClearCurShapePositionAndSizes()
{
m_dXCurShape = 0;
m_dYCurShape = 0;
m_dCxCurShape = 0;
m_dCyCurShape = 0;
m_bInGroup = false;
}
void CBinaryFileWriter::Clear()
{
m_lSize = 0;
m_lPosition = 0;
m_pStreamData = NULL;
m_pStreamCur = NULL;
m_lStackPosition = 0;
memset(m_arStack, 0, MAX_STACK_SIZE * sizeof(_UINT32));
m_dCxCurShape = 0;
m_dCyCurShape = 0;
m_dXCurShape = 0;
m_dYCurShape = 0;
m_bInGroup = false;
}
void CBinaryFileWriter::SetMainDocument(BinDocxRW::CDocxSerializer* pMainDoc)
{
m_pMainDocument = pMainDoc;
}
void CBinaryFileWriter::ClearNoAttack()
{
m_lPosition = 0;
m_pStreamCur = m_pStreamData;
m_lStackPosition = 0;
memset(m_arStack, 0, MAX_STACK_SIZE * sizeof(_UINT32));
}
void CBinaryFileWriter::CheckBufferSize(_UINT32 lPlus)
{
if (NULL != m_pStreamData)
{
size_t nNewSize = m_lPosition + lPlus;
if (nNewSize >= m_lSize)
{
while (nNewSize >= m_lSize)
{
unsigned int lSize = m_lSize * 2;
if (lSize < m_lSize)
{
m_lSize = nNewSize;
break;
}
m_lSize = lSize;
}
BYTE* pNew = new BYTE[m_lSize];
memcpy(pNew, m_pStreamData, m_lPosition);
RELEASEARRAYOBJECTS(m_pStreamData);
m_pStreamData = pNew;
m_pStreamCur = m_pStreamData + m_lPosition;
}
}
else
{
m_lSize = 1024 * 1024; // 1Mb
m_pStreamData = new BYTE[m_lSize];
m_lPosition = 0;
m_pStreamCur = m_pStreamData;
CheckBufferSize(lPlus);
}
}
void CBinaryFileWriter::WriteBYTE(const BYTE& lValue)
{
CheckBufferSize(BYTE_SIZEOF);
*m_pStreamCur = lValue;
m_lPosition += BYTE_SIZEOF;
m_pStreamCur += BYTE_SIZEOF;
}
void CBinaryFileWriter::WriteSBYTE(const signed char& lValue)
{
CheckBufferSize(BYTE_SIZEOF);
if (lValue < 0)
*m_pStreamCur = (lValue + 256);
else
*m_pStreamCur = lValue;
m_lPosition += BYTE_SIZEOF;
m_pStreamCur += BYTE_SIZEOF;
}
void CBinaryFileWriter::WriteBOOL(const bool& bValue)
{
WriteBYTE((bValue == true) ? 1 : 0);
}
void CBinaryFileWriter::WriteUSHORT(const _UINT16& lValue)
{
CheckBufferSize(UINT16_SIZEOF);
#if defined(_IOS) || defined(__ANDROID__)
memcpy(m_pStreamCur, &lValue, sizeof(_UINT16));
#else
*((_UINT16*)m_pStreamCur) = lValue; // EXC_ARM_DA_ALIGN on ios
#endif
m_lPosition += UINT16_SIZEOF;
m_pStreamCur += UINT16_SIZEOF;
}
void CBinaryFileWriter::WriteSHORT(const _INT16& lValue)
{
CheckBufferSize(INT16_SIZEOF);
#if defined(_IOS) || defined(__ANDROID__)
memcpy(m_pStreamCur, &lValue, sizeof(_INT16));
#else
*((_INT16*)m_pStreamCur) = lValue; // EXC_ARM_DA_ALIGN on ios
#endif
m_lPosition += INT16_SIZEOF;
m_pStreamCur += INT16_SIZEOF;
}
void CBinaryFileWriter::WriteULONG(const _UINT32& lValue)
{
CheckBufferSize(UINT32_SIZEOF);
#if defined(_IOS) || defined(__ANDROID__)
memcpy(m_pStreamCur, &lValue, sizeof(_UINT32));
#else
*((_UINT32*)m_pStreamCur) = lValue; // EXC_ARM_DA_ALIGN on ios
#endif
m_lPosition += UINT32_SIZEOF;
m_pStreamCur += UINT32_SIZEOF;
}
void CBinaryFileWriter::WriteLONG(const _INT32& lValue)
{
CheckBufferSize(INT32_SIZEOF);
#if defined(_IOS) || defined(__ANDROID__)
memcpy(m_pStreamCur, &lValue, sizeof(_INT32));
#else
*((_INT32*)m_pStreamCur) = lValue; // EXC_ARM_DA_ALIGN on ios
#endif
m_lPosition += INT32_SIZEOF;
m_pStreamCur += INT32_SIZEOF;
}
void CBinaryFileWriter::WriteLONG64(const _INT64& lValue)
{
CheckBufferSize(INT64_SIZEOF);
#if defined(_IOS) || defined(__ANDROID__)
memcpy(m_pStreamCur, &lValue, sizeof(_INT64));
#else
*((_INT64*)m_pStreamCur) = lValue; // EXC_ARM_DA_ALIGN on ios
#endif
m_lPosition += INT64_SIZEOF;
m_pStreamCur += INT64_SIZEOF;
}
void CBinaryFileWriter::WriteINT(const _INT32& lValue)
{
CheckBufferSize(INT32_SIZEOF);
#if defined(_IOS) || defined(__ANDROID__)
memcpy(m_pStreamCur, &lValue, sizeof(_INT32));
#else
*((_INT32*)m_pStreamCur) = lValue; // EXC_ARM_DA_ALIGN on ios
#endif
m_lPosition += INT32_SIZEOF;
m_pStreamCur += INT32_SIZEOF;
}
void CBinaryFileWriter::WriteDouble(const double& dValue)
{
_INT64 _val = (_INT64)(dValue * 100000);
if (_val > 0x7fffffff)
{
WriteLONG(0x7fffffff);
}
else if ( _val < -0x7fffffff)
{
WriteLONG(-0x7fffffff);
}
else
{
WriteLONG((int)_val);
}
}
void CBinaryFileWriter::WriteDoubleReal(const double& dValue)
{
CheckBufferSize(DOUBLE_SIZEOF);
#if defined(_IOS) || defined(__ANDROID__)
memcpy(m_pStreamCur, &dValue, sizeof(double));
#else
*((double*)m_pStreamCur) = dValue; // EXC_ARM_DA_ALIGN on ios
#endif
m_lPosition += DOUBLE_SIZEOF;
m_pStreamCur += DOUBLE_SIZEOF;
}
void CBinaryFileWriter::WriteBYTEArray(const BYTE* pBuffer, size_t len)
{
CheckBufferSize((_UINT32)len);
memcpy(m_pStreamCur, pBuffer, len);
m_lPosition += (_UINT32)len;
m_pStreamCur += len;
}
void CBinaryFileWriter::WriteStringA(std::string& sBuffer)
{
_UINT32 lSize = (_UINT32)sBuffer.length();
_UINT32 lSizeMem = lSize * sizeof(char);
CheckBufferSize(UINT32_SIZEOF + lSizeMem);
#if defined(_IOS) || defined(__ANDROID__)
memcpy(m_pStreamCur, &lSizeMem, sizeof(_UINT32));
#else
*((_UINT32*)m_pStreamCur) = lSizeMem; // EXC_ARM_DA_ALIGN on ios
#endif
m_lPosition += UINT32_SIZEOF;
m_pStreamCur += UINT32_SIZEOF;
memcpy(m_pStreamCur, sBuffer.c_str(), lSizeMem);
m_lPosition += lSizeMem;
m_pStreamCur += lSizeMem;
}
void CBinaryFileWriter::WriteStringW(const std::wstring& sBuffer)
{
_WriteStringWithLength(sBuffer.c_str(), (_UINT32)sBuffer.length(), true);
}
void CBinaryFileWriter::WriteStringW2(const std::wstring& sBuffer)
{
_WriteStringWithLength(sBuffer.c_str(), (_UINT32)sBuffer.length(), false);
}
void CBinaryFileWriter::WriteStringW3(const std::wstring& sBuffer)
{
_WriteString(sBuffer.c_str(), (_UINT32)sBuffer.length());
}
void CBinaryFileWriter::WriteStringW4(const std::wstring& sBuffer)
{
_WriteString(sBuffer.c_str(), (_UINT32)sBuffer.length());
}
void CBinaryFileWriter::WriteStringUtf8(const std::wstring& sBuffer)
{
BYTE* pData = NULL;
LONG lLen = 0;
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(sBuffer.c_str(), (LONG)sBuffer.length(), pData, lLen, false);
WriteBYTEArray(pData, lLen);
RELEASEARRAYOBJECTS(pData);
}
CBinaryFileWriter::CBinaryFileWriter()
{
m_pMainDocument = NULL;
m_pCommon = new CCommonWriter();
//m_pCommonRels = new NSCommon::smart_ptr<PPTX::CCommonRels>();
m_pCurrentContainer = new NSCommon::smart_ptr<OOX::IFileContainer>();
m_pTheme = new NSCommon::smart_ptr<PPTX::Theme>();
m_pClrMap = new NSCommon::smart_ptr<PPTX::Logic::ClrMap>();
Clear();
}
CBinaryFileWriter::~CBinaryFileWriter()
{
RELEASEARRAYOBJECTS (m_pStreamData);
RELEASEOBJECT (m_pCommon);
//RELEASEOBJECT (m_pCommonRels);
RELEASEOBJECT (m_pCurrentContainer);
RELEASEOBJECT (m_pTheme);
RELEASEOBJECT (m_pClrMap);
}
void CBinaryFileWriter::SetRels(NSCommon::smart_ptr<OOX::IFileContainer> container)
{
*m_pCurrentContainer = container;
}
void CBinaryFileWriter::SetRels(OOX::IFileContainer *container)
{
*m_pCurrentContainer = NSCommon::smart_ptr<OOX::IFileContainer>(container);
m_pCurrentContainer->AddRef();
}
NSCommon::smart_ptr<OOX::IFileContainer> CBinaryFileWriter::GetRels()
{
return *m_pCurrentContainer;
}
void CBinaryFileWriter::StartRecord(_INT32 lType)
{
m_arStack[m_lStackPosition] = m_lPosition + 5; // sizeof(BYTE) + sizeof(_UINT32)
m_lStackPosition++;
WriteBYTE((BYTE)lType);
WriteULONG(0);
}
void CBinaryFileWriter::EndRecord()
{
m_lStackPosition--;
_UINT32 size_record = m_lPosition - m_arStack[m_lStackPosition];
(*(_UINT32*)(m_pStreamData + m_arStack[m_lStackPosition] - 4)) = size_record ;
}
void CBinaryFileWriter::StartMainRecord(_INT32 lType)
{
CSeekTableEntry oEntry;
oEntry.Type = lType;
oEntry.SeekPos = m_lPosition;
m_arMainTables.push_back(oEntry);
//StartRecord(lType);
}
void CBinaryFileWriter::WriteRecord2(int type, OOX::WritingElement* pVal)
{
if (pVal)
{
StartRecord(type);
pVal->toPPTY(this);
EndRecord();
}
}
void CBinaryFileWriter::WriteReserved(size_t lCount)
{
CheckBufferSize((_UINT32)lCount);
memset(m_pStreamCur, 0, lCount);
m_pStreamCur += lCount;
m_lPosition += (_UINT32)lCount;
}
void CBinaryFileWriter::WriteMainPart(_UINT32 nStartPos)
{
BYTE* pData = m_pStreamData + nStartPos;
size_t nCount = m_arMainTables.size();
for (size_t i = 0; i < nCount; i++)
{
*pData = (BYTE)m_arMainTables[i].Type;
++pData;
#if defined(_IOS) || defined(__ANDROID__)
memcpy(pData, &m_arMainTables[i].SeekPos, sizeof(_INT32));
#else
*((_INT32*)pData) = m_arMainTables[i].SeekPos; // EXC_ARM_DA_ALIGN on ios
#endif
pData += 4;
}
}
void CBinaryFileWriter::WriteString1(int type, const std::wstring& val)
{
BYTE bType = (BYTE)type;
WriteBYTE(bType);
std::wstring* s = const_cast<std::wstring*>(&val);
_WriteStringWithLength(s->c_str(), (_UINT32)s->length(), false);
}
void CBinaryFileWriter::WriteString1(int type, const std::string& val)
{
BYTE bType = (BYTE)type;
WriteBYTE(bType);
std::string* s = const_cast<std::string*>(&val);
_WriteStringWithLength(s->c_str(), (_UINT32)s->length());
}
void CBinaryFileWriter::WriteString2(int type, const NSCommon::nullable_string& val)
{
if (val.is_init())
WriteString1(type, *val);
}
void CBinaryFileWriter::WriteStringUtf8(int type, const NSCommon::nullable_string& val)
{
if (val.is_init())
{
BYTE bType = (BYTE)type;
WriteBYTE(bType);
_WriteStringUtf8WithLength(val->c_str(), (_UINT32)val->length());
}
}
void CBinaryFileWriter::WriteStringUtf8(int type, const NSCommon::nullable_astring& val)
{
if (val.is_init())
{
BYTE bType = (BYTE)type;
WriteBYTE(bType);
_WriteStringWithLength(val->c_str(), (_UINT32)val->length());
}
} void CBinaryFileWriter::WriteString(const std::wstring& val)
{
std::wstring* s = const_cast<std::wstring*>(&val);
_WriteStringWithLength(s->c_str(), (_UINT32)s->length(), false);
}
void CBinaryFileWriter::WriteString2(int type, const NSCommon::nullable_astring& val)
{
if (val.is_init())
WriteString1(type, *val);
}
void CBinaryFileWriter::WriteStringData(const WCHAR* pData, _UINT32 len)
{
_WriteStringWithLength(pData, len, false);
}
void CBinaryFileWriter::WriteString1Data(int type, const WCHAR* pData, _UINT32 len)
{
BYTE bType = (BYTE)type;
WriteBYTE(bType);
_WriteStringWithLength(pData, len, false);
}
void CBinaryFileWriter::WriteBool1(int type, const bool& val)
{
BYTE bType = (BYTE)type;
WriteBYTE(bType);
WriteBYTE((val == true) ? 1 : 0);
}
void CBinaryFileWriter::WriteBool2(int type, const NSCommon::nullable_bool& val)
{
if (val.is_init())
WriteBool1(type, *val);
}
void CBinaryFileWriter::WriteByte1(int type, const BYTE& val)
{
BYTE bType = (BYTE)type;
WriteBYTE(bType);
WriteBYTE(val);
}
void CBinaryFileWriter::WriteInt1(int type, const int& val)
{
BYTE bType = (BYTE)type;
WriteBYTE(bType);
WriteINT(val);
}
void CBinaryFileWriter::WriteInt2(int type, const NSCommon::nullable_int& val)
{
if (val.is_init())
WriteInt1(type, *val);
}
void CBinaryFileWriter::WriteUInt1(int type, const unsigned int& val)
{
BYTE bType = (BYTE)type;
WriteBYTE(bType);
WriteULONG(val);
}
void CBinaryFileWriter::WriteUInt2(int type, const NSCommon::nullable_uint& val)
{
if (val.is_init())
WriteUInt1(type, *val);
}
void CBinaryFileWriter::WriteDouble1(int type, const double& val)
{
_INT64 _val = (_INT64)(val * 100000);
if (_val > 0x7fffffff)
{
WriteInt1(type, 0x7fffffff);
}
else if (_val < -0x7fffffff)
{
WriteInt1(type, -0x7fffffff);
}
else
{
WriteInt1(type, (int)_val);
}
}
void CBinaryFileWriter::WriteDouble2(int type, const NSCommon::nullable_double& val)
{
if (val.is_init())
WriteDouble1(type, *val);
}
void CBinaryFileWriter::WriteDoubleReal1(int type, const double& val)
{
BYTE bType = (BYTE)type;
WriteBYTE(bType);
WriteDoubleReal(val);
}
void CBinaryFileWriter::WriteDoubleReal2(int type, const NSCommon::nullable_double& val)
{
if (val.is_init())
WriteDoubleReal1(type, *val);
}
void CBinaryFileWriter::WriteSize_t1(int type, const size_t& val)
{
BYTE bType = (BYTE)type;
WriteBYTE(bType);
_UINT32 ival = (_UINT32)val;
WriteULONG(ival);
}
void CBinaryFileWriter::WriteSize_t2(int type, const NSCommon::nullable_sizet& val)
{
if (val.is_init())
WriteSize_t1(type, *val);
}
void CBinaryFileWriter::GetBase64File(const std::wstring& sFile, std::string& strDst64)
{
NSFile::CFileBinary oFile;
bool res = oFile.OpenFile(sFile);
if (false == res)
{
strDst64 = "";
return;
}
DWORD dwLen = (DWORD)oFile.GetFileSize();
BYTE* pBuffer = new BYTE[dwLen];
oFile.SetPosition(0);
oFile.ReadFile(pBuffer, dwLen);
int nBase64BufferLen = Base64::Base64EncodeGetRequiredLength((int)dwLen, Base64::B64_BASE64_FLAG_NOCRLF);
BYTE *pbBase64Buffer = new BYTE[nBase64BufferLen + 1 + 64];
pbBase64Buffer[nBase64BufferLen] = '\0';
//if (true == Base64::Base64Encode(pBuffer, (int)dwLen, pbBase64Buffer, &nBase64BufferLen, Base64::B64_BASE64_FLAG_NOCRLF))
if (true == Base64_1::Base64Encode(pBuffer, (int)dwLen, pbBase64Buffer, &nBase64BufferLen))
{
//strDst64.SetString(pbBase64Buffer, nBase64BufferLen);
strDst64 = (char*)pbBase64Buffer;
}
RELEASEARRAYOBJECTS(pbBase64Buffer);
RELEASEARRAYOBJECTS(pBuffer);
oFile.CloseFile();
//DeleteFile(sFile);
}
void CBinaryFileWriter::WriteTheme64(_INT32 lIndex, const std::wstring& sFile)
{
GetBase64File(sFile, m_pCommon->m_oRels[lIndex].m_strImageBase64);
}
void CBinaryFileWriter::WriteLayoutTheme64(_INT32 lIndexTheme, _INT32 lIndexLayout, const std::wstring& sFile)
{
GetBase64File(sFile, m_pCommon->m_oRels[lIndexTheme].m_arLayoutImagesBase64[lIndexLayout]);
}
std::wstring CBinaryFileWriter::GetFolderForGenerateImages()
{
return m_strMainFolder + L"\\extract_themes";
}
// embedded fonts
void CBinaryFileWriter::WriteEmbeddedFonts()
{
if (NULL == m_pCommon->m_pNativePicker)
return;
if (!m_pCommon->m_pNativePicker->m_bIsEmbeddedFonts)
return;
StartMainRecord(NSBinPptxRW::NSMainTables::FontsEmbedded);
// добавим мега шрифт
m_pCommon->m_pNativePicker->m_oEmbeddedFonts.CheckString(L".)abcdefghijklmnopqrstuvwxyz");
m_pCommon->m_pNativePicker->m_oEmbeddedFonts.CheckFont(L"Wingdings 3", m_pCommon->m_pNativePicker->m_pFontManager);
m_pCommon->m_pNativePicker->m_oEmbeddedFonts.CheckFont(L"Arial", m_pCommon->m_pNativePicker->m_pFontManager);
StartRecord(NSBinPptxRW::NSMainTables::FontsEmbedded);
m_pCommon->m_pNativePicker->m_oEmbeddedFonts.WriteEmbeddedFonts(this);
EndRecord();
}
bool CBinaryFileWriter::GetSafearray(BYTE **ppArray, size_t& szCount)
{
if (NULL == ppArray)
return false;
_UINT32 lBinarySize = this->GetPosition();
if (0 == lBinarySize)
return false;
*ppArray = new BYTE [lBinarySize];
szCount = lBinarySize;
memcpy(*ppArray, this->GetBuffer(), lBinarySize);
return true;
}
_INT32 CBinaryFileWriter::_WriteString(const WCHAR* sBuffer, _UINT32 lCount)
{
if (lCount < 1) return 0;
_INT32 lSizeMem = 0;
if (sizeof(wchar_t) == 4)
{
_INT32 lSizeMemMax = 4 * lCount + 2;//2 - for null terminator
CheckBufferSize(lSizeMemMax);
NSFile::CUtf8Converter::GetUtf16StringFromUnicode_4bytes(sBuffer, lCount, m_pStreamCur, lSizeMem);
}
else
{
lSizeMem = 2 * lCount;
CheckBufferSize(lSizeMem);
memcpy(m_pStreamCur, sBuffer, lSizeMem);
}
m_lPosition += lSizeMem;
m_pStreamCur += lSizeMem;
return lSizeMem;
}
_INT32 CBinaryFileWriter::_WriteString(const char* sBuffer, _UINT32 lCount)
{
if (lCount < 1) return 0;
_UINT32 lSizeMem = lCount * sizeof(char);
CheckBufferSize(UINT32_SIZEOF + lSizeMem);
memcpy(m_pStreamCur, sBuffer, lSizeMem);
m_lPosition += lSizeMem;
m_pStreamCur += lSizeMem;
return lSizeMem;
}
_INT32 CBinaryFileWriter::_WriteStringUtf8(const WCHAR* sBuffer, _UINT32 lCount)
{
if (lCount < 1) return 0;
LONG lSizeMem = 0;
_INT32 lSizeMemMax = 4 * lCount + 2;//2 - for null terminator
CheckBufferSize(lSizeMemMax);
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(sBuffer, lCount, m_pStreamCur, lSizeMem, false);
m_lPosition += lSizeMem;
m_pStreamCur += lSizeMem;
return lSizeMem;
}
void CBinaryFileWriter::_WriteStringWithLength(const WCHAR* sBuffer, _UINT32 lCount, bool bByte)
{
if (sizeof(wchar_t) == 4)
{
_INT32 lSizeMemMax = 4 * lCount + 2;//2 - for null terminator
CheckBufferSize(UINT32_SIZEOF + lSizeMemMax);
}
else
{
_INT32 lSizeMem = 2 * lCount;
CheckBufferSize(UINT32_SIZEOF + lSizeMem);
}
//skip size
m_lPosition += UINT32_SIZEOF;
m_pStreamCur += UINT32_SIZEOF;
//write string
_INT32 lSizeMem = _WriteString(sBuffer, lCount);
//back to size
m_lPosition -= lSizeMem;
m_pStreamCur -= lSizeMem;
m_lPosition -= UINT32_SIZEOF;
m_pStreamCur -= UINT32_SIZEOF;
//write size
if (bByte)
{
//byte
WriteLONG(lSizeMem);
}
else
{
//length
WriteLONG(lSizeMem / 2);
}
//skip string
m_lPosition += lSizeMem;
m_pStreamCur += lSizeMem;
}
void CBinaryFileWriter::_WriteStringWithLength(const char* sBuffer, _UINT32 lCount)
{
CheckBufferSize(UINT32_SIZEOF + lCount);
//skip size
m_lPosition += UINT32_SIZEOF;
m_pStreamCur += UINT32_SIZEOF;
//write string
_INT32 lSizeMem = _WriteString(sBuffer, lCount);
//back to size
m_lPosition -= lSizeMem;
m_pStreamCur -= lSizeMem;
m_lPosition -= UINT32_SIZEOF;
m_pStreamCur -= UINT32_SIZEOF;
//write size
WriteLONG(lSizeMem);
//skip string
m_lPosition += lSizeMem;
m_pStreamCur += lSizeMem;
}
void CBinaryFileWriter::_WriteStringUtf8WithLength(const WCHAR* sBuffer, _UINT32 lCount)
{
if (sizeof(wchar_t) == 4)
{
_INT32 lSizeMemMax = 4 * lCount + 2;//2 - for null terminator
CheckBufferSize(UINT32_SIZEOF + lSizeMemMax);
}
else
{
_INT32 lSizeMem = 2 * lCount;
CheckBufferSize(UINT32_SIZEOF + lSizeMem);
}
//skip size
m_lPosition += UINT32_SIZEOF;
m_pStreamCur += UINT32_SIZEOF;
//write string
_INT32 lSizeMem = lCount > 0 ? _WriteStringUtf8(sBuffer, lCount) : 0;
//back to size
m_lPosition -= lSizeMem;
m_pStreamCur -= lSizeMem;
m_lPosition -= UINT32_SIZEOF;
m_pStreamCur -= UINT32_SIZEOF;
//write size
WriteLONG(lSizeMem);
//skip string
m_lPosition += lSizeMem;
m_pStreamCur += lSizeMem;
}
CStreamBinaryWriter::CStreamBinaryWriter(size_t bufferSize)
{
m_lSize = bufferSize;
m_pStreamData = new BYTE[bufferSize];
m_lPosition = 0;
m_pStreamCur = m_pStreamData;
m_lPositionFlushed = 0;
}
void CStreamBinaryWriter::CheckBufferSize(_UINT32 lPlus)
{
if ((m_lPosition + lPlus) > m_lSize)
{
Flush();
if ((m_lPosition + lPlus) > m_lSize)
{
CBinaryFileWriter::CheckBufferSize(lPlus);
}
}
}
_UINT32 CStreamBinaryWriter::GetPositionAbsolute()
{
return m_lPosition + m_lPositionFlushed;
}
void CStreamBinaryWriter::CloseFile()
{
Flush();
CFileBinary::CloseFile();
}
void CStreamBinaryWriter::Flush()
{
if (m_lPosition > 0)
{
bool result = CFileBinary::WriteFile(m_pStreamData, m_lPosition);
if (result)
{
m_lPositionFlushed += m_lPosition;
m_lPosition = 0;
m_pStreamCur = m_pStreamData;
}
}
}
void CStreamBinaryWriter::WriteReserved(size_t lCount)
{
CBinaryFileWriter::WriteReserved(lCount);
}
CXlsbBinaryWriter::CXlsbBinaryWriter(size_t bufferSize) : CStreamBinaryWriter(bufferSize)
{
}
void CXlsbBinaryWriter::XlsbStartRecord(_INT16 lType, _INT32 nLen)
{
//Type
if (lType < 0x80)
{
WriteBYTE(lType);
}
else
{
WriteBYTE((lType & 0x7F) | 0x80);
WriteBYTE(lType >> 7);
}
//Len
for (int i = 0; i < 4; ++i)
{
BYTE nPart = nLen & 0x7F;
nLen = nLen >> 7;
if (nLen == 0)
{
WriteBYTE(nPart);
break;
}
else
{
WriteBYTE(nPart | 0x80);
}
}
}
void CXlsbBinaryWriter::XlsbEndRecord()
{
}
CRelsGenerator::CRelsGenerator(CImageManager2* pManager) : m_lNextRelsID(1), m_mapRelsImages()
{
m_pManager = pManager;
m_pWriter = new NSStringUtils::CStringBuilder();
}
CRelsGenerator::~CRelsGenerator()
{
RELEASEOBJECT(m_pWriter);
}
void CRelsGenerator::Clear()
{
m_pWriter->ClearNoAttack();
m_lNextRelsID = 1;
m_mapRelsImages.clear();
m_mapLinks.clear();
}
void CRelsGenerator::StartRels()
{
m_pWriter->WriteString(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
m_pWriter->WriteString(L"<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
}
void CRelsGenerator::StartTheme()
{
m_pWriter->WriteString(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
m_pWriter->WriteString(L"<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
}
void CRelsGenerator::StartMaster(int nIndexTheme, const _slideMasterInfo& oInfo)
{
m_pWriter->WriteString(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
m_pWriter->WriteString(L"<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
int nCountLayouts = (int)oInfo.m_arLayouts.size();
for (int i = 0; i < nCountLayouts; ++i)
{
std::wstring str = L"<Relationship Id=\"rId" +
std::to_wstring(m_lNextRelsID++) +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout\" Target=\"../slideLayouts/slideLayout" +
std::to_wstring(oInfo.m_arLayouts[i] + 1) +
L".xml\"/>";
m_pWriter->WriteString(str);
}
std::wstring s = L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme\" Target=\"../theme/theme" +
std::to_wstring(nIndexTheme + 1) + L".xml\"/>";
m_pWriter->WriteString(s);
}
void CRelsGenerator::StartThemeNotesMaster(int nIndexTheme)
{
m_pWriter->WriteString(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
m_pWriter->WriteString(L"<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
std::wstring s = L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme\" Target=\"../theme/theme" +
std::to_wstring(nIndexTheme + 1) + L".xml\"/>";
m_pWriter->WriteString(s);
}
void CRelsGenerator::StartLayout(int nIndexTheme)
{
m_pWriter->WriteString(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
m_pWriter->WriteString(L"<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
std::wstring str = L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster\" Target=\"../slideMasters/slideMaster" +
std::to_wstring(nIndexTheme + 1) + L".xml\"/>";
m_pWriter->WriteString(str);
}
void CRelsGenerator::StartSlide(int nIndexSlide, int nIndexLayout, int nIndexNotes)
{
m_pWriter->WriteString(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
m_pWriter->WriteString(L"<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
std::wstring str = L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout\" Target=\"../slideLayouts/slideLayout" +
std::to_wstring(nIndexLayout + 1) + L".xml\"/>";
m_pWriter->WriteString(str);
if (nIndexNotes >= 0)
{
str = L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide\" Target=\"../notesSlides/notesSlide" +
std::to_wstring(nIndexNotes + 1) + L".xml\"/>";
m_pWriter->WriteString(str);
}
}
void CRelsGenerator::StartNotes(int nIndexSlide)
{
m_pWriter->WriteString(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>");
m_pWriter->WriteString(L"<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
std::wstring sNum = std::to_wstring(nIndexSlide + 1);
std::wstring strNoteSlideRels = L"<Relationship Id=\"rId2\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide\" Target=\"../slides/slide" + sNum + L".xml\"/>";
m_pWriter->WriteString(strNoteSlideRels);
m_pWriter->WriteString(L"<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster\" Target=\"../notesMasters/notesMaster1.xml\"/>");
m_lNextRelsID = 3;
}
std::wstring CRelsGenerator::WriteMaster(int nIndex)
{
std::wstring rid = L"rId" + std::to_wstring(m_lNextRelsID++);
std::wstring strRels = L"<Relationship Id=\"" + rid +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster\" Target=\"slideMasters/slideMaster"
+ std::to_wstring(nIndex) + L".xml\"/>";
m_pWriter->WriteString(strRels);
return rid;
}
void CRelsGenerator::WriteThemes(int nCount)
{
for (int i = 0; i < nCount; ++i)
{
std::wstring strRels = L"<Relationship Id=\"rId" + std::to_wstring( m_lNextRelsID++ ) +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme\" Target=\"theme/theme" +
std::to_wstring(i + 1) + L".xml\"/>";
m_pWriter->WriteString(strRels);
}
}
std::wstring CRelsGenerator::WriteSlide(int nIndex)
{
std::wstring rid = L"rId" + std::to_wstring(m_lNextRelsID++);
std::wstring strRels = L"<Relationship Id=\"" + rid +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide\" Target=\"slides/slide" +
std::to_wstring(nIndex) + L".xml\"/>";
m_pWriter->WriteString(strRels);
return rid;
}
void CRelsGenerator::WriteNotesMaster()
{
std::wstring strRels0 = L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster\" Target=\"notesMasters/notesMaster1.xml\"/>";
m_pWriter->WriteString(strRels0);
}
std::wstring CRelsGenerator::WriteCustom(const std::wstring & file_name)
{
std::wstring rid = L"rId" + std::to_wstring(m_lNextRelsID++);
std::wstring strRels = L"<Relationship Id=\"" + rid +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml\" Target=\"../customXml/" + file_name + L"\"/>";
m_pWriter->WriteString(strRels);
return rid;
}
void CRelsGenerator::EndPresentationRels(bool bIsVbaProject, bool bIsJsaProject)
{
std::wstring strRels1 = L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/presProps\" Target=\"presProps.xml\" />";
std::wstring strRels2 = L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/tableStyles\" Target=\"tableStyles.xml\" />";
std::wstring strRels3 = L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/viewProps\" Target=\"viewProps.xml\" />";
m_pWriter->WriteString(strRels1);
m_pWriter->WriteString(strRels2);
m_pWriter->WriteString(strRels3);
if (bIsVbaProject)
{
std::wstring strRels4 = L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
L"\" Type=\"http://schemas.microsoft.com/office/2006/relationships/vbaProject\" Target=\"vbaProject.bin\"/>";
m_pWriter->WriteString(strRels4);
}
if (bIsJsaProject)
{
std::wstring strRels5 = L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
L"\" Type=\"" + OOX::FileTypes::JsaProject.RelationType() + L"\" Target=\"" + OOX::FileTypes::JsaProject.DefaultFileName().GetPath() + L"\"/>";
m_pWriter->WriteString(strRels5);
}
}
void CRelsGenerator::CloseRels()
{
m_pWriter->WriteString(L"</Relationships>");
}
void CRelsGenerator::AddRels(const std::wstring& strRels)
{
m_pWriter->WriteString(strRels);
}
void CRelsGenerator::SaveRels(const std::wstring& strFile)
{
NSFile::CFileBinary oFile;
oFile.CreateFile(strFile);
std::wstring strMem = m_pWriter->GetData();
oFile.WriteStringUTF8(strMem);
oFile.CloseFile();
}
_relsGeneratorInfo CRelsGenerator::WriteMedia(const std::wstring& strImage, int type)
{
_imageManager2Info oImageManagerInfo = m_pManager->GenerateMedia(strImage);
std::wstring strMediaRelsPath;
if (m_pManager->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX) strMediaRelsPath = L"media/";
else strMediaRelsPath = L"../media/";
_relsGeneratorInfo oRelsGeneratorInfo;
if (!oImageManagerInfo.sFilepathImage.empty())
{
strMediaRelsPath += OOX::CPath(oImageManagerInfo.sFilepathImage).GetFilename();
std::map<std::wstring, _relsGeneratorInfo>::iterator pPair = m_mapRelsImages.find(strMediaRelsPath);
if (m_mapRelsImages.end() != pPair)
{
return pPair->second;
}
oRelsGeneratorInfo.nImageRId = m_lNextRelsID++;
oRelsGeneratorInfo.sFilepathImage = oImageManagerInfo.sFilepathImage;
std::wstring strRid = L"rId" + std::to_wstring(oRelsGeneratorInfo.nImageRId);
if (type == 0)
{
m_pWriter->WriteString( L"<Relationship Id=\"" + strRid +
L"\" Type=\"http://schemas.microsoft.com/office/2007/relationships/media\" Target=\"" + strMediaRelsPath + L"\"/>");
}
else if (type == 1)
{
m_pWriter->WriteString( L"<Relationship Id=\"" + strRid +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/audio\" Target=\"" + strMediaRelsPath + L"\"/>");
}
}
m_mapRelsImages.insert(std::pair<std::wstring, _relsGeneratorInfo>(strMediaRelsPath, oRelsGeneratorInfo));
return oRelsGeneratorInfo;
}
_relsGeneratorInfo CRelsGenerator::WriteImage(const std::wstring& strImage, std::vector<NSCommon::smart_ptr<OOX::File>>& additionalFiles, const std::wstring& oleData, std::wstring strBase64Image = L"")
{
_imageManager2Info oImageManagerInfo = m_pManager->GenerateImage(strImage, additionalFiles, oleData, strBase64Image);
std::wstring strImageRelsPath;
if (m_pManager->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX) strImageRelsPath = L"media/";
else strImageRelsPath = L"../media/";
_relsGeneratorInfo oRelsGeneratorInfo;
if (!oImageManagerInfo.sFilepathImage.empty())
{
strImageRelsPath += OOX::CPath(oImageManagerInfo.sFilepathImage).GetFilename();
std::map<std::wstring, _relsGeneratorInfo>::iterator pPair = m_mapRelsImages.find(strImageRelsPath);
if (m_mapRelsImages.end() != pPair)
{
return pPair->second;
}
oRelsGeneratorInfo.nImageRId = m_lNextRelsID++;
oRelsGeneratorInfo.sFilepathImage = oImageManagerInfo.sFilepathImage;
std::wstring strRid = L"rId" + std::to_wstring(oRelsGeneratorInfo.nImageRId);
m_pWriter->WriteString( L"<Relationship Id=\"" + strRid +
L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/image\" Target=\"" + strImageRelsPath + L"\"/>");
}
for (auto additionalFile : additionalFiles)
{
if (additionalFile.is<OOX::OleObject>())
{
smart_ptr<OOX::OleObject> oleFile = additionalFile.smart_dynamic_cast<OOX::OleObject>();
std::wstring strOleRelsPath;
oRelsGeneratorInfo.nOleRId = m_lNextRelsID++;
oRelsGeneratorInfo.sFilepathOle = oleFile->filename().GetPath();
if (m_pManager->m_nDocumentType != XMLWRITER_DOC_TYPE_XLSX)
{
std::wstring strRid = L"rId" + std::to_wstring(oRelsGeneratorInfo.nOleRId);
if (m_pManager->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX) strOleRelsPath = L"embeddings/";
else strOleRelsPath = L"../embeddings/";
strOleRelsPath += oleFile->filename().GetFilename();
if (oleFile->isMsPackage())
{
m_pWriter->WriteString(L"<Relationship Id=\"" + strRid
+ L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/package\" Target=\"" + strOleRelsPath + L"\"/>");
}
else {
m_pWriter->WriteString(L"<Relationship Id=\"" + strRid
+ L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/oleObject\" Target=\"" + strOleRelsPath + L"\"/>");
}
}
}
else if (additionalFile.is<OOX::Media>())
{
smart_ptr<OOX::Media> mediaFile = additionalFile.smart_dynamic_cast<OOX::Media>();
std::wstring strMediaRelsPath;
oRelsGeneratorInfo.nMediaRId = m_lNextRelsID++;
oRelsGeneratorInfo.sFilepathMedia = mediaFile->filename().GetPath();
if (m_pManager->m_nDocumentType != XMLWRITER_DOC_TYPE_XLSX || additionalFile.is<OOX::SvgBlip>())
{
std::wstring strRid = L"rId" + std::to_wstring(oRelsGeneratorInfo.nMediaRId);
if (mediaFile->IsExternal())
{
strMediaRelsPath = mediaFile->filename().GetFilename();
}
else
{
if (m_pManager->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX) strMediaRelsPath = L"media/";
else strMediaRelsPath = L"../media/";
const std::wstring filename = mediaFile->filename().GetFilename();
if (!filename.empty())
{
strMediaRelsPath += filename;
if (additionalFile.is<OOX::Video>() || additionalFile.is<OOX::Audio>())
{
m_pWriter->WriteString(L"<Relationship Id=\"" + strRid
+ L"\" Type=\"http://schemas.microsoft.com/office/2007/relationships/media\" Target=\"" +
strMediaRelsPath + L"\"" + (mediaFile->IsExternal() ? L" TargetMode=\"External\"" : L"") + L"/>");
}
else
{
m_pWriter->WriteString(L"<Relationship Id=\"" + strRid
+ L"\" Type=\"" + additionalFile->type().RelationType() + L"\" Target=\"" +
strMediaRelsPath + L"\"" + (mediaFile->IsExternal() ? L" TargetMode=\"External\"" : L"") + L"/>");
}
}
}
}
}
}
m_mapRelsImages.insert(std::pair<std::wstring, _relsGeneratorInfo>(strImageRelsPath, oRelsGeneratorInfo));
return oRelsGeneratorInfo;
}
unsigned int CRelsGenerator::WriteRels(const std::wstring& bsType, const std::wstring& bsTarget, const std::wstring& bsTargetMode)
{
std::wstring strRid = L"rId" + std::to_wstring(m_lNextRelsID++);
std::wstring strType = L"Type=\"" + bsType + L"\" ";
std::wstring strTarget = L"Target=\"" + bsTarget + L"\" ";
std::wstring strTargetMode = bsTargetMode.empty() ? L"" : L"TargetMode=\"" + bsTargetMode + L"\"";
std::wstring strRels = L"<Relationship Id=\"" + strRid + L"\" " + strType + strTarget + strTargetMode + L"/>";
m_pWriter->WriteString(strRels);
return m_lNextRelsID - 1;
}
unsigned int CRelsGenerator::WriteHyperlink(const std::wstring& strLink, const bool& bIsActionInit)
{
std::map<std::wstring, unsigned int>::iterator pPair = m_mapLinks.find(strLink);
if (m_mapLinks.end() != pPair)
{
return pPair->second;
}
m_mapLinks.insert(std::pair<std::wstring, unsigned int>(strLink, m_lNextRelsID));
std::wstring strRid = L"rId" + std::to_wstring(m_lNextRelsID++);
std::wstring sLink = XmlUtils::EncodeXmlString(strLink);
bool bIsSlide = (0 == sLink.find(L"slide"));
if (!bIsActionInit)
bIsSlide = false;
std::wstring strRels;
if (!bIsSlide)
{
strRels = L"<Relationship Id=\"" + strRid
+ L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink\" Target=\"" + sLink + L"\" TargetMode=\"External\"/>";
}
else
{
strRels = L"<Relationship Id=\"" + strRid
+ L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide\" Target=\"" + sLink + L"\"/>";
}
m_pWriter->WriteString(strRels);
return m_lNextRelsID - 1;
}
CBinaryFileReader::CBinaryFileReader()
{
m_pMainDocument = NULL;
m_lNextId = 0;
m_nDocumentType = XMLWRITER_DOC_TYPE_PPTX;
m_pRels = new CRelsGenerator();
m_nCurrentRelsStack = -1;
m_pCurrentContainer = new NSCommon::smart_ptr<OOX::IFileContainer>();
}
CBinaryFileReader::~CBinaryFileReader()
{
RELEASEOBJECT(m_pRels);
RELEASEOBJECT(m_pCurrentContainer);
size_t nCountStackRels = m_stackRels.size();
for (size_t i = 0; i < nCountStackRels; ++i)
{
CRelsGenerator* pCur = m_stackRels[i];
RELEASEOBJECT(pCur);
}
m_stackRels.clear();
}
void CBinaryFileReader::SetRels(NSCommon::smart_ptr<OOX::IFileContainer> container)
{
*m_pCurrentContainer = container;
}
void CBinaryFileReader::SetRels(OOX::IFileContainer* container)
{
*m_pCurrentContainer = NSCommon::smart_ptr<OOX::IFileContainer>(container);
m_pCurrentContainer->AddRef();
}
NSCommon::smart_ptr<OOX::IFileContainer> CBinaryFileReader::GetRels()
{
return *m_pCurrentContainer;
}
void CBinaryFileReader::SetMainDocument(BinDocxRW::CDocxSerializer* pMainDoc)
{
m_pMainDocument = pMainDoc;
}
void CBinaryFileReader::Init(BYTE* pData, _INT32 lStart, _INT32 lSize)
{
m_pData = pData;
m_lSize = lSize + lStart;
m_lPos = lStart;
m_pDataCur = m_pData + m_lPos;
}
_INT32 CBinaryFileReader::GenerateNextId()
{
++m_lNextId;
return m_lNextId;
}
int CBinaryFileReader::Seek(LONG _pos)
{
if (_pos > m_lSize)
{
_pos = m_lSize;
}
if (_pos < 0 )
{
_pos = 0;
throw;
}
m_lPos = _pos;
m_pDataCur = m_pData + m_lPos;
return 0;
}
int CBinaryFileReader::Skip(LONG _skip)
{
if (_skip < 0)
return 1;
return Seek(m_lPos + _skip);
}
bool CBinaryFileReader::Peek(LONG nSizeToRead = 0)
{
return !(m_lPos + nSizeToRead > m_lSize);
}
// 1 bytes
bool CBinaryFileReader::GetUCharWithResult(BYTE *value_)
{
if (!value_ || m_lPos >= m_lSize)
{
return false;
}
*value_ = *m_pDataCur;
++m_lPos;
++m_pDataCur;
return true;
}
BYTE CBinaryFileReader::GetUChar()
{
if (m_lPos >= m_lSize || m_lPos < 0)
{
throw;
}
BYTE res = *m_pDataCur;
++m_lPos;
++m_pDataCur;
return res;
}
signed char CBinaryFileReader::GetChar()
{
if (m_lPos >= m_lSize || m_lPos <0)
{
throw;
}
BYTE res = *m_pDataCur;
if (res > 127)
res -= 256;
++m_lPos;
++m_pDataCur;
return res;
}
// 1 bytes
BYTE CBinaryFileReader::GetUChar_TypeNode()
{
if (m_lPos >= m_lSize)
return NSBinPptxRW::g_nodeAttributeEnd;
BYTE res = *m_pDataCur;
++m_lPos;
++m_pDataCur;
return res;
}
bool CBinaryFileReader::GetBool()
{
return (GetUChar() != 0) ? true : false;
}
// 2 byte
_UINT16 CBinaryFileReader::GetUShort()
{
if (m_lPos + 1 >= m_lSize)
{
throw;
}
#if defined(_IOS) || defined(__ANDROID__)
_UINT16 res = 0;
memcpy(&res, m_pDataCur, sizeof(_UINT16));
#else
_UINT16 res = *((_UINT16*)m_pDataCur); // EXC_ARM_DA_ALIGN on ios
#endif
m_lPos += 2;
m_pDataCur += 2;
return res;
}
_INT16 CBinaryFileReader::GetShort()
{
if (m_lPos + 1 >= m_lSize)
{
throw;
}
#if defined(_IOS) || defined(__ANDROID__)
_INT16 res = 0;
memcpy(&res, m_pDataCur, sizeof(_INT16));
#else
_INT16 res = *((_INT16*)m_pDataCur); // EXC_ARM_DA_ALIGN on ios
#endif
m_lPos += 2;
m_pDataCur += 2;
return res;
}
// 4 byte
_UINT32 CBinaryFileReader::GetULong()
{
if (m_lPos + 3 >= m_lSize)
{
throw;
}
#if defined(_IOS) || defined(__ANDROID__)
_UINT32 res = 0;
memcpy(&res, m_pDataCur, sizeof(_UINT32));
#else
_UINT32 res = *((_UINT32*)m_pDataCur); // EXC_ARM_DA_ALIGN on ios
#endif
m_lPos += 4;
m_pDataCur += 4;
return res;
}
_INT64 CBinaryFileReader::GetLong64()
{
if (m_lPos + 7 >= m_lSize)
{
throw;
}
#if defined(_IOS) || defined(__ANDROID__)
_INT64 res = 0;
memcpy(&res, m_pDataCur, sizeof(_INT64));
#else
_INT64 res = *((_INT64*)m_pDataCur); // EXC_ARM_DA_ALIGN on ios
#endif
m_lPos += 8;
m_pDataCur += 8;
return res;
}
_INT32 CBinaryFileReader::GetRecordSize()
{
_INT32 sz = (_INT32)GetULong();
if (m_lPos + sz > m_lSize)
{
//todooo - переделать
throw;
}
return sz;
}
_INT32 CBinaryFileReader::GetLong()
{
return (_INT32)GetULong();
}
double CBinaryFileReader::GetDouble()
{
return 1.0 * GetLong() / 100000.;
}
// 8 byte
double CBinaryFileReader::GetDoubleReal()
{
if (m_lPos + (int)DOUBLE_SIZEOF > m_lSize)
{
throw;
}
#if defined(_IOS) || defined(__ANDROID__)
double res = 0.0;
memcpy(&res, m_pDataCur, sizeof(double));
#else
double res = *((double*)m_pDataCur); // EXC_ARM_DA_ALIGN on ios
#endif
m_lPos += DOUBLE_SIZEOF;
m_pDataCur += DOUBLE_SIZEOF;
return res;
}
//String
std::wstring CBinaryFileReader::GetString(_INT32 len, bool bDeleteZero)
{
len *= 2;
return GetString3(len, bDeleteZero);
}
std::string CBinaryFileReader::GetString1(_INT32 len)
{
if (len < 1 )
return "";
if (m_lPos + len > m_lSize)
{
throw;
}
std::string res((CHAR*)m_pDataCur, len);
m_lPos += len;
m_pDataCur += len;
return res;
}
std::wstring CBinaryFileReader::GetString2(bool bDeleteZero)
{
_INT32 len = GetLong();
return GetString(len, bDeleteZero);
}
std::wstring CBinaryFileReader::GetStringUtf8(_INT32 len)//len in byte for utf8
{
if (len < 1)
return L"";
if (m_lPos + len > m_lSize)
{
throw;
}
std::wstring res = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8(m_pDataCur, len);
m_lPos += len;
m_pDataCur += len;
return res;
}
std::wstring CBinaryFileReader::GetString3(_INT32 len, bool bDeleteZero)//len in byte for utf16
{
if (len < 1 )
return L"";
if (m_lPos + len > m_lSize)
{
throw;
}
int lSize = len >> 1; //string in char
if (bDeleteZero)
{
while (lSize > 0)
{
if (((unsigned short*)m_pDataCur)[lSize - 1] == 0)
lSize--;
else
break;
}
}
if (sizeof(wchar_t) == 4)
{
std::wstring val = NSFile::CUtf8Converter::GetWStringFromUTF16((unsigned short*)m_pDataCur, lSize);
std::wstring res(val.c_str(), val.length());
m_lPos += len;
m_pDataCur += len;
return res;
}
else
{
std::wstring res((WCHAR*)m_pDataCur, lSize);
m_lPos += len;
m_pDataCur += len;
return res;
}
}
std::wstring CBinaryFileReader::GetString4(_INT32 len)//len in byte for utf16
{
if (len < 1)
return L"";
if (m_lPos + len > m_lSize)
{
throw;
}
_UINT32 lSize = len >> 1; //string in char
std::wstring res = NSFile::CUtf8Converter::GetWStringFromUTF16((unsigned short*)m_pDataCur, lSize);
m_lPos += len;
m_pDataCur += len;
return res;
}
bool CBinaryFileReader::GetArray(BYTE *pBuffer, _INT32 len)
{
if (0 == len)
return false;
if (m_lPos + len > m_lSize)
return false;
//*pBuffer = new BYTE [len];
memcpy(pBuffer, m_pDataCur, len);
m_lPos += len;
m_pDataCur += len;
return true;
}
/*LPSAFEARRAY CBinaryFileReader::GetArray(_INT32 len)
{
if (0 == len)
return NULL;
if (m_lPos + len > m_lSize)
return NULL;
SAFEARRAY* pArray = SafeArrayCreateVector(VT_UI1, (_UINT32)len);
BYTE* pDataD = (BYTE*)pArray->pvData;
memcpy(pDataD, m_pDataCur, len);
m_lPos += len;
m_pDataCur += len;
return pArray;
}
*/
std::wstring CBinaryFileReader::GetStringUtf8()
{
_INT32 len = GetULong();
return GetStringUtf8(len);
}
std::string CBinaryFileReader::GetString2A()
{
_INT32 len = GetULong();
return GetString1(len);
}
void CBinaryFileReader::SkipRecord()
{
_INT32 _len = GetRecordSize();
Skip(_len);
}
LONG CBinaryFileReader::GetPos()
{
return m_lPos;
}
LONG CBinaryFileReader::GetSize()
{
return m_lSize;
}
BYTE* CBinaryFileReader::GetData()
{
return m_pData;
}
BYTE* CBinaryFileReader::GetPointer(int nSize = 0)
{
if (nSize < 0) return 0;
if (m_lPos + nSize > m_lSize)
{
throw;
}
BYTE* res = (BYTE*)m_pDataCur;
m_lPos += nSize;
m_pDataCur += nSize;
return res;
}
_UINT16 CBinaryFileReader::XlsbReadRecordType()
{
_UINT16 nValue = GetUChar();
if (0 != (nValue & 0x80))
{
BYTE nPart = GetUChar();
nValue = (nValue & 0x7F) | ((nPart & 0x7F) << 7);
}
return nValue;
}
void CBinaryFileReader::XlsbSkipRecord()
{
Skip(XlsbReadRecordLength());
}
_UINT32 CBinaryFileReader::XlsbReadRecordLength()
{
_UINT32 nValue = 0;
for (int i = 0; i < 4; ++i)
{
BYTE nPart = GetUChar();
nValue |= (nPart & 0x7F) << (7 * i);
if (0 == (nPart & 0x80))
{
break;
}
}
return nValue;
}
void CBinaryFileReader::SetDstContentRels()
{
++m_nCurrentRelsStack;
//чистить текущий m_pRels хорошо при последовательной записи автофигур в word.
//плохо в случае записи перезентаций, с момента перехода на единственный обьект m_pReader.
//пример: презетации записали несколько Rels, записываем chart, вызывается SetDstContentRels и трутся Rels презентаций
//if (0 == m_pReader->m_nCurrentRelsStack)
//{
// m_pReader->m_pRels->Clear();
// m_pReader->m_pRels->StartRels();
//}
//else
{
m_stackRels.push_back(m_pRels);
m_pRels = new NSBinPptxRW::CRelsGenerator(m_pRels->m_pManager);
m_pRels->StartRels();
}
}
void CBinaryFileReader::SaveDstContentRels(const std::wstring& bsRelsPath)
{
m_pRels->CloseRels();
m_pRels->SaveRels(bsRelsPath);
--m_nCurrentRelsStack;
if (-1 > m_nCurrentRelsStack)
m_nCurrentRelsStack = -1;
//if (-1 != m_pReader->m_nCurrentRelsStack)
{
int nIndex = (int)m_stackRels.size() - 1;
if (0 <= nIndex)
{
NSBinPptxRW::CRelsGenerator* pCur = m_pRels;
m_pRels = m_stackRels[nIndex];
m_stackRels.erase(m_stackRels.begin() + nIndex);
RELEASEOBJECT(pCur);
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink