Yajbir-Malik/DocumentServer-v-9.2.0
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
8f5cb6a648a79c0ac5a5cfe6e6b7c3d059936737
DocumentServer-v-9.2.0/core/OOXML/PPTXFormat/Logic/Pic.cpp
Yajbir Singh f1b860b25c
Some checks failed
check / markdownlint (push) Has been cancelled
Details
check / spellchecker (push) Has been cancelled
Details
updated
2025-12-11 19:03:17 +05:30

1990 lines
66 KiB
C++
Raw 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 "Pic.h"
#include "../../../MsBinaryFile/XlsFile/Converter/ConvertXls2Xlsx.h"
#include "../../../MsBinaryFile/DocFile/Main/DocFormatLib.h"
#include "../../Binary/Document/BinWriter/BinEquationWriter.h"
#include "../../Binary/Document/BinWriter/BinaryWriterD.h"
#include "../../Binary/Document/BinReader/BinaryReaderD.h"
#include "../../Binary/Document/BinReader/FileWriter.h"
#include "../../Binary/Document/DocWrapper/FontProcessor.h"
#include "../../Binary/Document/DocWrapper/XlsxSerializer.h"
#include "../../Binary/Document/DocWrapper/VsdxSerializer.h"
#include "../../Binary/Sheets/Reader/BinaryWriterS.h"
#include "../../Binary/Sheets/Writer/BinaryReaderS.h"
#include "../../Binary/Draw/BinaryWriterV.h"
#include "../../Binary/Draw/BinaryReaderV.h"
#include "../../Binary/MathEquation/MathEquation.h"
#include "SpTree.h"
#include "Shape.h"
#include "./../SlideLayout.h"
#include "./../SlideMaster.h"
#include "./../Slide.h"
#include "./../NotesSlide.h"
#include "./../NotesMaster.h"
#include "Media/MediaFile.h"
#include "Media/WavAudioFile.h"
#include "../../DocxFormat/App.h"
#include "../../DocxFormat/Core.h"
#include "../../DocxFormat/Media/Audio.h"
#include "../../DocxFormat/Media/Video.h"
#include "../../DocxFormat/Media/OleObject.h"
#include "../../DocxFormat/Media/ActiveX.h"
#include "../../../Common/OfficeFileFormatChecker.h"
#include "../../../OfficeUtils/src/OfficeUtils.h"
namespace PPTX
{
namespace Limit
{
OLEDrawAspectType::OLEDrawAspectType()
{
m_strValue = L"Content";
}
void OLEDrawAspectType::set(const std::wstring& strValue)
{
if ((L"Content" == strValue) ||
(L"Icon" == strValue))
{
m_strValue = strValue;
}
}
unsigned char OLEDrawAspectType::GetBYTECode() const
{
if (L"Content" == m_strValue)
return 0;
if (L"Icon" == m_strValue)
return 1;
return 0;
}
void OLEDrawAspectType::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0:
m_strValue = L"Content";
break;
case 1:
m_strValue = L"Icon";
break;
default:
break;
}
}
OLEType::OLEType()
{
m_strValue = L"Embed";
}
void OLEType::set(const std::wstring& strValue)
{
if ((L"Embed" == strValue) ||
(L"Link" == strValue))
{
m_strValue = strValue;
}
}
unsigned char OLEType::GetBYTECode() const
{
if (L"Embed" == m_strValue)
return 0;
if (L"Link" == m_strValue)
return 1;
return 0;
}
void OLEType::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0:
m_strValue = L"Embed";
break;
case 1:
m_strValue = L"Link";
break;
default:
break;
}
}
OLEUpdateMode::OLEUpdateMode()
{
m_strValue = L"Always";
}
void OLEUpdateMode::set(const std::wstring& strValue)
{
if ((L"Always" == strValue) ||
(L"OnCall" == strValue))
{
m_strValue = strValue;
}
}
unsigned char OLEUpdateMode::GetBYTECode() const
{
if (L"Always" == m_strValue)
return 0;
if (L"OnCall" == m_strValue)
return 1;
return 0;
}
void OLEUpdateMode::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0:
m_strValue = L"Always";
break;
case 1:
m_strValue = L"OnCall";
break;
default:
break;
}
}
}
namespace Logic
{
void COLEObject::fromXML(XmlUtils::CXmlNode& node)
{
XmlMacroReadAttributeBase(node, L"DrawAspect", m_oDrawAspect);
XmlMacroReadAttributeBase(node, L"r:id", m_oId);
XmlMacroReadAttributeBase(node, L"ObjectID", m_sObjectId);
XmlMacroReadAttributeBase(node, L"ProgID", m_sProgId);
XmlMacroReadAttributeBase(node, L"ShapeID", m_sShapeId);
XmlMacroReadAttributeBase(node, L"Type", m_oType);
XmlMacroReadAttributeBase(node, L"UpdateMode", m_oUpdateMode);
XmlMacroReadAttributeBase(node, L"w:drawAspect", m_oDrawAspect);
XmlMacroReadAttributeBase(node, L"w:progId", m_sProgId);
XmlMacroReadAttributeBase(node, L"w:shapeId", m_sShapeId);
if (false == m_oId.IsInit())
{
XmlMacroReadAttributeBase( node, L"relationships:id", m_oId );
}
std::wstring ole_bin, ole_image, mspackage;
XmlMacroReadAttributeBase(node, L"pathbin", ole_bin);
XmlMacroReadAttributeBase(node, L"pathimg", ole_image);
XmlMacroReadAttributeBase(node, L"mspackage", mspackage);
if (m_OleObjectFile.IsInit() == false && !ole_bin.empty())
{
m_OleObjectFile = new OOX::OleObject(NULL, !mspackage.empty());
m_OleObjectFile->set_filename (ole_bin, false);
m_OleObjectFile->set_filename_cache (ole_image);
}
}
std::wstring COLEObject::toXML() const
{
return L"";
}
void COLEObject::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
{
std::wstring strName = L"o:OLEObject";
pWriter->StartNode(strName);
pWriter->StartAttributes();
pWriter->WriteAttribute(L"DrawAspect", m_oDrawAspect);
if (m_oId.IsInit())
{
pWriter->WriteAttribute(L"r:id", m_oId->ToString());
}
pWriter->WriteAttribute(L"ObjectID", m_sObjectId);
pWriter->WriteAttribute2(L"ProgID", m_sProgId);
pWriter->WriteAttribute(L"ShapeID", m_sShapeId);
pWriter->WriteAttribute(L"Type", m_oType);
pWriter->WriteAttribute(L"UpdateMode", m_oUpdateMode);
pWriter->EndAttributes();
pWriter->EndNode(strName);
}
void COLEObject::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
{
smart_ptr<OOX::OleObject> ole_file = m_OleObjectFile;
if (m_oId.IsInit() && ole_file.IsInit() == false)
{
OOX::IFileContainer* pRels = pWriter->GetRels().GetPointer();
ole_file = GetOleObject(m_oId.get(), pRels);
}
std::wstring sData;
std::wstring sProgID = m_sProgId.get_value_or(L"");
//test xls ole_file for convert to xlsx
if (ole_file.IsInit())
{
COfficeFileFormatChecker checker;
checker.isOfficeFile(ole_file->filename().GetPath());
if (checker.nFileType == AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS ||
checker.nFileType == AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC ||
checker.nFileType == AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC_FLAT)
{
std::wstring sTemp = ole_file->filename().GetDirectory();
std::wstring sResultOoxmlDir = sTemp + FILE_SEPARATOR_STR + _T("ooxml_unpacked");
NSDirectory::CreateDirectory(sResultOoxmlDir);
bool bMacro = true;
_UINT32 nRes = 0;
std::wstring ooxml_file;
if (checker.nFileType == AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS)
{
nRes = ConvertXls2Xlsx(ole_file->filename().GetPath(), sResultOoxmlDir, L"", L"", sTemp, 0, bMacro);
ooxml_file = ole_file->filename().GetPath() + (bMacro ? L".xlsm" : L".xlsx");
}
else if (checker.nFileType == AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC ||
checker.nFileType == AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC_FLAT)
{
COfficeDocFile docFile;
docFile.m_sTempFolder = ole_file->filename().GetDirectory();
nRes = docFile.LoadFromFile(ole_file->filename().GetPath(), sResultOoxmlDir, L"", bMacro);
ooxml_file = ole_file->filename().GetPath() + (bMacro ? L".docm" : L".docx");
}
else if (checker.nFileType == AVS_OFFICESTUDIO_FILE_PRESENTATION_PPT)
{//todooo
}
if (0 == nRes)
{
COfficeUtils oCOfficeUtils(NULL);
nRes = (S_OK == oCOfficeUtils.CompressFileOrDirectory(sResultOoxmlDir, ooxml_file)) ? nRes : S_FALSE;
}
NSDirectory::DeleteDirectory(sResultOoxmlDir);
if (0 == nRes && false == ooxml_file.empty())
{
ole_file->set_MsPackage(true);
ole_file->set_filename(ooxml_file, false);
}
}
else if (checker.nFileType == AVS_OFFICESTUDIO_FILE_OTHER_PACKAGE_IN_OLE)
{
POLE::Storage* storageIn = new POLE::Storage(ole_file->filename().GetPath().c_str());
if ((storageIn) && (storageIn->open(false, false))) //storage in storage
{
POLE::Stream stream(storageIn, L"Package");
if (false == stream.fail())
{//test package stream??? xls ole -> xlsx ole
POLE::uint64 size = stream.size();
unsigned char* data = new unsigned char[size];
stream.read(data, size);
storageIn->close();
std::wstring package = ole_file->filename().GetPath() + L".temp";
NSFile::CFileBinary file;
file.CreateFileW(package);
file.WriteFile(data, (DWORD)size);
file.CloseFile();
COfficeFileFormatChecker checker2;
checker2.isOfficeFile(package);
if (checker2.nFileType != AVS_OFFICESTUDIO_FILE_UNKNOWN)
{
std::wstring package2 = package + checker2.GetExtensionByType(checker2.nFileType);
file.CreateFileW(package2);
file.WriteFile(data, (DWORD)size);
file.CloseFile();
ole_file->set_MsPackage(true);
ole_file->set_filename(package2, false);
}
delete[]data;
}
}
delete storageIn;
}
}
if (ole_file.IsInit() && 0 == sProgID.find(L"asc."))
{
sData = GetOleData(ole_file->filename().GetPath());
}
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
pWriter->WriteString2(0, m_sProgId);
if (!sData.empty())
pWriter->WriteString1Data(1, sData.c_str(), sData.length());
pWriter->WriteInt2 (2, m_oDxaOrig);
pWriter->WriteInt2 (3, m_oDyaOrig);
pWriter->WriteLimit2(4, m_oDrawAspect);
pWriter->WriteLimit2(5, m_oType);
pWriter->WriteLimit2(6, m_oUpdateMode);
if (ole_file.IsInit() && ole_file->isMsPackage() == false)
{
std::wstring sExt = ole_file->filename().GetExtention(false);
if (!sExt.empty())
pWriter->WriteString1(7, L"maskFile." + sExt); //OleObject Binary FileName Extension (bin, xls, doc, ... other stream file)
}
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
if (m_oMoveWithCells.IsInit())
{
pWriter->StartRecord(5);
pWriter->WriteBYTE(*m_oMoveWithCells);
pWriter->EndRecord();
}
if (m_oSizeWithCells.IsInit())
{
pWriter->StartRecord(6);
pWriter->WriteBYTE(*m_oSizeWithCells);
pWriter->EndRecord();
}
if (ole_file.IsInit() == false) return;
if (ole_file->isMsPackage())
{
OOX::CPath oox_file = ole_file->filename();
OOX::CPath oox_unpacked = oox_file.GetDirectory(true) + L"Temp_" + oox_file.GetFilename();
if (true == NSDirectory::CreateDirectory(oox_unpacked.GetPath()))
{
COfficeUtils oOfficeUtils(NULL);
oOfficeUtils.ExtractToDirectory(oox_file.GetPath(), oox_unpacked.GetPath(), NULL, 0);
COfficeFileFormatChecker office_checker;
office_checker.isOOXFormatFile(oox_file.GetPath());
//-----------------------------------------------------------------------------------------
DocWrapper::FontProcessor oFontProcessor;
NSBinPptxRW::CDrawingConverter oDrawingConverter;
NSCommon::smart_ptr<OOX::IFileContainer> old_rels = pWriter->GetRels();
NSCommon::smart_ptr<PPTX::Theme> old_theme = *pWriter->m_pTheme;
NSShapeImageGen::CMediaManager* old_manager = oDrawingConverter.m_pBinaryWriter->m_pCommon->m_pMediaManager;
oDrawingConverter.m_pBinaryWriter->m_pCommon->m_pMediaManager = pWriter->m_pCommon->m_pMediaManager;
oDrawingConverter.SetFontPicker(pWriter->m_pCommon->m_pFontPicker);
BYTE embedded_type = 0;
if (office_checker.nFileType == AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX ||
office_checker.nFileType == AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCM)
{
embedded_type = 1;
BinDocxRW::CDocxSerializer* old_serializer = pWriter->m_pMainDocument;
BinDocxRW::CDocxSerializer oDocxSerializer;
oDrawingConverter.m_pBinaryWriter->m_pMainDocument = &oDocxSerializer;
oDocxSerializer.m_pParamsWriter = new BinDocxRW::ParamsWriter(oDrawingConverter.m_pBinaryWriter, &oFontProcessor, &oDrawingConverter, NULL);
BinDocxRW::BinaryFileWriter oBinaryFileWriter(*oDocxSerializer.m_pParamsWriter);
oBinaryFileWriter.intoBindoc(oox_unpacked.GetPath());
pWriter->m_pMainDocument = old_serializer;
}
else if (office_checker.nFileType == AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX ||
office_checker.nFileType == AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSM ||
office_checker.nFileType == AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSB)
{
embedded_type = 2;
BinXlsxRW::BinaryFileWriter xlsxBinaryWriter(oFontProcessor);
OOX::Spreadsheet::CXlsx *pXlsxEmbedded = NULL;
NSBinPptxRW::CXlsbBinaryWriter oXlsbWriter;
if (office_checker.nFileType == AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSB)
pXlsxEmbedded = new OOX::Spreadsheet::CXlsb();
else
pXlsxEmbedded = new OOX::Spreadsheet::CXlsx();
oXlsbWriter.WriteReserved(xlsxBinaryWriter.GetMainTableSize());
unsigned int nXlsbWriterStartPos = oXlsbWriter.GetPositionAbsolute();
pXlsxEmbedded->m_pXlsbWriter = &oXlsbWriter;
pXlsxEmbedded->m_bNeedCalcChain = false;
pXlsxEmbedded->Read(oox_unpacked);
pXlsxEmbedded->PrepareWorkbook();
unsigned int nXlsbWriterEndPos = oXlsbWriter.GetPositionAbsolute();
if (office_checker.nFileType == AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSB)
{
dynamic_cast<OOX::Spreadsheet::CXlsb*>(pXlsxEmbedded)->PrepareSi();
dynamic_cast<OOX::Spreadsheet::CXlsb*>(pXlsxEmbedded)->PrepareTableFormula();
dynamic_cast<OOX::Spreadsheet::CXlsb*>(pXlsxEmbedded)->ReadSheetData();
}
xlsxBinaryWriter.WriteMainTableStart(*oDrawingConverter.m_pBinaryWriter);
if (nXlsbWriterEndPos > nXlsbWriterStartPos)
{
xlsxBinaryWriter.WriteBinaryTable(oXlsbWriter.GetBuffer() + nXlsbWriterStartPos, nXlsbWriterEndPos - nXlsbWriterStartPos);
}
xlsxBinaryWriter.WriteContent(pXlsxEmbedded, NULL, &oDrawingConverter);
xlsxBinaryWriter.WriteMainTableEnd();
pXlsxEmbedded->m_pXlsbWriter = NULL;
delete pXlsxEmbedded;
}
//else if (office_checker.nFileType == AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX)
//{ todooo
// embedded_type = 3;
//}
else if (office_checker.nFileType == AVS_OFFICESTUDIO_FILE_DRAW_VSDX ||
office_checker.nFileType == AVS_OFFICESTUDIO_FILE_DRAW_VSDM ||
office_checker.nFileType == AVS_OFFICESTUDIO_FILE_DRAW_VSTX)
{
embedded_type = 5;
BinVsdxRW::BinaryFileWriter oBinaryFileWriter(oFontProcessor);
NSBinPptxRW::CBinaryFileWriter& oBufferedStream = *oDrawingConverter.m_pBinaryWriter;
oBufferedStream.m_strMainFolder = oDrawingConverter.m_pImageManager->GetDstFolder();
OOX::Draw::CVsdx* pVsdx = new OOX::Draw::CVsdx(oox_unpacked);
oBinaryFileWriter.WriteMainTableStart(oBufferedStream);
oBinaryFileWriter.WriteContent(pVsdx, &oDrawingConverter);
oBinaryFileWriter.WriteMainTableEnd();
RELEASEOBJECT(pVsdx);
}
else
{//unknown ms package
oDrawingConverter.m_pBinaryWriter->WriteString1(2, ole_file->filename().GetFilename());
}
pWriter->SetRels(old_rels);
*pWriter->m_pTheme = old_theme;
oDrawingConverter.m_pBinaryWriter->m_pCommon->m_pMediaManager = old_manager;
//---------------------------------------------------------------------------------------------------------------------
pWriter->StartRecord(1);
pWriter->WriteBYTE(embedded_type);
pWriter->EndRecord();
pWriter->StartRecord(2);
pWriter->WriteBYTEArray(oDrawingConverter.m_pBinaryWriter->GetBuffer(), oDrawingConverter.m_pBinaryWriter->GetPosition());
pWriter->EndRecord();
NSDirectory::DeleteDirectory(oox_unpacked.GetPath());
}
}
else if ( std::wstring::npos != sProgID.find(L"Equation"))
{
BYTE embedded_type = 4;
pWriter->StartRecord(1);
pWriter->WriteBYTE(embedded_type);
pWriter->EndRecord();
MathEquation::CEquationReader oReader (ole_file->filename().GetPath().c_str());
MathEquation::BinaryEquationWriter oBinEqWriter(pWriter);
oReader.SetOutputDev(&oBinEqWriter);
pWriter->StartRecord(2);
oReader.Parse();
pWriter->EndRecord();
}
}
void COLEObject::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
{
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
pReader->Skip(1); // start attributes
while (true)
{
BYTE _at = pReader->GetUChar_TypeNode();
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
break;
if (0 == _at) m_sProgId = pReader->GetString2();
else if (1 == _at) m_sData = pReader->GetString2();
else if (2 == _at) m_oDxaOrig = pReader->GetLong();
else if (3 == _at) m_oDyaOrig = pReader->GetLong();
else if (4 == _at) m_oDrawAspect = pReader->GetUChar();
else if (5 == _at) m_oType = pReader->GetUChar();
else if (6 == _at) m_oUpdateMode = pReader->GetUChar();
else if (7 == _at)//OleObject Binary FileName (bin, xls, doc, ... other stream file)
{
m_OleObjectFile = new OOX::OleObject(NULL, false, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
std::wstring strOlePath = pReader->GetString2(true);
m_OleObjectFile->set_filename(strOlePath, false); //temp !!! for ImageManager original file name
}
else
break;
}
if (m_sData.IsInit() && m_OleObjectFile.IsInit() == false)
{
m_OleObjectFile = new OOX::OleObject(NULL, false, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
}
BYTE embedded_type = 0;
while (pReader->GetPos() < _end_rec)
{
BYTE _at = pReader->GetUChar();
switch (_at)
{
case 1:
{
pReader->GetLong(); //skip size
embedded_type = pReader->GetUChar();
}break;
case 2:
{
LONG _embed_data_size = pReader->GetLong();
LONG _end_embed_data = pReader->GetPos() + _embed_data_size + 4;
if (_embed_data_size < 1)
break;
//------------------------------------------------------------------
std::wstring sDstEmbedded = pReader->m_pRels->m_pManager->GetDstMedia();
int nPos = (int)sDstEmbedded.rfind(wchar_t('m'));
if (-1 != nPos)
sDstEmbedded = sDstEmbedded.substr(0, nPos);
sDstEmbedded += L"embeddings";
//------------------------------------------------------------------
if (true == NSDirectory::CreateDirectory(sDstEmbedded))
{
if (embedded_type == 0) //unknown ms package
{
m_OleObjectFile = new OOX::OleObject(NULL, true, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
BYTE type = pReader->GetUChar();
std::wstring strOlePath = pReader->GetString2(true);
m_OleObjectFile->set_filename(strOlePath, false); //temp !!! for ImageManager original file name
}
else if (embedded_type == 1)
{
ReadDocxBin(pReader, sDstEmbedded, pReader->GetData() + pReader->GetPos(), _embed_data_size);
}
else if (embedded_type == 2)
{
ReadXlsxBin(pReader, sDstEmbedded, pReader->GetData() + pReader->GetPos(), _embed_data_size);
}
else if (embedded_type == 3)
{
// pptx bin
}
else if (embedded_type == 4) //math equation
{
pReader->Seek(pReader->GetPos() - 4); //roll back to size record
std::wstring sXmlContent;
if (pReader->m_pMainDocument)
{
pReader->m_pMainDocument->getXmlContentElem(OOX::et_m_oMathPara, *pReader, sXmlContent);
}
else
{
BinDocxRW::CDocxSerializer oDocxSerializer;
NSBinPptxRW::CDrawingConverter oDrawingConverter;
oDrawingConverter.SetMainDocument(&oDocxSerializer);
//oDocxSerializer.m_pParamsWriter = new BinDocxRW::ParamsWriter(oDrawingConverter.m_pBinaryWriter, &oFontProcessor, &oDrawingConverter, NULL);
oDocxSerializer.m_pCurFileWriter = new Writers::FileWriter(L"", L"", false, 111, &oDrawingConverter, L"");
oDocxSerializer.getXmlContentElem(OOX::et_m_oMathPara, *pReader, sXmlContent);
}
if (!sXmlContent.empty())
{
m_sAlternateContenteXml = sXmlContent;
}
}
else if (embedded_type == 5)
{
ReadVsdxBin(pReader, sDstEmbedded, pReader->GetData() + pReader->GetPos(), _embed_data_size);
}
else if (embedded_type == 6) //???
{
ReadOoxmlZip(pReader, sDstEmbedded, pReader->GetData() + pReader->GetPos(), _embed_data_size);
}
}
pReader->Seek(_end_embed_data);
}break;
case 5:
{
pReader->GetLong(); //skip size
m_oMoveWithCells = (0 != pReader->GetUChar());
}break;
case 6:
{
pReader->GetLong(); //skip size
m_oSizeWithCells = (0 != pReader->GetUChar());
}break;
}
}
pReader->Seek(_end_rec);
}
void COLEObject::FillParentPointersForChilds()
{
}
bool COLEObject::isValid()
{
return m_sProgId.IsInit() && (m_sData.IsInit() || m_oId.IsInit() || m_OleObjectFile.IsInit());
}
smart_ptr<OOX::OleObject> COLEObject::GetOleObject(const OOX::RId& oRId, OOX::IFileContainer* pRels) const
{
smart_ptr<OOX::OleObject> ole_file = m_OleObjectFile;
if (ole_file.IsInit() == false)
{
if (pRels != NULL)
ole_file = pRels->Get<OOX::OleObject>(oRId);
else
{
OOX::IFileContainer* pContainer = dynamic_cast<OOX::IFileContainer*>(const_cast<PPTX::WrapperFile*>(parentFile));
if (pContainer)
ole_file = pContainer->Get<OOX::OleObject>(oRId);
}
}
return ole_file;
}
std::wstring COLEObject::GetOleData(const std::wstring& sFilePath)const
{
std::wstring sRes;
//EncodingMode.unparsed https://github.com/tonyqus/npoi/blob/master/main/POIFS/FileSystem/Ole10Native.cs
POLE::Storage oStorage(sFilePath.c_str());
if (oStorage.open(false, false))
{
POLE::Stream oStream(&oStorage, L"Ole10Native");
if (oStream.size() > 4)
{
BYTE head[] = {0x00, 0x00, 0x00, 0x00};
oStream.read(head, 4);
_UINT32 nDataSize = (_UINT32)((head[0]<< 0) | ((head[1]) << 8) | ((head[2]) << 16) | ((head[3]) << 24));
BYTE* aData = new BYTE[nDataSize];
oStream.read(aData, nDataSize);
sRes = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8(aData, nDataSize);
RELEASEARRAYOBJECTS(aData);
}
}
return sRes;
}
OOX::EElementType COLEObject::getType () const
{
return OOX::et_oleobject;
}
Pic::Pic(std::wstring ns)
{
m_namespace = ns;
m_pLevelUp = NULL;
}
Pic::~Pic()
{
}
Pic::Pic(XmlUtils::CXmlNode& node)
{
m_pLevelUp = NULL;
fromXML(node);
}
Pic::Pic(XmlUtils::CXmlLiteReader& oReader)
{
m_pLevelUp = NULL;
fromXML(oReader);
}
OOX::EElementType Pic::getType () const
{
return OOX::et_pic;
}
const Pic& Pic::operator =(XmlUtils::CXmlNode& node)
{
fromXML(node);
return *this;
}
const Pic& Pic::operator =(XmlUtils::CXmlLiteReader& oReader)
{
fromXML(oReader);
return *this;
}
void Pic::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
m_namespace = XmlUtils::GetNamespace(oReader.GetName());
ReadAttributes(oReader);
if ( oReader.IsEmptyNode() )
return;
int nParentDepth = oReader.GetDepth();
while( oReader.ReadNextSiblingNode( nParentDepth ) )
{
std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
if (_T("nvPicPr") == strName)
nvPicPr = oReader;
else if (_T("blipFill") == strName)
blipFill = oReader;
else if (_T("spPr") == strName)
spPr = oReader;
else if (_T("style") == strName)
style = oReader;
}
FillParentPointersForChilds();
}
void Pic::fromXML(XmlUtils::CXmlNode& node)
{
m_namespace = XmlUtils::GetNamespace(node.GetName());
XmlMacroReadAttributeBase(node, L"macro", macro);
std::vector<XmlUtils::CXmlNode> oNodes;
if (node.GetNodes(_T("*"), oNodes))
{
size_t nCount = oNodes.size();
for (size_t i = 0; i < nCount; ++i)
{
XmlUtils::CXmlNode& item = oNodes[i];
std::wstring strName = XmlUtils::GetNameNoNS(item.GetName());
if (_T("nvPicPr") == strName)
nvPicPr = item;
else if (_T("blipFill") == strName)
blipFill = item;
else if (_T("spPr") == strName)
spPr = item;
else if (_T("style") == strName)
{
if (!style.IsInit())
style = item;
}
}
if (!blipFill.blip.is_init())
{
XmlUtils::CXmlNode oNodeMSAlternate;
if (node.GetNode(_T("mc:AlternateContent"), oNodeMSAlternate))
{
XmlUtils::CXmlNode oNodeFallback;
if (oNodeMSAlternate.GetNode(_T("mc:Fallback"), oNodeFallback))
{
blipFill = oNodeFallback.ReadNode(_T("p:blipFill"));
}
}
}
}
FillParentPointersForChilds();
}
std::wstring Pic::toXML() const
{
XmlUtils::CAttribute oAttr;
oAttr.Write2(L"macro", macro);
XmlUtils::CNodeValue oValue;
oValue.Write(nvPicPr);
oValue.Write(blipFill);
oValue.Write(spPr);
oValue.WriteNullable(style);
return XmlUtils::CreateNode(m_namespace + L":pic", oAttr, oValue);
}
void Pic::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
{
if (oleObject.IsInit())
{
pWriter->StartRecord(SPTREE_TYPE_OLE);
OOX::CVmlDrawing *pVml = NULL;
if (parentFileIs<PPTX::Slide>())
{
pVml = parentFileAs<PPTX::Slide>().Vml.GetPointer();
}
else if (parentFileIs<PPTX::SlideMaster>())
{
pVml = parentFileAs<PPTX::SlideMaster>().Vml.GetPointer();
}
if (oleObject->m_sShapeId.IsInit() && pVml && !blipFill.blip->embed.IsInit() && blipFill.blip->oleFilepathImage.empty())
{
std::map<std::wstring, OOX::CVmlDrawing::_vml_shape>::iterator pFind = pVml->m_mapShapes.find(*oleObject->m_sShapeId);
if (pVml->m_mapShapes.end() != pFind)
{
pFind->second.bUsed = true;
OOX::Vml::CVmlCommonElements* pShape = dynamic_cast<OOX::Vml::CVmlCommonElements*>(pFind->second.pElement);
if (pShape)
{
for(size_t i = 0; i < pShape->m_arrItems.size(); ++i)
{
OOX::WritingElement* pChildElemShape = pShape->m_arrItems[i];
if (OOX::et_v_imagedata == pChildElemShape->getType())
{
OOX::Vml::CImageData* pImageData = static_cast<OOX::Vml::CImageData*>(pChildElemShape);
std::wstring sIdImageFileCache;
if (pImageData->m_oRelId.IsInit()) sIdImageFileCache = pImageData->m_oRelId->GetValue();
else if (pImageData->m_rId.IsInit()) sIdImageFileCache = pImageData->m_rId->GetValue();
else if (pImageData->m_rPict.IsInit()) sIdImageFileCache = pImageData->m_rPict->GetValue();
if (!sIdImageFileCache.empty())
{
//ищем физический файл ( rId относительно vml_drawing)
smart_ptr<OOX::File> pFile = pVml->Find(sIdImageFileCache);
if (pFile.IsInit() && ( OOX::FileTypes::Image == pFile->type()))
{
OOX::Image* pImageFileCache = static_cast<OOX::Image*>(pFile.GetPointer());
blipFill.blip->oleFilepathImage = pImageFileCache->filename().GetPath();
}
}
}
}
}
}
}
}
else if (nvPicPr.nvPr.media.is_init())
{
blipFill.additionalFiles.emplace_back();
blipFill.additionalFiles.back() = GetMediaLink(pWriter);
smart_ptr<OOX::Media> mediaFile = blipFill.additionalFiles.back().smart_dynamic_cast<OOX::Media>();
if (mediaFile.IsInit() && blipFill.blip.IsInit())
{
blipFill.blip->mediaFilepath = mediaFile->filename().GetPath();
blipFill.blip->mediaExternal = mediaFile->IsExternal();
}
if (nvPicPr.nvPr.media.is<MediaFile>())
{
if (nvPicPr.nvPr.media.as<MediaFile>().name == L"audioFile")
pWriter->StartRecord(SPTREE_TYPE_AUDIO);
else if (nvPicPr.nvPr.media.as<MediaFile>().name == L"videoFile" ||
nvPicPr.nvPr.media.as<MediaFile>().name == L"quickTimeFile")
pWriter->StartRecord(SPTREE_TYPE_VIDEO);
else
pWriter->StartRecord(SPTREE_TYPE_PIC);
}
else if (nvPicPr.nvPr.media.is<WavAudioFile>() || nvPicPr.nvPr.media.is<AudioCD>())
{
pWriter->StartRecord(SPTREE_TYPE_AUDIO);
}
else
pWriter->StartRecord(SPTREE_TYPE_PIC);
}
else
{
pWriter->StartRecord(SPTREE_TYPE_PIC);
}
if (!blipFill.additionalFiles.empty() && blipFill.additionalFiles.back().is<OOX::Media>())
{
smart_ptr<OOX::Media> mediaFile = blipFill.additionalFiles.back().smart_dynamic_cast<OOX::Media>();
pWriter->StartRecord(5);
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
std::wstring sExt = mediaFile->filename().GetExtention(false);
if (!sExt.empty() && !mediaFile->IsExternal())
pWriter->WriteString1(0, L"maskFile." + sExt);
else
pWriter->WriteString1(0, mediaFile->filename().GetPath());
pWriter->WriteBool1(1, mediaFile->IsExternal());
//todoo start, end positions ..
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
pWriter->EndRecord();
}
pWriter->WriteRecord2(4, oleObject);
pWriter->WriteRecord1(0, nvPicPr);
pWriter->WriteRecord1(2, spPr);
pWriter->WriteRecord1(1, blipFill);
pWriter->WriteRecord2(3, style);
if (macro.IsInit())
{
pWriter->StartRecord(SPTREE_TYPE_MACRO);
pWriter->WriteString1(0, *macro);
pWriter->EndRecord();
}
pWriter->EndRecord();
}
void Pic::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
{
std::wstring namespace_ = m_namespace;
bool bOle = false;
if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX) namespace_ = L"xdr";
else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX ||
pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX_GLOSSARY) namespace_ = L"pic";
else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_GRAPHICS) namespace_ = L"a";
else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_CHART_DRAWING) namespace_ = L"cdr";
else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DIAGRAM) namespace_ = L"dgm";
else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DSP_DRAWING) namespace_ = L"dsp";
if (pWriter->m_lDocType != XMLWRITER_DOC_TYPE_XLSX &&
pWriter->m_lDocType != XMLWRITER_DOC_TYPE_DOCX &&
pWriter->m_lDocType != XMLWRITER_DOC_TYPE_DOCX_GLOSSARY)
{
if (oleObject.IsInit() && oleObject->isValid())
{
int _id = nvPicPr.cNvPr.id;
if (_id <= 0)
{
_id = pWriter->m_lObjectId;
++pWriter->m_lObjectId;
}
else
{
if (pWriter->m_lObjectId <= (unsigned int)_id)
{
pWriter->m_lObjectId = _id + 1;
}
}
bOle = true;
pWriter->WriteString(L"<p:graphicFrame><p:nvGraphicFramePr>");
pWriter->WriteString(L"<p:cNvPr id=\"" + std::to_wstring(_id) + L"\"");
pWriter->WriteString(L" name=\"" + nvPicPr.cNvPr.name + L"\"");
pWriter->WriteString(L"/><p:cNvGraphicFramePr>");
pWriter->WriteString(L"<a:graphicFrameLocks xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" noChangeAspect=\"1\"/>");
pWriter->WriteString(L"</p:cNvGraphicFramePr>");
pWriter->WriteString(L"<p:nvPr>");
//pWriter->WriteString(L"<p:extLst><p:ext uri=\"{D42A27DB-BD31-4B8C-83A1-F6EECF244321}\">");
//pWriter->WriteString(L"<p14:modId xmlns:p14=\"http://schemas.microsoft.com/office/powerpoint/2010/main\" val=\"2157879785\"/>");
//pWriter->WriteString(L"</p:ext></p:extLst>");
pWriter->WriteString(L"</p:nvPr></p:nvGraphicFramePr>");
if (spPr.xfrm.IsInit())
{
std::wstring oldName = spPr.xfrm->node_name;
spPr.xfrm->node_name = _T("p:xfrm");
spPr.xfrm->toXmlWriter(pWriter);
spPr.xfrm->node_name = oldName;
}
pWriter->WriteString(L"<a:graphic><a:graphicData uri=\"http://schemas.openxmlformats.org/presentationml/2006/ole\">");
pWriter->StartNode(_T("p:oleObj"));
pWriter->WriteAttribute(L"name", (std::wstring)L"oleObj");
if (oleObject->m_oId.IsInit())
{
pWriter->WriteAttribute2(L"r:id", oleObject->m_oId->get());
}
if (oleObject->m_oDxaOrig.IsInit())
{
int nDxaOrig = oleObject->m_oDxaOrig.get();
pWriter->WriteAttribute(L"imgW", 635 * nDxaOrig); //twips to emu
}
if (oleObject->m_oDyaOrig.IsInit())
{
int nDyaOrig = oleObject->m_oDyaOrig.get();
pWriter->WriteAttribute(L"imgH", 635 * nDyaOrig); //twips to emu
}
if ((oleObject->m_oDrawAspect.IsInit()) && (oleObject->m_oDrawAspect->GetBYTECode() == 1))
{
pWriter->WriteAttribute(L"showAsIcon", 1);
}
pWriter->WriteAttribute2(L"progId", oleObject->m_sProgId);
pWriter->EndAttributes();
pWriter->WriteString(L"<p:embed/>");
}
}
pWriter->StartNode(namespace_ + L":pic");
if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX ||
pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX_GLOSSARY)
{
pWriter->StartAttributes();
pWriter->WriteAttribute(_T("xmlns:pic"), (std::wstring)_T("http://schemas.openxmlformats.org/drawingml/2006/picture"));
}
pWriter->WriteAttribute2(L"macro", macro);
pWriter->EndAttributes();
nvPicPr.toXmlWriter(pWriter);
blipFill.m_namespace = namespace_;
blipFill.toXmlWriter(pWriter);
pWriter->m_lFlag = 1;
spPr.toXmlWriter(pWriter);
pWriter->m_lFlag = 0;
pWriter->Write(style);
pWriter->EndNode(namespace_ + L":pic");
if (pWriter->m_lDocType != XMLWRITER_DOC_TYPE_XLSX &&
pWriter->m_lDocType != XMLWRITER_DOC_TYPE_DOCX &&
pWriter->m_lDocType != XMLWRITER_DOC_TYPE_DOCX_GLOSSARY)
{
if (bOle)
{
pWriter->WriteString(L"</p:oleObj></a:graphicData></a:graphic></p:graphicFrame>");
}
}
}
void Pic::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
{
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
nvPicPr.cNvPr.id = -1;
while (pReader->GetPos() < _end_rec)
{
BYTE _at = pReader->GetUChar();
switch (_at)
{
case 0:
{
nvPicPr.fromPPTY(pReader);
}break;
case 1:
{
blipFill.fromPPTY(pReader);
if (oleObject.IsInit() && blipFill.blip.IsInit())
{
if (oleObject->m_OleObjectFile.IsInit() == false)
oleObject->m_OleObjectFile = new OOX::OleObject(NULL, false, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
oleObject->m_OleObjectFile->set_filename_cache(blipFill.blip->oleFilepathImage);
if (NSFile::CFileBinary::Exists(oleObject->m_OleObjectFile->filename().GetPath()) == false)
{
oleObject->m_OleObjectFile->set_filename(blipFill.blip->oleFilepathBin, false);
}
}
for (auto additionalFile : blipFill.additionalFiles)
{
smart_ptr<OOX::Media> mediaFile = additionalFile.smart_dynamic_cast<OOX::Media>();
if (mediaFile.IsInit() && blipFill.blip.IsInit())
{
if (!mediaFile->IsExternal() && NSFile::CFileBinary::Exists(mediaFile->filename().GetPath()) == false)
{
mediaFile->set_filename(blipFill.blip->mediaFilepath,
false == NSFile::CFileBinary::Exists(blipFill.blip->mediaFilepath));
}
}
}
}break;
case 2:
{
spPr.fromPPTY(pReader);
}break;
case 3:
{
style = new ShapeStyle(L"p");
style->fromPPTY(pReader);
}break;
case 4:
{
oleObject = new COLEObject();
oleObject->fromPPTY(pReader);
if (oleObject->m_sData.IsInit())
blipFill.oleData = oleObject->m_sData.get();
blipFill.additionalFiles.emplace_back();
blipFill.additionalFiles.back() = oleObject->m_OleObjectFile.smart_dynamic_cast<OOX::File>();
}break;
case 5:
{
bool isExternal = false;
std::wstring strMediaFileMask;
LONG _end_rec1 = pReader->GetPos() + pReader->GetRecordSize() + 4;
pReader->Skip(1); // start attributes
while (true)
{
BYTE _at = pReader->GetUChar_TypeNode();
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
break;
if (0 == _at)
{
strMediaFileMask = pReader->GetString2();
}
else if (1 == _at)
{
isExternal = pReader->GetBool();
}
else
break;
}
smart_ptr<OOX::Media> mediaFile = blipFill.additionalFiles.back().smart_dynamic_cast<OOX::Media>();
if (mediaFile.IsInit())
{
mediaFile->set_filename(strMediaFileMask, isExternal);
}
pReader->Seek(_end_rec1);
}break;
case SPTREE_TYPE_MACRO:
{
pReader->Skip(5); // type + size
macro = pReader->GetString2();
}break;
default:
{
break;
}
}
}
if (blipFill.blip.IsInit())
{
for (auto additionalFile : blipFill.additionalFiles)
{
if (false == additionalFile.IsInit()) continue;
if (!blipFill.blip->oleRid.empty() && oleObject.IsInit())
{
oleObject->m_oId = OOX::RId(blipFill.blip->oleRid);
if (oleObject->m_OleObjectFile.IsInit() == false)
{
oleObject->m_OleObjectFile = new OOX::OleObject(NULL, false, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
oleObject->m_OleObjectFile->set_filename(blipFill.blip->oleFilepathBin, false);
oleObject->m_OleObjectFile->set_filename_cache(blipFill.blip->oleFilepathImage);
}
}
if (false == blipFill.blip->mediaRid.empty() && additionalFile.IsInit())
{
smart_ptr<OOX::Media> mediaFile = additionalFile.smart_dynamic_cast<OOX::Media>();
bool bExternal = mediaFile->IsExternal();
std::wstring strMediaRelsPath;
if (pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX) strMediaRelsPath = L"media/";
else strMediaRelsPath = L"../media/";
if (bExternal)
{
strMediaRelsPath = mediaFile->filename().GetFilename();
}
else
{
strMediaRelsPath += mediaFile->filename().GetFilename();
PPTX::Logic::Ext ext;
if (additionalFile->type() == OOX::FileTypes::Audio ||
additionalFile->type() == OOX::FileTypes::Video)
{
ext.link_media = OOX::RId(blipFill.blip->mediaRid);
nvPicPr.nvPr.extLst.push_back(ext);
if (nvPicPr.cNvPr.hlinkClick.IsInit() == false)
nvPicPr.cNvPr.hlinkClick.Init();
nvPicPr.cNvPr.hlinkClick->id = L"";
nvPicPr.cNvPr.hlinkClick->action = L"ppaction://media";
}
else if (additionalFile->type() == OOX::FileTypes::SvgBlip)
{
ext.link_svg = OOX::RId(blipFill.blip->mediaRid);
blipFill.blip->ExtLst.push_back(ext);
}
}
unsigned int nRId = 0;
if (additionalFile.is<OOX::Audio>())
{
nvPicPr.nvPr.media.Media = new PPTX::Logic::MediaFile(L"audioFile");
nRId = pReader->m_pRels->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/audio", strMediaRelsPath, bExternal ? L"External" : L"");
}
if (additionalFile.is<OOX::Video>())
{
nvPicPr.nvPr.media.Media = new PPTX::Logic::MediaFile(L"videoFile");
nRId = pReader->m_pRels->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/video", strMediaRelsPath, bExternal ? L"External" : L"");
}
if (nvPicPr.nvPr.media.Media.IsInit() && nRId > 0)
{
PPTX::Logic::MediaFile& mediaFile = nvPicPr.nvPr.media.Media.as<PPTX::Logic::MediaFile>();
mediaFile.link = OOX::RId((size_t)nRId);
}
}
}
}
pReader->Seek(_end_rec);
}
void Pic::FillLevelUp()
{
if ((m_pLevelUp == NULL) && (nvPicPr.nvPr.ph.IsInit()))
{
if ((nvPicPr.nvPr.ph->type.IsInit()) || (nvPicPr.nvPr.ph->idx.IsInit()))
{
if (parentFileIs<Slide>())
{
parentFileAs<Slide>().Layout->GetLevelUp(this);
}
else if (parentFileIs<SlideLayout>())
{
parentFileAs<SlideLayout>().Master->GetLevelUp(this);
}
else if (parentFileIs<NotesSlide>())
{
parentFileAs<NotesSlide>().master_->GetLevelUp(this);
}
}
}
}
void Pic::Merge(Pic& pic, bool bIsSlidePlaceholder)
{
if (m_pLevelUp)
m_pLevelUp->Merge(pic, true);
pic.nvPicPr = nvPicPr;
pic.blipFill = blipFill;
pic.oleObject = oleObject;
spPr.Merge(pic.spPr);
if (style.is_init())
{
pic.style = style;
pic.style->SetParentFilePointer(parentFile);
}
}
void Pic::FillParentPointersForChilds()
{
nvPicPr.SetParentPointer(this);
blipFill.SetParentPointer(this);
spPr.SetParentPointer(this);
if (style.IsInit())
style->SetParentPointer(this);
if (oleObject.IsInit())
oleObject->SetParentPointer(this);
}
void Pic::GetRect(Aggplus::RECT& pRect)const
{
pRect.bottom = 0;
pRect.left = 0;
pRect.right = 0;
pRect.top = 0;
if (spPr.xfrm.IsInit())
{
pRect.left = spPr.xfrm->offX.get_value_or(0);
pRect.top = spPr.xfrm->offY.get_value_or(0);
pRect.right = pRect.left + spPr.xfrm->extX.get_value_or(0);
pRect.bottom = pRect.top + spPr.xfrm->extY.get_value_or(0);
}
if (parentIs<Logic::SpTree>())
parentAs<Logic::SpTree>().NormalizeRect(pRect);
}
std::wstring Pic::GetFullPicName()const
{
if (blipFill.blip.IsInit())
return blipFill.blip->GetFullPicName();
return _T("");
}
smart_ptr<OOX::File> Pic::GetMediaLink(NSBinPptxRW::CBinaryFileWriter* pWriter)const
{
smart_ptr<OOX::File> file;
OOX::IFileContainer* pRels = NULL;
if (parentFileIs<Slide>())
{
pRels = dynamic_cast<OOX::IFileContainer*>(const_cast<PPTX::WrapperFile*>(parentFile));
}
//else if ..layout, master
else if (pWriter)
{
pRels = pWriter->GetRels().GetPointer();
}
if (pRels)
{
if (nvPicPr.nvPr.media.is<WavAudioFile>())
{
return pRels->Find(nvPicPr.nvPr.media.as<WavAudioFile>().embed.get());
}
if (nvPicPr.nvPr.media.is<MediaFile>())
{
file = pRels->Find(nvPicPr.nvPr.media.as<MediaFile>().link.get());
smart_ptr<OOX::Media> mediaFile = file.smart_dynamic_cast<OOX::Media>();
if ( (mediaFile.IsInit() == false || mediaFile->filename().GetPath() == L"NULL") && !nvPicPr.nvPr.extLst.empty())
{
//todooo - почему везде нулевой то? - сделать поиск по всем uri
file = pRels->Find(nvPicPr.nvPr.extLst[0].link_media.get());
}
}
}
return file;
}
DWORD Pic::GetFill(UniFill& fill)const
{
DWORD BGRA = 0;
fill.SetParentFilePointer(parentFile);
if (style.IsInit())
{
if (parentFileIs<PPTX::Slide>())
parentFileAs<PPTX::Slide>().theme->GetFillStyle(style->fillRef.idx.get_value_or(0), fill);
else if (parentFileIs<PPTX::SlideLayout>())
parentFileAs<PPTX::SlideLayout>().theme->GetFillStyle(style->fillRef.idx.get_value_or(0), fill);
else if (parentFileIs<PPTX::SlideMaster>())
parentFileAs<PPTX::SlideMaster>().theme->GetFillStyle(style->fillRef.idx.get_value_or(0), fill);
BGRA = style->fillRef.Color.GetBGRA();
}
if (spPr.Fill.is_init())
spPr.Fill.Merge(fill);
return BGRA;
}
DWORD Pic::GetLine(Ln& line)const
{
DWORD BGRA = 0;
line.SetParentFilePointer(parentFile);
if (style.is_init())
{
if (parentFileIs<PPTX::Slide>())
parentFileAs<PPTX::Slide>().theme->GetLineStyle(style->lnRef.idx.get_value_or(0), line);
else if (parentFileIs<PPTX::SlideLayout>())
parentFileAs<PPTX::SlideLayout>().theme->GetLineStyle(style->lnRef.idx.get_value_or(0), line);
else if (parentFileIs<PPTX::SlideMaster>())
parentFileAs<PPTX::SlideMaster>().theme->GetLineStyle(style->lnRef.idx.get_value_or(0), line);
BGRA = style->lnRef.Color.GetBGRA();
}
if (spPr.ln.IsInit())
spPr.ln->Merge(line);
return BGRA;
}
double Pic::GetStTrim () const
{
double trim = 0.0;
if (parentFileIs<FileContainer>())
{
if (nvPicPr.nvPr.media.is<MediaFile>())
{
if ((nvPicPr.nvPr.media.as<MediaFile>().name == _T("videoFile")) ||
(nvPicPr.nvPr.media.as<MediaFile>().name == _T("quickTimeFile")) ||
(nvPicPr.nvPr.media.as<MediaFile>().name == _T("audioFile")) )
{
if (std::wstring (_T("NULL")) == parentFileAs<FileContainer>().GetLinkFromRId(nvPicPr.nvPr.media.as<MediaFile>().link.get()) ) // HAVE TRIM
{
if (nvPicPr.nvPr.extLst.size())
{
if (nvPicPr.nvPr.extLst[0].st.is_init())
trim = nvPicPr.nvPr.extLst[0].st.get();
}
}
}
}
}
return trim;
}
double Pic::GetEndTrim () const
{
double trim = -1.0;
if (nvPicPr.nvPr.media.is<MediaFile>())
{
if ((nvPicPr.nvPr.media.as<MediaFile>().name == _T("videoFile")) ||
(nvPicPr.nvPr.media.as<MediaFile>().name == _T("quickTimeFile")) ||
(nvPicPr.nvPr.media.as<MediaFile>().name == _T("audioFile")) )
{
if (parentFileIs<FileContainer>())
{
if (std::wstring (_T("NULL")) == parentFileAs<FileContainer>().GetLinkFromRId(nvPicPr.nvPr.media.as<MediaFile>().link.get())) // HAVE TRIM
{
if (nvPicPr.nvPr.extLst.size())
{
if (nvPicPr.nvPr.extLst[0].end.is_init())
trim = nvPicPr.nvPr.extLst[0].end.get();
}
}
}
}
}
return trim;
}
long Pic::GetRefId() const
{
return (long) nvPicPr.cNvPr.id;
}
std::wstring CorrentCropString(const std::wstring val)
{
int nVal = XmlUtils::GetInteger(val);
double dKoef = 65536 / 100000.0;
nVal = (int)(dKoef * nVal + 0.5);
return std::to_wstring(nVal) + L"f";
}
void Pic::toXmlWriterVML(NSBinPptxRW::CXmlWriter *pWriter, NSCommon::smart_ptr<PPTX::Theme>& oTheme, NSCommon::smart_ptr<PPTX::Logic::ClrMap>& oClrMap, bool in_group)
{
bool bOle = oleObject.IsInit() && oleObject->isValid();
std::wstring sOleNodeName;
if (XMLWRITER_DOC_TYPE_XLSX != pWriter->m_lDocType)
{
if (bOle && oleObject->m_oDxaOrig.IsInit() && oleObject->m_oDyaOrig.IsInit())
{
sOleNodeName = L"w:object";
pWriter->StartNode(sOleNodeName);
pWriter->StartAttributes();
pWriter->WriteAttribute(L"w:dxaOrig", oleObject->m_oDxaOrig);
pWriter->WriteAttribute(L"w:dyaOrig", oleObject->m_oDyaOrig);
pWriter->EndAttributes();
}
else
{
//sOleNodeName = L"w:pict";
//pWriter->StartNode(sOleNodeName);
//pWriter->StartAttributes();
//pWriter->EndAttributes();
}
}
int nShapeId = pWriter->m_lObjectIdVML;
std::wstring strId = L"_x0000_i" + std::to_wstring(pWriter->m_lObjectIdVML);
std::wstring strSpid = L"_x0000_s" + std::to_wstring(pWriter->m_lObjectIdVML);
std::wstring strObjectid = L"_152504" + std::to_wstring(pWriter->m_lObjectIdVML);
pWriter->m_lObjectIdVML++;
int dL = 0, dT = 0, dW = 0, dH = 0;
if (spPr.xfrm.is_init())
{
if (spPr.xfrm->offX.is_init()) dL = *spPr.xfrm->offX;
if (spPr.xfrm->offY.is_init()) dT = *spPr.xfrm->offY;
if (spPr.xfrm->extX.is_init()) dW = *spPr.xfrm->extX;
if (spPr.xfrm->extY.is_init()) dH = *spPr.xfrm->extY;
}
NSBinPptxRW::CXmlWriter oStylesWriter;
if (pWriter->m_strStyleMain.empty())
{
oStylesWriter.WriteAttributeCSS (L"position", L"absolute");
if (in_group)
{
oStylesWriter.WriteAttributeCSS_int(L"left", dL / 100);
oStylesWriter.WriteAttributeCSS_int(L"top", dT / 100);
oStylesWriter.WriteAttributeCSS_int(L"width", dW / 100);
oStylesWriter.WriteAttributeCSS_int(L"height", dH / 100);
}
else
{
oStylesWriter.WriteAttributeCSS_int_pt(L"left", dL / 12700);
oStylesWriter.WriteAttributeCSS_int_pt(L"top", dT / 12700);
oStylesWriter.WriteAttributeCSS_int_pt(L"width", dW / 12700);
oStylesWriter.WriteAttributeCSS_int_pt(L"height", dH / 12700);
}
}
if (spPr.xfrm.is_init())
{
if (spPr.xfrm->rot.is_init())
{
int nRot = (int)((double)(*(spPr.xfrm->rot)) / 60000.0);
oStylesWriter.WriteAttributeCSS_int(L"rotation", nRot);
}
bool bIsFH = spPr.xfrm->flipH.get_value_or(false);
bool bIsFV = spPr.xfrm->flipV.get_value_or(false);
if (bIsFH && bIsFV)
{
oStylesWriter.WriteAttributeCSS(L"flip", L"xy");
}
else if (bIsFH)
{
oStylesWriter.WriteAttributeCSS(L"flip", L"x");
}
else if (bIsFV)
{
oStylesWriter.WriteAttributeCSS(L"flip", L"y");
}
}
oStylesWriter.WriteAttributeCSS(L"z-index", L"1");
std::wstring strPath;
std::wstring strTextRect;
LONG lW = 43200;
LONG lH = 43200;
if (spPr.xfrm.is_init())
{
lW = spPr.xfrm->extX.get_value_or(43200);
lH = spPr.xfrm->extY.get_value_or(43200);
}
spPr.Geometry.ConvertToCustomVML(pWriter->m_pOOXToVMLRenderer, strPath, strTextRect, lW, lH);
pWriter->StartNode(L"v:shapetype");
pWriter->StartAttributes();
pWriter->WriteAttribute(L"id", L"_x0000_t75");
pWriter->WriteAttribute(L"coordsize", L"21600,21600");
pWriter->WriteAttribute(L"o:spt", L"75");
pWriter->WriteAttribute(L"o:preferrelative", L"t");
pWriter->WriteAttribute(L"path", L"m@4@5l@4@11@9@11@9@5xe");
pWriter->WriteAttribute(L"filled", L"f");
pWriter->WriteAttribute(L"stroked", L"f");
pWriter->EndAttributes();
pWriter->StartNode(L"v:stroke");
pWriter->StartAttributes();
pWriter->WriteAttribute(L"joinstyle", L"miter");
pWriter->EndAttributes();
pWriter->EndNode(L"v:stroke");
pWriter->StartNode(L"v:formulas");
pWriter->EndAttributes();
pWriter->WriteString(L"<v:f eqn=\"if lineDrawn pixelLineWidth 0\"/>\
<v:f eqn=\"sum @0 1 0\"/>\
<v:f eqn=\"sum 0 0 @1\"/>\
<v:f eqn=\"prod @2 1 2\"/>\
<v:f eqn=\"prod @3 21600 pixelWidth\"/>\
<v:f eqn=\"prod @3 21600 pixelHeight\"/>\
<v:f eqn=\"sum @0 0 1\"/>\
<v:f eqn=\"prod @6 1 2\"/>\
<v:f eqn=\"prod @7 21600 pixelWidth\"/>\
<v:f eqn=\"sum @8 21600 0\"/>\
<v:f eqn=\"prod @7 21600 pixelHeight\"/>\
<v:f eqn=\"sum @10 21600 0\"/>");
pWriter->EndNode(L"v:formulas");
pWriter->StartNode(L"v:path");
pWriter->StartAttributes();
pWriter->WriteAttribute(L"o:extrusionok", L"f");
pWriter->WriteAttribute(L"gradientshapeok", L"t");
pWriter->WriteAttribute(L"o:connecttype", L"rect");
pWriter->EndAttributes();
pWriter->EndNode(L"v:path");
pWriter->StartNode(L"o:lock");
pWriter->StartAttributes();
pWriter->WriteAttribute(L"v:ext", L"edit");
pWriter->WriteAttribute(L"aspectratio", L"t");
pWriter->EndAttributes();
pWriter->EndNode(L"o:lock");
pWriter->EndNode(L"v:shapetype");
pWriter->StartNode(L"v:shape");
pWriter->StartAttributes();
if (pWriter->m_strId.empty())
{
if (XMLWRITER_DOC_TYPE_XLSX == pWriter->m_lDocType)
{
pWriter->WriteAttribute(L"id", strSpid); //??
}
else
{
pWriter->WriteAttribute(L"id", strId);
pWriter->WriteAttribute(L"o:spid", strSpid);
}
}
else
{
pWriter->WriteAttribute(L"id", pWriter->m_strId);
pWriter->WriteAttribute(L"o:spid", strSpid);
pWriter->m_strId.clear();
}
pWriter->WriteAttribute(L"type", L"#_x0000_t75");
pWriter->WriteAttribute(L"style", pWriter->m_strStyleMain + pWriter->m_strStyleWrap + oStylesWriter.GetXmlString());
if (!pWriter->m_strAttributesMain.empty())
{
pWriter->WriteString(pWriter->m_strAttributesMain);
pWriter->m_strAttributesMain.clear();
}
if (bOle)
{
pWriter->WriteAttribute(L"filled", L"f");
}
std::wstring strNodeVal;
if (!spPr.ln.is_init())
{
pWriter->WriteAttribute(L"stroked", L"false");
}
else
{
std::wstring strPenAttr = _T("");
nullable<ShapeStyle> pShapeStyle;
CalculateLine(pWriter->m_lDocType, spPr, pShapeStyle, oTheme, oClrMap, strPenAttr, strNodeVal, bOle);
pWriter->WriteString(strPenAttr);
}
pWriter->EndAttributes();
pWriter->WriteString(pWriter->m_strNodes);
pWriter->m_strNodes.clear();
if (blipFill.blip.is_init() && blipFill.blip->embed.is_init())
{
pWriter->StartNode(L"v:imagedata");
pWriter->StartAttributes();
if (XMLWRITER_DOC_TYPE_XLSX == pWriter->m_lDocType)
{
pWriter->WriteAttribute(L"o:relid", blipFill.blip->embed->ToString());
}
else
{
pWriter->WriteAttribute(L"r:id", blipFill.blip->embed->ToString());
}
pWriter->WriteAttribute(L"o:title", L"");
if (blipFill.srcRect.IsInit())
{
if (blipFill.srcRect->t.IsInit()) pWriter->WriteAttribute(L"croptop", CorrentCropString(*blipFill.srcRect->t));
if (blipFill.srcRect->l.IsInit()) pWriter->WriteAttribute(L"cropleft", CorrentCropString(*blipFill.srcRect->l));
if (blipFill.srcRect->b.IsInit()) pWriter->WriteAttribute(L"cropbottom", CorrentCropString(*blipFill.srcRect->b));
if (blipFill.srcRect->r.IsInit()) pWriter->WriteAttribute(L"cropright", CorrentCropString(*blipFill.srcRect->r));
}
pWriter->EndAttributes();
pWriter->EndNode(L"v:imagedata");
}
pWriter->StartNode(L"o:lock");
pWriter->StartAttributes();
pWriter->WriteAttribute(L"v:ext", L"edit");
pWriter->WriteAttribute(L"rotation", L"t");
pWriter->EndAttributes();
pWriter->EndNode(L"o:lock");
if (m_sClientDataXml.IsInit())
pWriter->WriteString(*m_sClientDataXml);
pWriter->EndNode(L"v:shape");
pWriter->m_strStyleMain.clear();
pWriter->m_strStyleWrap.clear();
if (bOle)
{
oleObject->m_sObjectId = strObjectid;
if (XMLWRITER_DOC_TYPE_XLSX == pWriter->m_lDocType)
{
oleObject->m_sShapeId = std::to_wstring(nShapeId);
}
else
{
oleObject->m_sShapeId = strId;
oleObject->toXmlWriter(pWriter);
}
}
if (!sOleNodeName.empty())
{
pWriter->EndNode(sOleNodeName);
}
}
void Pic::fromXMLOle(XmlUtils::CXmlNode& node)
{
oleObject.Init();
XmlMacroReadAttributeBase(node, L"showAsIcon", oleObject->m_oShowAsIcon);
XmlMacroReadAttributeBase(node, L"progId", oleObject->m_sProgId);
XmlMacroReadAttributeBase(node, L"r:id", oleObject->m_oId);
XmlMacroReadAttributeBase(node, L"name", oleObject->m_oName);
if (false == oleObject->m_oId.IsInit())
{
XmlMacroReadAttributeBase( node, L"relationships:id", oleObject->m_oId );
}
if ((oleObject->m_oShowAsIcon.IsInit()) && (*oleObject->m_oShowAsIcon))
{
oleObject->m_oDrawAspect = (BYTE)1;
}
int imgW = node.GetAttributeInt(std::wstring(L"imgW"), 0);
if (imgW > 0)
{
oleObject->m_oDxaOrig = (int)Emu_To_Twips(imgW);
}
int imgH = node.GetAttributeInt(std::wstring(L"imgH"), 0);
if (imgH > 0)
{
oleObject->m_oDyaOrig = (int)Emu_To_Twips(imgH);
}
if (oleObject->m_oId.IsInit())
{
if (blipFill.blip.IsInit() == false)
{
blipFill.blip.Init();
blipFill.stretch.Init();
blipFill.stretch->fillRect.Init();
}
blipFill.blip->oleRid = oleObject->m_oId->get();
}
XmlMacroReadAttributeBase(node, L"spid", oleObject->m_sShapeId);
}
void Pic::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
WritingElement_ReadAttributes_Start(oReader)
WritingElement_ReadAttributes_Read_if (oReader, _T("macro"), macro)
WritingElement_ReadAttributes_End(oReader)
}
bool COLEObject::ReadOoxmlZip(NSBinPptxRW::CBinaryFileReader* pReader, const std::wstring& sDstEmbedded, BYTE* pData, long length)
{
std::wstring sTempFilename = sDstEmbedded + FILE_SEPARATOR_STR + L"Microsoft_XXX.ooxml";
NSFile::CFileBinary file;
if (false == file.CreateFileW(sTempFilename)) return false;
file.WriteFile(pData, length);
file.CloseFile();
std::wstring sTrueFilename;
COfficeFileFormatChecker fileChecker;
bool result = fileChecker.isOfficeFile(sTempFilename);
if (result)
{
int id = pReader->m_nCountEmbedded++;
switch (fileChecker.nFileType)
{
case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX: sTrueFilename = L"Microsoft_Word_Document" + std::to_wstring(id) + L".docx"; break;
case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCM: sTrueFilename = L"Microsoft_Word_Document" + std::to_wstring(id) + L".docm"; break;
case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTX: sTrueFilename = L"Microsoft_Word_Document" + std::to_wstring(id) + L".dotx"; break;
case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTM: sTrueFilename = L"Microsoft_Word_Document" + std::to_wstring(id) + L".dotm"; break;
case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX: sTrueFilename = L"Microsoft_Excel_Worksheet" + std::to_wstring(id) + L".xlsx"; break;
case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSM: sTrueFilename = L"Microsoft_Excel_Worksheet" + std::to_wstring(id) + L".xlsm"; break;
case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTX: sTrueFilename = L"Microsoft_Excel_Worksheet" + std::to_wstring(id) + L".xltx"; break;
case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTM: sTrueFilename = L"Microsoft_Excel_Worksheet" + std::to_wstring(id) + L".xltm"; break;
case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX: sTrueFilename = L"Microsoft_PowerPoint" + std::to_wstring(id) + L".pptx"; break;
case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTM: sTrueFilename = L"Microsoft_PowerPoint" + std::to_wstring(id) + L".pptm"; break;
case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX: sTrueFilename = L"Microsoft_PowerPoint" + std::to_wstring(id) + L".ppsx"; break;
case AVS_OFFICESTUDIO_FILE_PRESENTATION_POTX: sTrueFilename = L"Microsoft_PowerPoint" + std::to_wstring(id) + L".potx"; break;
case AVS_OFFICESTUDIO_FILE_PRESENTATION_POTM: sTrueFilename = L"Microsoft_PowerPoint" + std::to_wstring(id) + L".potm"; break;
case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSM: sTrueFilename = L"Microsoft_PowerPoint" + std::to_wstring(id) + L".ppsm"; break;
case AVS_OFFICESTUDIO_FILE_DRAW_VSDX: sTrueFilename = L"Microsoft_Visio_Drawing" + std::to_wstring(id) + L".vsdx"; break;
case AVS_OFFICESTUDIO_FILE_DRAW_VSDM: sTrueFilename = L"Microsoft_Visio_Drawing" + std::to_wstring(id) + L".vsdm"; break;
case AVS_OFFICESTUDIO_FILE_DRAW_VSSX: sTrueFilename = L"Microsoft_Visio_Drawing" + std::to_wstring(id) + L".vssx"; break;
case AVS_OFFICESTUDIO_FILE_DRAW_VSTX: sTrueFilename = L"Microsoft_Visio_Drawing" + std::to_wstring(id) + L".vstx"; break;
case AVS_OFFICESTUDIO_FILE_DRAW_VSSM: sTrueFilename = L"Microsoft_Visio_Drawing" + std::to_wstring(id) + L".vssm"; break;
case AVS_OFFICESTUDIO_FILE_DRAW_VSTM: sTrueFilename = L"Microsoft_Visio_Drawing" + std::to_wstring(id) + L".vstm"; break;
}
}
if (false == sTrueFilename.empty())
{
sTrueFilename = sDstEmbedded + FILE_SEPARATOR_STR + sTrueFilename;
NSFile::CFileBinary::Copy(sTempFilename, sTrueFilename);
m_OleObjectFile = new OOX::OleObject(NULL, true, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
m_OleObjectFile->set_filename(sTrueFilename, false);
size_t nFind = sTrueFilename.rfind('.');
if (std::wstring::npos != nFind)
pReader->m_pRels->m_pManager->m_pContentTypes->AddDefault(sTrueFilename.substr(nFind + 1));
}
NSFile::CFileBinary::Remove(sTempFilename);
return result;
}
bool COLEObject::ReadDocxBin(NSBinPptxRW::CBinaryFileReader* pReader, const std::wstring& sDstEmbedded, BYTE* pData, long length)
{
m_OleObjectFile = new OOX::OleObject(NULL, true, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
int id = pReader->m_nCountEmbedded++;
std::wstring sDstEmbeddedTemp = sDstEmbedded + FILE_SEPARATOR_STR + L"Temp";
NSDirectory::CreateDirectory(sDstEmbeddedTemp);
BinDocxRW::CDocxSerializer oDocxSerializer;
NSBinPptxRW::CDrawingConverter oDrawingConverter;
std::wstring sThemePath, sMediaPath, sEmbedPath;
oDocxSerializer.CreateDocxFolders(sDstEmbeddedTemp, sThemePath, sMediaPath, sEmbedPath);
oDrawingConverter.m_pReader->Init(pData, 0, length);
oDrawingConverter.SetMainDocument(&oDocxSerializer);
oDrawingConverter.SetDstPath(sDstEmbeddedTemp + FILE_SEPARATOR_STR + L"word");
oDrawingConverter.SetSrcPath(pReader->m_strFolder, XMLWRITER_DOC_TYPE_DOCX);
oDrawingConverter.SetMediaDstPath(sMediaPath);
oDrawingConverter.SetEmbedDstPath(sEmbedPath);
std::wstring sDocxFilename = L"Microsoft_Word_Document" + std::to_wstring(id) + L".docx";
NSBinPptxRW::CBinaryFileReader& oBufferedStream = *oDrawingConverter.m_pReader;
oDocxSerializer.m_pCurFileWriter = new Writers::FileWriter(sDstEmbeddedTemp, L"", false, 111, &oDrawingConverter, sThemePath);
BinDocxRW::BinaryFileReader oBinaryFileReader(pReader->m_strFolder, oBufferedStream, *oDocxSerializer.m_pCurFileWriter);
oBinaryFileReader.ReadFile();
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//themes
oDocxSerializer.m_pCurFileWriter->m_oTheme.Write(sThemePath);
OOX::CContentTypes* pContentTypes = oDrawingConverter.GetContentTypes();
//docProps
OOX::CPath pathDocProps = sDstEmbeddedTemp + FILE_SEPARATOR_STR + L"docProps";
NSDirectory::CreateDirectory(pathDocProps.GetPath());
OOX::CPath DocProps = std::wstring(L"docProps");
OOX::CApp oApp(NULL);
oApp.SetDefaults();
oApp.write(pathDocProps + FILE_SEPARATOR_STR + _T("app.xml"), DocProps, *pContentTypes);
OOX::CCore oCore(NULL);
oCore.SetDefaults();
oCore.write(pathDocProps + FILE_SEPARATOR_STR + _T("core.xml"), DocProps, *pContentTypes);
oDocxSerializer.m_pCurFileWriter->Write();
pContentTypes->Write(sDstEmbeddedTemp);
COfficeUtils oOfficeUtils(NULL);
oOfficeUtils.CompressFileOrDirectory(sDstEmbeddedTemp, sDstEmbedded + FILE_SEPARATOR_STR + sDocxFilename, true);
m_OleObjectFile->set_filename(sDstEmbedded + FILE_SEPARATOR_STR + sDocxFilename, false);
pReader->m_pRels->m_pManager->m_pContentTypes->AddDefault(L"docx");
NSDirectory::DeleteDirectory(sDstEmbeddedTemp);
return true;
}
bool COLEObject::ReadXlsxBin(NSBinPptxRW::CBinaryFileReader* pReader, const std::wstring& sDstEmbedded, BYTE* pData, long length)
{
m_OleObjectFile = new OOX::OleObject(NULL, true, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
int id = pReader->m_nCountEmbedded++; //todoooo -> countEmbeddedObjects
std::wstring sDstEmbeddedTemp = sDstEmbedded + FILE_SEPARATOR_STR + L"Temp";
NSDirectory::CreateDirectory(sDstEmbeddedTemp);
OOX::Spreadsheet::CXlsx oXlsx;
BinXlsxRW::BinaryFileReader oEmbeddedReader;
NSBinPptxRW::CDrawingConverter oDrawingConverter;
std::wstring sDrawingsPath = sDstEmbeddedTemp + FILE_SEPARATOR_STR + L"xl" + FILE_SEPARATOR_STR + L"drawings";
std::wstring sThemePath = sDstEmbeddedTemp + FILE_SEPARATOR_STR + L"xl" + FILE_SEPARATOR_STR + L"theme";
std::wstring sEmbeddingsPath = sDstEmbeddedTemp + FILE_SEPARATOR_STR + L"xl" + FILE_SEPARATOR_STR + L"embeddings";
BinXlsxRW::SaveParams oSaveParams(sDrawingsPath, sEmbeddingsPath, sThemePath, oDrawingConverter.GetContentTypes(), NULL, true);
std::wstring sXmlOptions, sMediaPath, sEmbedPath;
BinXlsxRW::CXlsxSerializer::CreateXlsxFolders(sXmlOptions, sDstEmbeddedTemp, sMediaPath, sEmbedPath);
boost::unordered_map<std::wstring, size_t> old_enum_map = oXlsx.m_mapEnumeratedGlobal;
oXlsx.m_mapEnumeratedGlobal.clear();
oDrawingConverter.m_pReader->Init(pData, 0, length);
oDrawingConverter.SetDstPath(sDstEmbeddedTemp + FILE_SEPARATOR_STR + L"xl");
oDrawingConverter.SetSrcPath(pReader->m_strFolder, XMLWRITER_DOC_TYPE_XLSX);
oDrawingConverter.SetMediaDstPath(sMediaPath);
oDrawingConverter.SetEmbedDstPath(sEmbedPath);
oEmbeddedReader.ReadMainTable(oXlsx, *oDrawingConverter.m_pReader, pReader->m_strFolder, sDstEmbeddedTemp, oSaveParams, &oDrawingConverter);
oXlsx.PrepareToWrite();
oXlsx.Write(sDstEmbeddedTemp, *oSaveParams.pContentTypes);
COfficeUtils oOfficeUtils(NULL);
std::wstring sXlsxFilename = L"Microsoft_Excel_Worksheet" + std::to_wstring(id) + (oSaveParams.bMacroEnabled ? L".xlsm" : L".xlsx");
oOfficeUtils.CompressFileOrDirectory(sDstEmbeddedTemp, sDstEmbedded + FILE_SEPARATOR_STR + sXlsxFilename, true);
oXlsx.m_mapEnumeratedGlobal = old_enum_map;
pReader->m_pRels->m_pManager->m_pContentTypes->AddDefault(oSaveParams.bMacroEnabled ? L"xlsm" : L"xlsx");
m_OleObjectFile->set_filename(sDstEmbedded + FILE_SEPARATOR_STR + sXlsxFilename, false);
NSDirectory::DeleteDirectory(sDstEmbeddedTemp);
return true;
}
bool COLEObject::ReadVsdxBin(NSBinPptxRW::CBinaryFileReader* pReader, const std::wstring& sDstEmbedded, BYTE* pData, long length)
{
m_OleObjectFile = new OOX::OleObject(NULL, true, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
int id = pReader->m_nCountEmbedded++; //todoooo -> countEmbeddedObjects
std::wstring sDstEmbeddedTemp = sDstEmbedded + FILE_SEPARATOR_STR + L"Temp";
NSDirectory::CreateDirectory(sDstEmbeddedTemp);
NSBinPptxRW::CDrawingConverter oDrawingConverter;
oDrawingConverter.m_pReader->Init(pData, 0, length);
std::wstring sXmlOptions, sMediaPath, sEmbedPath;
BinVsdxRW::CVsdxSerializer::CreateVsdxFolders(sDstEmbeddedTemp, sMediaPath, sEmbedPath);
oDrawingConverter.SetDstPath(sDstEmbeddedTemp + FILE_SEPARATOR_STR + L"visio");
oDrawingConverter.SetSrcPath(pReader->m_strFolder + FILE_SEPARATOR_STR, XMLWRITER_DOC_TYPE_VSDX);
oDrawingConverter.SetMediaDstPath(sMediaPath);
oDrawingConverter.SetEmbedDstPath(sEmbedPath);
OOX::Draw::CVsdx oVsdx;
boost::unordered_map<std::wstring, size_t> old_enum_map = oVsdx.m_mapEnumeratedGlobal;
BinVsdxRW::BinaryFileReader oEmbeddedReader;
BinVsdxRW::SaveParams oSaveParams(true);
oEmbeddedReader.ReadContent(oVsdx, *oDrawingConverter.m_pReader, pReader->m_strFolder, sDstEmbeddedTemp, oSaveParams);
OOX::CContentTypes oContentTypes;
oVsdx.Write(sDstEmbeddedTemp, oContentTypes);
COfficeUtils oOfficeUtils(NULL);
std::wstring sVsdxFilename = L"Microsoft_Visio_Drawing" + std::to_wstring(id) + (oSaveParams.bMacroEnabled ? L".vsdm" : L".vsdx");
oOfficeUtils.CompressFileOrDirectory(sDstEmbeddedTemp, sDstEmbedded + FILE_SEPARATOR_STR + sVsdxFilename, true);
oVsdx.m_mapEnumeratedGlobal = old_enum_map;
pReader->m_pRels->m_pManager->m_pContentTypes->AddDefault(oSaveParams.bMacroEnabled ? L"vsdm" : L"vsdx");
m_OleObjectFile->set_filename(sDstEmbedded + FILE_SEPARATOR_STR + sVsdxFilename, false);
NSDirectory::DeleteDirectory(sDstEmbeddedTemp);
return true;
}
} // namespace Logic
} // namespace PPTX
Reference in New Issue View Git Blame Copy Permalink