3054 lines
97 KiB
C++
3054 lines
97 KiB
C++
/*
|
|
* (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 "XlsxConverter.h"
|
|
#include "PptxConverter.h"
|
|
#include "DocxConverter.h"
|
|
|
|
#include "../../Common/utils.h"
|
|
|
|
#include "../../../OOXML/DocxFormat/VmlDrawing.h"
|
|
#include "../../../OOXML/DocxFormat/Diagram/DiagramDrawing.h"
|
|
#include "../../../OOXML/DocxFormat/Diagram/DiagramData.h"
|
|
#include "../../../OOXML/DocxFormat/Drawing/DrawingExt.h"
|
|
#include "../../../OOXML/DocxFormat/Logic/Vml.h"
|
|
#include "../../../OOXML/XlsxFormat/Chart/ChartDrawing.h"
|
|
#include "../../../OOXML/XlsxFormat/Chart/Chart.h"
|
|
#include "../../../OOXML/PPTXFormat/Slide.h"
|
|
#include "../../../OOXML/PPTXFormat/SlideMaster.h"
|
|
#include "../../../OOXML/PPTXFormat/Logic/SpTreeElem.h"
|
|
#include "../../../OOXML/PPTXFormat/Logic/GraphicFrame.h"
|
|
#include "../../../OOXML/PPTXFormat/Logic/Shape.h"
|
|
#include "../../../OOXML/PPTXFormat/Logic/Pic.h"
|
|
#include "../../../OOXML/PPTXFormat/Logic/CxnSp.h"
|
|
#include "../../../OOXML/PPTXFormat/Logic/SpTree.h"
|
|
#include "../../../OOXML/PPTXFormat/Logic/Table/Table.h"
|
|
#include "../../../OOXML/PPTXFormat/Logic/Effects/AlphaModFix.h"
|
|
#include "../../../OOXML/PPTXFormat/Logic/Effects/Duotone.h"
|
|
|
|
#include "../../../OOXML/PPTXFormat/Logic/Colors/SrgbClr.h"
|
|
#include "../../../OOXML/PPTXFormat/Logic/Colors/PrstClr.h"
|
|
#include "../../../OOXML/PPTXFormat/Logic/Colors/SchemeClr.h"
|
|
#include "../../../OOXML/PPTXFormat/Logic/TextFont.h"
|
|
|
|
#include "../../../OOXML/Common/SimpleTypes_Drawing.h"
|
|
#include "../../../OOXML/Common/SimpleTypes_Word.h"
|
|
|
|
#include "../Format/odf_conversion_context.h"
|
|
#include "../Format/odp_conversion_context.h"
|
|
#include "../Format/odf_text_context.h"
|
|
#include "../Format/odf_drawing_context.h"
|
|
#include "../Format/style_text_properties.h"
|
|
#include "../Format/style_paragraph_properties.h"
|
|
#include "../Format/style_graphic_properties.h"
|
|
#include "../Format/styles_list.h"
|
|
|
|
#define GETBITS(from, numL, numH) ((from & (((1 << (numH - numL + 1)) - 1) << numL)) >> numL)
|
|
|
|
using namespace cpdoccore;
|
|
|
|
namespace Oox2Odf
|
|
{
|
|
double Emu2Pt(int emu)
|
|
{
|
|
return (1.0 * emu / (635 * 20.0));
|
|
}
|
|
const double c_d_1_6 = 1.0 / 6.0;
|
|
const double c_d_1_3 = 1.0 / 3.0;
|
|
const double c_d_2_3 = 2.0 / 3.0;
|
|
|
|
inline double Hue2RGB(double dV1, double dV2, double dH)
|
|
{
|
|
if (dH < 0.0) dH += 1.0;
|
|
if (dH > 1.0) dH -= 1.0;
|
|
if (dH < c_d_1_6) return dV1 + (dV2 - dV1) * 6.0 * dH;
|
|
if (dH < 0.5) return dV2;
|
|
if (dH < c_d_2_3) return dV1 + (dV2 - dV1) * (c_d_2_3 - dH) * 6.0;
|
|
return dV1;
|
|
}
|
|
//----------------------------------------------------------------------------------
|
|
void OoxConverter::convert(PPTX::Logic::SpTreeElem *oox_element)
|
|
{
|
|
if (!oox_element) return;
|
|
if (!oox_element->is_init()) return;
|
|
|
|
smart_ptr<PPTX::WrapperWritingElement> elem = oox_element->GetElem();
|
|
|
|
convert (elem.GetPointer());
|
|
}
|
|
|
|
void OoxConverter::convert_font(PPTX::Theme *theme, std::wstring & font)
|
|
{
|
|
if (font == L"+mj-lt")
|
|
font = theme ? theme->themeElements.fontScheme.majorFont.latin.typeface : L"";
|
|
else if (font == L"+mn-lt")
|
|
font = theme ? theme->themeElements.fontScheme.minorFont.latin.typeface : L"";
|
|
else if (font == L"+mj-ea")
|
|
font = theme ? theme->themeElements.fontScheme.majorFont.ea.typeface : L"";
|
|
else if (font == L"+mn-ea")
|
|
font = theme ? theme->themeElements.fontScheme.minorFont.ea.typeface : L"";
|
|
else if (font == L"+mj-cs")
|
|
font = theme ? theme->themeElements.fontScheme.majorFont.cs.typeface : L"";
|
|
else if (font == L"+mn-cs")
|
|
font = theme ? theme->themeElements.fontScheme.minorFont.cs.typeface : L"";
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::GraphicFrame *oox_graphic_frame)
|
|
{
|
|
if (!oox_graphic_frame)return;
|
|
|
|
convert(oox_graphic_frame->nvGraphicFramePr.GetPointer());
|
|
convert(oox_graphic_frame->xfrm.GetPointer());
|
|
|
|
if ( oox_graphic_frame->chartRec.is_init())
|
|
{
|
|
convert(oox_graphic_frame->chartRec.GetPointer());
|
|
}
|
|
else if ( oox_graphic_frame->smartArt.is_init())
|
|
{
|
|
OoxConverter::convert(oox_graphic_frame->smartArt.GetPointer());
|
|
}
|
|
else if ( oox_graphic_frame->olePic.is_init())
|
|
{
|
|
OoxConverter::convert(oox_graphic_frame->olePic.GetPointer());
|
|
}
|
|
else if ( oox_graphic_frame->table.is_init())
|
|
{
|
|
PptxConverter *pptx_converter = dynamic_cast<PptxConverter *>(this);
|
|
if (pptx_converter)
|
|
pptx_converter->convert(oox_graphic_frame->table.GetPointer());
|
|
}
|
|
else if ( oox_graphic_frame->element.is_init())
|
|
{
|
|
OoxConverter::convert(oox_graphic_frame->element.GetElem().GetPointer());
|
|
}
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::NvGraphicFramePr *oox_framePr)
|
|
{
|
|
if (oox_framePr == NULL) return;
|
|
|
|
convert(&oox_framePr->cNvPr);
|
|
}
|
|
void OoxConverter::RGB2HSL(DWORD argb, double& dH, double& dS, double& dL)
|
|
{
|
|
unsigned char unB = (argb & 0xFF);
|
|
unsigned char unG = (argb & 0xFF00) >> 8;
|
|
unsigned char unR = (argb & 0xFF0000) >> 16;
|
|
|
|
int nmin = (std::min)(unR, (std::min)(unG, unB));
|
|
int nmax = (std::max)(unR, (std::max)(unG, unB));
|
|
int nDelta = nmax - nmin;
|
|
double dmax = (nmax + nmin) / 255.0;
|
|
double dDelta = nDelta / 255.0;
|
|
|
|
dL = dmax / 2.0;
|
|
|
|
if (0 == nDelta) //This is a gray, no chroma...
|
|
{
|
|
dH = 0.0;
|
|
dS = 0.0;
|
|
}
|
|
else //Chromatic data...
|
|
{
|
|
if (dL < 0.5) dS = dDelta / dmax;
|
|
else dS = dDelta / (2.0 - dmax);
|
|
|
|
dDelta = dDelta * 1530.0;
|
|
|
|
double dR = (nmax - unR) / dDelta;
|
|
double dG = (nmax - unG) / dDelta;
|
|
double dB = (nmax - unB) / dDelta;
|
|
|
|
if (unR == nmax) dH = dB - dG;
|
|
else if (unG == nmax) dH = c_d_1_3 + dR - dB;
|
|
else if (unB == nmax) dH = c_d_2_3 + dG - dR;
|
|
|
|
if (dH < 0.0) dH += 1.0;
|
|
if (dH > 1.0) dH -= 1.0;
|
|
}
|
|
}
|
|
|
|
DWORD OoxConverter::HSL2RGB(double dH, double dS, double dL)
|
|
{
|
|
unsigned char unR, unG, unB;
|
|
|
|
if (0 == dS)
|
|
{
|
|
unR = static_cast<unsigned char>(255 * dL);
|
|
unG = static_cast<unsigned char>(255 * dL);
|
|
unB = static_cast<unsigned char>(255 * dL);
|
|
}
|
|
else
|
|
{
|
|
double dV2;
|
|
if (dL < 0.5) dV2 = dL * (1.0 + dS);
|
|
else dV2 = dL + dS - dS * dL;
|
|
|
|
double dV1 = 2.0 * dL - dV2;
|
|
|
|
unR = static_cast<unsigned char>(255 * Hue2RGB(dV1, dV2, dH + c_d_1_3));
|
|
unG = static_cast<unsigned char>(255 * Hue2RGB(dV1, dV2, dH));
|
|
unB = static_cast<unsigned char>(255 * Hue2RGB(dV1, dV2, dH - c_d_1_3));
|
|
}
|
|
return (unR << 16) | (unG << 8) | unB;
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::Xfrm *oox_xfrm)
|
|
{
|
|
if (oox_xfrm == NULL) return; //CTransform2D
|
|
|
|
_CP_OPT(double) x, y, width, height;
|
|
|
|
if (oox_xfrm->offX.IsInit()) x = Emu2Pt(*oox_xfrm->offX);
|
|
if (oox_xfrm->offY.IsInit()) y = Emu2Pt(*oox_xfrm->offY);
|
|
|
|
if (oox_xfrm->extX.IsInit()) width = Emu2Pt(*oox_xfrm->extX);
|
|
if (oox_xfrm->extY.IsInit()) height = Emu2Pt(*oox_xfrm->extY);
|
|
|
|
odf_context()->drawing_context()->set_size( width, height);
|
|
odf_context()->drawing_context()->set_position( x, y);
|
|
|
|
if (oox_xfrm->flipH.get_value_or(false)) odf_context()->drawing_context()->set_flip_H(true);
|
|
if (oox_xfrm->flipV.get_value_or(false)) odf_context()->drawing_context()->set_flip_V(true);
|
|
|
|
if (oox_xfrm->rot.IsInit())
|
|
odf_context()->drawing_context()->set_rotate(oox_xfrm->rot.get_value_or(0)/60000.);
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::Xfrm *oox_txbx, PPTX::Logic::Xfrm *oox_xfrm)
|
|
{
|
|
if (oox_txbx == NULL) return;
|
|
if (oox_xfrm == NULL) return;
|
|
|
|
if (oox_txbx->rot.IsInit() && oox_xfrm->rot.IsInit())
|
|
{
|
|
int angle1 = *oox_txbx->rot / 60000;
|
|
int angle2 = *oox_xfrm->rot / 60000;
|
|
|
|
oox_txbx->rot = (angle1 + angle2) * 60000;
|
|
|
|
}
|
|
|
|
convert(oox_txbx);
|
|
}
|
|
std::wstring OoxConverter::GetImageIdFromVmlShape(OOX::Vml::CVmlCommonElements* pShape)
|
|
{
|
|
if (!pShape) return L"";
|
|
|
|
std::wstring sIdImageFileCache;
|
|
|
|
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);
|
|
|
|
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())
|
|
break;
|
|
}
|
|
}
|
|
return sIdImageFileCache;
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::Pic *oox_picture)
|
|
{
|
|
if (!oox_picture) return;
|
|
|
|
if (oox_picture->spPr.Geometry.is_init())
|
|
{
|
|
int type = SimpleTypes::shapetypeRect;
|
|
if ( oox_picture->spPr.Geometry.is<PPTX::Logic::CustGeom>() )
|
|
{
|
|
type = 1000;
|
|
}
|
|
else if ( oox_picture->spPr.Geometry.is<PPTX::Logic::PrstGeom>() )
|
|
{
|
|
const PPTX::Logic::PrstGeom& prstGeom = oox_picture->spPr.Geometry.as<PPTX::Logic::PrstGeom>();
|
|
|
|
SimpleTypes::CShapeType preset;
|
|
preset.FromString(prstGeom.prst.get());
|
|
type = preset.GetValue();
|
|
}
|
|
|
|
if (type != SimpleTypes::shapetypeRect)
|
|
{
|
|
odf_context()->drawing_context()->start_shape(type);
|
|
|
|
convert(&oox_picture->spPr, oox_picture->style.GetPointer());
|
|
convert(&oox_picture->nvPicPr);
|
|
|
|
odf_context()->drawing_context()->start_area_properties();
|
|
convert(&oox_picture->blipFill);
|
|
odf_context()->drawing_context()->end_area_properties();
|
|
|
|
odf_context()->drawing_context()->end_shape();
|
|
return;
|
|
}
|
|
}
|
|
//--------------------------------------------------------------------------------------
|
|
bool bExternal = false;
|
|
std::wstring pathImage;
|
|
|
|
if (oox_picture->blipFill.blip.IsInit())
|
|
{
|
|
if (oox_picture->blipFill.blip->embed.IsInit())
|
|
{
|
|
std::wstring sID = oox_picture->blipFill.blip->embed->get();
|
|
pathImage = find_link_by_id(sID, 1, bExternal);
|
|
|
|
if (false == NSFile::CFileBinary::Exists(pathImage))
|
|
{
|
|
pathImage.clear();
|
|
}
|
|
}
|
|
else if (oox_picture->blipFill.blip->link.IsInit())
|
|
{
|
|
std::wstring sID = oox_picture->blipFill.blip->link->get();
|
|
pathImage = find_link_by_id(sID, 1, bExternal);
|
|
|
|
if (pathImage.empty()) pathImage = sID;
|
|
}
|
|
}
|
|
//--------------------------------------------------------------------------------------
|
|
std::wstring odf_ref_image;
|
|
|
|
if (oox_picture->nvPicPr.nvPr.media.is_init())
|
|
{
|
|
if (oox_picture->nvPicPr.nvPr.media.is<PPTX::Logic::MediaFile>())
|
|
{
|
|
PPTX::Logic::MediaFile & media = oox_picture->nvPicPr.nvPr.media.as<PPTX::Logic::MediaFile>();
|
|
|
|
std::wstring sID = media.link.get();
|
|
std::wstring pathMedia = find_link_by_id(sID, 3, bExternal);
|
|
|
|
double start = -1, end = -1;
|
|
|
|
for (size_t i = 0; i < oox_picture->nvPicPr.nvPr.extLst.size(); i++)
|
|
{
|
|
PPTX::Logic::Ext & ext = oox_picture->nvPicPr.nvPr.extLst[i];
|
|
if (pathMedia.empty() && ext.link_media.IsInit())
|
|
{
|
|
pathMedia = find_link_by_id(ext.link_media->get(), 3, bExternal);
|
|
//например файлики mp3
|
|
}
|
|
if (ext.st.IsInit()) start = *ext.st;
|
|
if (ext.end.IsInit()) end = *ext.end;
|
|
}
|
|
|
|
std::wstring odf_ref_media = odf_context()->add_media(pathMedia, bExternal);
|
|
|
|
if (!odf_ref_media.empty())
|
|
{
|
|
odf_context()->drawing_context()->start_media(odf_ref_media);
|
|
//... params
|
|
|
|
OoxConverter::convert(&oox_picture->nvPicPr.cNvPr);
|
|
OoxConverter::convert(&oox_picture->spPr, oox_picture->style.GetPointer());
|
|
|
|
odf_ref_image = bExternal ? pathImage : odf_context()->add_image(pathImage);
|
|
odf_context()->drawing_context()->set_image_replacement(odf_ref_image);
|
|
|
|
odf_context()->drawing_context()->end_media();
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (oox_picture->oleObject.IsInit())
|
|
{
|
|
if (pathImage.empty() && oox_picture->blipFill.blip.IsInit())
|
|
{
|
|
pathImage = oox_picture->blipFill.blip->oleFilepathImage;
|
|
}
|
|
std::wstring pathOle;
|
|
|
|
if (oox_picture->oleObject->m_oId.IsInit())
|
|
{
|
|
pathOle = find_link_by_id(oox_picture->oleObject->m_oId->get(), 4, bExternal);
|
|
}
|
|
std::wstring odf_ref_ole = odf_context()->add_oleobject(pathOle, bExternal);
|
|
|
|
if (!odf_ref_ole.empty())
|
|
{
|
|
odf_context()->drawing_context()->start_object_ole(odf_ref_ole);
|
|
|
|
if (oox_picture->oleObject->m_sProgId.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->set_program(*oox_picture->oleObject->m_sProgId);
|
|
}
|
|
|
|
if (pathImage.empty() && oox_picture->oleObject->m_sShapeId.IsInit())
|
|
{
|
|
PPTX::Slide *pSlide = dynamic_cast<PPTX::Slide*>(current_document());
|
|
PPTX::SlideMaster *pSlideMaster = dynamic_cast<PPTX::SlideMaster*>(current_document());
|
|
|
|
OOX::CVmlDrawing *pVml = pSlide ? pSlide->Vml.GetPointer() : (pSlideMaster ? pSlideMaster->Vml.GetPointer() : NULL);
|
|
|
|
if (pVml)
|
|
{
|
|
std::wstring sShapeId = oox_picture->oleObject->m_sShapeId.get();
|
|
std::map<std::wstring, OOX::CVmlDrawing::_vml_shape>::iterator pFind = pVml->m_mapShapes.find(sShapeId);
|
|
|
|
if (pVml->m_mapShapes.end() != pFind)
|
|
{
|
|
OOX::Vml::CVmlCommonElements* pShape = dynamic_cast<OOX::Vml::CVmlCommonElements*>(pFind->second.pElement);
|
|
|
|
std::wstring sIdImageFileCache = GetImageIdFromVmlShape(pShape);
|
|
|
|
if (!sIdImageFileCache.empty())
|
|
{
|
|
//ищем физический файл ( rId относительно vml_drawing)
|
|
smart_ptr<OOX::File> pFile = pVml->Find(sIdImageFileCache);
|
|
|
|
if (pFile.IsInit() && (OOX::FileTypes::Image == pFile->type()))
|
|
{
|
|
smart_ptr<OOX::Image> pImageFileCache = pFile.smart_dynamic_cast<OOX::Image>();
|
|
pathImage = pImageFileCache->filename().GetPath();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
odf_ref_image = odf_context()->add_imageobject(pathImage, bExternal);
|
|
odf_context()->drawing_context()->set_image_replacement(odf_ref_image);
|
|
|
|
odf_context()->drawing_context()->end_object_ole();
|
|
return;
|
|
}
|
|
}
|
|
//--------------------------------------------------------------------------------------
|
|
odf_ref_image = bExternal ? pathImage : odf_context()->add_image(pathImage);
|
|
|
|
if (bExternal && std::wstring::npos == odf_ref_image.find(L"\\") && std::wstring::npos == odf_ref_image.find(L"/"))
|
|
{
|
|
odf_ref_image = L"../" + odf_ref_image;
|
|
}
|
|
|
|
odf_context()->drawing_context()->start_image(odf_ref_image);
|
|
{
|
|
double Width = 0, Height = 0;
|
|
_graphics_utils_::GetResolution(pathImage.c_str(), Width, Height);
|
|
//inch
|
|
Width /= 96;
|
|
Height /= 96;
|
|
|
|
if (oox_picture->blipFill.tile.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->set_image_style_repeat(2);
|
|
}
|
|
if (oox_picture->blipFill.stretch.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->set_image_style_repeat(1);
|
|
}
|
|
if (oox_picture->blipFill.srcRect.IsInit() && Width > 0 && Height >0 )
|
|
{
|
|
double l = XmlUtils::GetInteger( oox_picture->blipFill.srcRect->l.get_value_or(L"0")) /100000.;
|
|
double t = XmlUtils::GetInteger( oox_picture->blipFill.srcRect->t.get_value_or(L"0")) /100000.;
|
|
double r = XmlUtils::GetInteger( oox_picture->blipFill.srcRect->r.get_value_or(L"0")) /100000.;
|
|
double b = XmlUtils::GetInteger( oox_picture->blipFill.srcRect->b.get_value_or(L"0")) /100000.;
|
|
|
|
odf_context()->drawing_context()->set_image_client_rect_inch( l * Width, t * Height, r * Width, b * Height );
|
|
}
|
|
|
|
odf_context()->drawing_context()->start_area_properties();
|
|
if (oox_picture->blipFill.blip.IsInit())
|
|
{
|
|
for (size_t i = 0 ; i < oox_picture->blipFill.blip->Effects.size(); i++)
|
|
{
|
|
convert(oox_picture->blipFill.blip->Effects[i].Effect.GetPointer());
|
|
}
|
|
}
|
|
odf_context()->drawing_context()->end_area_properties();
|
|
|
|
OoxConverter::convert(&oox_picture->nvPicPr.cNvPr);
|
|
OoxConverter::convert(&oox_picture->spPr, oox_picture->style.GetPointer());
|
|
|
|
}
|
|
if (oox_picture->blipFill.blip.IsInit())
|
|
{
|
|
for (size_t i = 0; i < oox_picture->blipFill.blip->ExtLst.size(); ++i)
|
|
{
|
|
if (oox_picture->blipFill.blip->ExtLst[i].link_svg.IsInit())
|
|
{
|
|
std::wstring sID = oox_picture->blipFill.blip->ExtLst[i].link_svg->get();
|
|
pathImage = find_link_by_id(sID, 1, bExternal);
|
|
if (NSFile::CFileBinary::Exists(pathImage))
|
|
{
|
|
odf_ref_image = odf_context()->add_image(pathImage);
|
|
odf_context()->drawing_context()->start_image2(odf_ref_image);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
odf_context()->drawing_context()->end_image();
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::SmartArt *oox_smart_art)
|
|
{
|
|
if (oox_smart_art == NULL) return;
|
|
if (oox_smart_art->id_data.IsInit() == false) return;
|
|
|
|
oox_smart_art->LoadDrawing(current_document());
|
|
|
|
if (oox_smart_art->m_oDrawing.IsInit())
|
|
{
|
|
_CP_OPT(double) x, y, width, height, cx = 1., cy= 1.;
|
|
|
|
odf_context()->drawing_context()->get_size (width, height);
|
|
odf_context()->drawing_context()->get_position (x, y);
|
|
|
|
odf_context()->drawing_context()->start_group();
|
|
|
|
odf_context()->drawing_context()->set_group_size (width, height, width, height);
|
|
odf_context()->drawing_context()->set_group_position (x, y, cx, cy);
|
|
|
|
#if 0
|
|
odf_context()->drawing_context()->start_drawing();
|
|
odf_context()->drawing_context()->start_shape(SimpleTypes::shapetypeRect);
|
|
|
|
odf_context()->drawing_context()->set_size( width, height);
|
|
odf_context()->drawing_context()->set_position(x, y);
|
|
|
|
if (oox_smart_art->m_oDataBg.IsInit())
|
|
{
|
|
oox_current_child_document = oox_smart_art->m_pDataContainer.GetPointer();
|
|
|
|
if ((oox_smart_art->m_oDataBg->m_oFill.Fill.IsInit()) &&
|
|
(oox_smart_art->m_oDataBg->m_oFill.m_type != PPTX::Logic::UniFill::noFill))
|
|
{
|
|
odf_context()->drawing_context()->start_area_properties();
|
|
{
|
|
convert(&oox_smart_art->m_oDataBg->m_oFill);
|
|
}
|
|
odf_context()->drawing_context()->end_area_properties();
|
|
}
|
|
}
|
|
odf_context()->drawing_context()->end_shape();
|
|
odf_context()->drawing_context()->end_drawing();
|
|
#endif
|
|
|
|
oox_current_child_document = oox_smart_art->m_pDrawingContainer.GetPointer();
|
|
|
|
for (size_t i = 0; i < oox_smart_art->m_oDrawing->SpTreeElems.size(); i++)
|
|
{
|
|
odf_context()->drawing_context()->start_drawing();
|
|
convert(&oox_smart_art->m_oDrawing->SpTreeElems[i]);
|
|
odf_context()->drawing_context()->end_drawing();
|
|
}
|
|
|
|
odf_context()->drawing_context()->end_group();
|
|
oox_current_child_document = NULL;
|
|
}
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::ChartRec *oox_chart)
|
|
{
|
|
if (!oox_chart) return;
|
|
if( !oox_chart->id_data.IsInit()) return;
|
|
|
|
_CP_OPT(double) width, height, x, y, zero(0);
|
|
|
|
odf_context()->drawing_context()->get_size (width, height);
|
|
odf_context()->drawing_context()->get_position (x, y);
|
|
|
|
smart_ptr<OOX::File> oFile = find_file_by_id (oox_chart->id_data->get());
|
|
if (oFile.IsInit())
|
|
{
|
|
OOX::Spreadsheet::CChartFile* pChart = dynamic_cast<OOX::Spreadsheet::CChartFile*>(oFile.GetPointer());
|
|
OOX::Spreadsheet::CChartExFile* pChartEx = dynamic_cast<OOX::Spreadsheet::CChartExFile*>(oFile.GetPointer());
|
|
|
|
if (pChart || pChartEx)
|
|
{
|
|
oox_current_child_document = pChart ? dynamic_cast<OOX::IFileContainer*>(pChart) : dynamic_cast<OOX::IFileContainer*>(pChartEx);
|
|
|
|
OOX::CChartDrawing* pChartDrawing = NULL;
|
|
if ( (pChart) && ((pChart->m_oChartSpace.m_userShapes) && (pChart->m_oChartSpace.m_userShapes->m_id.IsInit())) )
|
|
{
|
|
oFile = find_file_by_id (*pChart->m_oChartSpace.m_userShapes->m_id);
|
|
pChartDrawing = dynamic_cast<OOX::CChartDrawing*>(oFile.GetPointer());
|
|
}
|
|
|
|
if ((pChartDrawing) && (false == pChartDrawing->m_arrItems.empty()))
|
|
{
|
|
odf_context()->drawing_context()->start_group();
|
|
|
|
odf_context()->drawing_context()->set_group_size (width, height, width, height);
|
|
odf_context()->drawing_context()->set_group_position (x, y, zero, zero);
|
|
|
|
odf_context()->drawing_context()->start_drawing();
|
|
odf_context()->drawing_context()->set_position (zero, zero);
|
|
odf_context()->drawing_context()->set_size (width, height);
|
|
}
|
|
|
|
odf_context()->drawing_context()->start_object(odf_context()->get_next_name_object());
|
|
{
|
|
odf_context()->start_chart();
|
|
odf_context()->chart_context()->set_chart_size(width, height);
|
|
|
|
if (pChart)
|
|
{
|
|
OoxConverter::convert(pChart->m_oChartSpace.m_spPr.GetPointer());
|
|
OoxConverter::convert(&pChart->m_oChartSpace);
|
|
}
|
|
else if (pChartEx)
|
|
{
|
|
OoxConverter::convert(pChartEx->m_oChartSpace.m_spPr.GetPointer());
|
|
OoxConverter::convert(&pChartEx->m_oChartSpace);
|
|
}
|
|
odf_context()->end_chart();
|
|
}
|
|
odf_context()->drawing_context()->end_object();
|
|
|
|
if ((pChartDrawing) && (false == pChartDrawing->m_arrItems.empty()))
|
|
{
|
|
odf_context()->drawing_context()->end_drawing();
|
|
|
|
oox_current_child_document = dynamic_cast<OOX::IFileContainer*>(pChartDrawing);
|
|
|
|
for (size_t i = 0; i < pChartDrawing->m_arrItems.size(); i++)
|
|
{
|
|
convert(pChartDrawing->m_arrItems[i], 0, 0, width.get_value_or(0), height.get_value_or(0));
|
|
}
|
|
odf_context()->drawing_context()->end_group();
|
|
}
|
|
oox_current_child_document = NULL;
|
|
}
|
|
}
|
|
}
|
|
void OoxConverter::convert(OOX::CSizeAnchor *sz_anchor, double x0, double y0, double width, double height)
|
|
{
|
|
if (!sz_anchor) return;
|
|
|
|
_CP_OPT(double) x, y, cx, cy;
|
|
|
|
if (sz_anchor->m_oFrom.IsInit())
|
|
{
|
|
if (sz_anchor->m_oFrom->m_oX.IsInit()) x = *sz_anchor->m_oFrom->m_oX * width + x0;
|
|
if (sz_anchor->m_oFrom->m_oY.IsInit()) y = *sz_anchor->m_oFrom->m_oY * height + y0;
|
|
}
|
|
|
|
OOX::CRelSizeAnchor *relAnchor = dynamic_cast<OOX::CRelSizeAnchor*>(sz_anchor);
|
|
OOX::CAbsSizeAnchor *absAnchor = dynamic_cast<OOX::CAbsSizeAnchor*>(sz_anchor);
|
|
|
|
if ((relAnchor) && (relAnchor->m_oTo.IsInit() && sz_anchor->m_oFrom.IsInit()))
|
|
{
|
|
if (relAnchor->m_oTo->m_oX.IsInit()) cx = (*relAnchor->m_oTo->m_oX - *sz_anchor->m_oFrom->m_oX) * width;
|
|
if (relAnchor->m_oTo->m_oY.IsInit()) cy = (*relAnchor->m_oTo->m_oY - *sz_anchor->m_oFrom->m_oY) * height;
|
|
}
|
|
if ((absAnchor) && (absAnchor->m_oExt.IsInit()))
|
|
{
|
|
if (absAnchor->m_oExt->m_oCx.IsInit()) cx = *absAnchor->m_oExt->m_oCx * width;
|
|
if (absAnchor->m_oExt->m_oCy.IsInit()) cy = *absAnchor->m_oExt->m_oCy * height;
|
|
}
|
|
|
|
odf_context()->drawing_context()->start_drawing();
|
|
|
|
odf_context()->drawing_context()->set_position (x, y);
|
|
odf_context()->drawing_context()->set_size (cx, cy);
|
|
|
|
convert(sz_anchor->m_oElement.GetPointer());
|
|
|
|
odf_context()->drawing_context()->end_drawing();
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::CNvGrpSpPr *oox_cnvGrpSpPr)
|
|
{
|
|
if (!oox_cnvGrpSpPr) return;
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::NvGrpSpPr *oox_nvGrpSpPr)
|
|
{
|
|
if (!oox_nvGrpSpPr) return;
|
|
|
|
odf_context()->drawing_context()->set_group_name(oox_nvGrpSpPr->cNvPr.name);
|
|
odf_context()->drawing_context()->set_group_z_order(oox_nvGrpSpPr->cNvPr.id);
|
|
|
|
if (oox_nvGrpSpPr->cNvPr.descr.IsInit())
|
|
odf_context()->drawing_context()->set_description(oox_nvGrpSpPr->cNvPr.descr.get());
|
|
|
|
if (oox_nvGrpSpPr->cNvPr.id != -1)
|
|
{
|
|
cpdoccore::odf_writer::odp_conversion_context* odp_context =
|
|
dynamic_cast<cpdoccore::odf_writer::odp_conversion_context*>(odf_context());
|
|
if (odp_context)
|
|
{
|
|
const std::wstring xml_id = odp_context->map_indentifier(std::to_wstring(oox_nvGrpSpPr->cNvPr.id));
|
|
odf_context()->drawing_context()->set_group_xml_id(xml_id);
|
|
}
|
|
}
|
|
|
|
convert(&oox_nvGrpSpPr->cNvGrpSpPr);
|
|
convert(&oox_nvGrpSpPr->nvPr);
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::GrpSpPr *oox_grpSpPr)
|
|
{
|
|
if (!oox_grpSpPr) return;
|
|
|
|
if (oox_grpSpPr->xfrm.IsInit())
|
|
{
|
|
if (oox_grpSpPr->xfrm->flipH.IsInit())
|
|
odf_context()->drawing_context()->set_group_flip_H(oox_grpSpPr->xfrm->flipH.get());
|
|
|
|
if (oox_grpSpPr->xfrm->flipV.IsInit())
|
|
odf_context()->drawing_context()->set_group_flip_V(oox_grpSpPr->xfrm->flipV.get());
|
|
|
|
_CP_OPT(double) cx, cy, ch_cx, ch_cy;
|
|
|
|
if (oox_grpSpPr->xfrm->extX.IsInit())
|
|
cx = oox_grpSpPr->xfrm->extX.get() / 12700.;
|
|
if (oox_grpSpPr->xfrm->extY.IsInit())
|
|
cy = oox_grpSpPr->xfrm->extY.get() / 12700.;
|
|
|
|
if (oox_grpSpPr->xfrm->chExtX.IsInit())
|
|
ch_cx = oox_grpSpPr->xfrm->chExtX.get() / 12700.;
|
|
if (oox_grpSpPr->xfrm->chExtY.IsInit())
|
|
ch_cy = oox_grpSpPr->xfrm->chExtY.get() / 12700.;
|
|
|
|
odf_context()->drawing_context()->set_group_size( cx, cy, ch_cx, ch_cy );
|
|
|
|
_CP_OPT(double) x, y, ch_x, ch_y, ext_x, ext_y;
|
|
|
|
if (oox_grpSpPr->xfrm->offX.IsInit())
|
|
x = oox_grpSpPr->xfrm->offX.get() / 12700.;
|
|
if (oox_grpSpPr->xfrm->offY.IsInit())
|
|
y = oox_grpSpPr->xfrm->offY.get() / 12700.;
|
|
|
|
if (oox_grpSpPr->xfrm->chOffX.IsInit())
|
|
ch_x = oox_grpSpPr->xfrm->chOffX.get() / 12700.;
|
|
if (oox_grpSpPr->xfrm->chOffY.IsInit())
|
|
ch_y = oox_grpSpPr->xfrm->chOffY.get() / 12700.;
|
|
|
|
size_t group_level = odf_context()->drawing_context()->get_group_level();
|
|
|
|
odf_context()->drawing_context()->get_position(ext_x, ext_y);
|
|
|
|
if (ext_x && ext_y && group_level < 2)
|
|
{
|
|
x = ext_x;
|
|
y = ext_y;
|
|
}
|
|
|
|
odf_context()->drawing_context()->set_group_position( x, y, ch_x, ch_y );
|
|
|
|
if (oox_grpSpPr->xfrm->rot.IsInit())
|
|
odf_context()->drawing_context()->set_group_rotate(oox_grpSpPr->xfrm->rot.get() / 60000.);
|
|
}
|
|
|
|
if ((oox_grpSpPr->Fill.Fill.IsInit()) && (oox_grpSpPr->Fill.m_type != PPTX::Logic::UniFill::noFill))
|
|
{
|
|
odf_context()->drawing_context()->start_area_properties();
|
|
{
|
|
convert(&oox_grpSpPr->Fill);
|
|
}
|
|
odf_context()->drawing_context()->end_area_properties();
|
|
}
|
|
|
|
convert(oox_grpSpPr->EffectList.List.GetPointer());
|
|
convert(oox_grpSpPr->scene3d.GetPointer());
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::SpTree *oox_shape_tree)
|
|
{
|
|
if (oox_shape_tree == NULL) return;
|
|
|
|
odf_context()->drawing_context()->start_group();
|
|
|
|
convert(&oox_shape_tree->nvGrpSpPr);
|
|
convert(&oox_shape_tree->grpSpPr);
|
|
|
|
//odf_context()->drawing_context()->set_group_size (width, height, width, height);
|
|
//odf_context()->drawing_context()->set_group_position (x, y, cx, cy);
|
|
|
|
for (size_t i = 0; i < oox_shape_tree->SpTreeElems.size(); i++)
|
|
{
|
|
odf_context()->drawing_context()->start_drawing();
|
|
convert(oox_shape_tree->SpTreeElems[i].GetElem().GetPointer());
|
|
odf_context()->drawing_context()->end_drawing();
|
|
}
|
|
|
|
odf_context()->drawing_context()->end_group();
|
|
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::CxnSp *oox_connect)
|
|
{
|
|
if (oox_connect == NULL) return;
|
|
|
|
int type = SimpleTypes::shapetypeLine;
|
|
|
|
if ( oox_connect->spPr.Geometry.is<PPTX::Logic::PrstGeom>() )
|
|
{
|
|
const PPTX::Logic::PrstGeom& prstGeom = oox_connect->spPr.Geometry.as<PPTX::Logic::PrstGeom>();
|
|
|
|
SimpleTypes::CShapeType preset;
|
|
preset.FromString(prstGeom.prst.get());
|
|
type = preset.GetValue();
|
|
}
|
|
odf_context()->drawing_context()->start_shape(type);
|
|
|
|
convert(&oox_connect->spPr, oox_connect->style.GetPointer());
|
|
convert(&oox_connect->nvCxnSpPr);
|
|
|
|
odf_context()->drawing_context()->end_shape();
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::Shape *oox_shape)
|
|
{
|
|
if (oox_shape == NULL) return;
|
|
|
|
if (oox_shape->txXfrm.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->start_group();
|
|
odf_context()->drawing_context()->start_drawing();
|
|
}
|
|
|
|
int type = 1000; //custom
|
|
|
|
if (oox_shape->spPr.Geometry.is_init())
|
|
{
|
|
if ( oox_shape->spPr.Geometry.is<PPTX::Logic::PrstGeom>() )
|
|
{
|
|
const PPTX::Logic::PrstGeom& prstGeom = oox_shape->spPr.Geometry.as<PPTX::Logic::PrstGeom>();
|
|
|
|
SimpleTypes::CShapeType preset;
|
|
preset.FromString(prstGeom.prst.get());
|
|
type = preset.GetValue();
|
|
}
|
|
|
|
if (type == SimpleTypes::shapetypeRect && (oox_shape->txBody.IsInit() || oox_shape->oTextBoxShape.IsInit()))
|
|
type = 2000;
|
|
|
|
if (type == 63) // ellipse
|
|
type = 1000; // custom
|
|
|
|
if (type == 2000)
|
|
{
|
|
PPTX::Logic::BodyPr *bodyPr = NULL;
|
|
if (oox_shape->txBody.IsInit()) bodyPr = oox_shape->txBody->bodyPr.GetPointer();
|
|
else bodyPr = oox_shape->oTextBoxBodyPr.GetPointer();
|
|
|
|
if ((bodyPr) && (bodyPr->prstTxWarp.IsInit()))
|
|
{
|
|
int wordart_type = convert(bodyPr->prstTxWarp.GetPointer());
|
|
if (wordart_type > 0) type = wordart_type;
|
|
}
|
|
}
|
|
}
|
|
else if (oox_shape->nvSpPr.nvPr.ph.is_init())
|
|
{
|
|
type = 2000;
|
|
}
|
|
|
|
if (type < 0)return;
|
|
//-----------------------------------------------------------------------------
|
|
odf_context()->drawing_context()->start_shape(type);
|
|
|
|
if (oox_shape->nvSpPr.nvPr.ph.is_init())
|
|
{
|
|
_CP_PTR(cpdoccore::odf_writer::paragraph_format_properties) paragraph_properties = boost::make_shared<cpdoccore::odf_writer::paragraph_format_properties>();
|
|
_CP_PTR(cpdoccore::odf_writer::text_format_properties) text_properties = boost::make_shared<cpdoccore::odf_writer::text_format_properties>();
|
|
_CP_PTR(cpdoccore::odf_writer::graphic_format_properties) graphic_properties = boost::make_shared<cpdoccore::odf_writer::graphic_format_properties>();
|
|
|
|
if(oox_shape->txBody.is_init())
|
|
convert(oox_shape->txBody->lstStyle.GetPointer(), 0, paragraph_properties.get(), text_properties.get());
|
|
|
|
if (odf_context()->drawing_context()->placeholder_replacing())
|
|
{
|
|
graphic_properties->draw_textarea_horizontal_align_ = odf_types::text_align(odf_types::text_align::Left);
|
|
graphic_properties->draw_textarea_vertical_align_ = odf_types::vertical_align(odf_types::vertical_align::Top);
|
|
}
|
|
|
|
odf_context()->drawing_context()->set_text_properties(text_properties.get());
|
|
odf_context()->drawing_context()->set_paragraph_properties(paragraph_properties.get());
|
|
odf_context()->drawing_context()->set_graphic_properties(graphic_properties.get());
|
|
|
|
if (oox_shape->txBody.IsInit())
|
|
{
|
|
odf_context()->start_text_context();
|
|
convert(oox_shape->txBody->bodyPr.GetPointer());
|
|
odf_context()->drawing_context()->set_text(odf_context()->text_context());
|
|
odf_context()->end_text_context();
|
|
}
|
|
}
|
|
|
|
convert(&oox_shape->spPr, oox_shape->style.GetPointer());
|
|
|
|
convert(&oox_shape->nvSpPr);
|
|
|
|
if (oox_shape->txXfrm.IsInit() == false)
|
|
{
|
|
if (oox_shape->oTextBoxShape.IsInit()) //docx sdt
|
|
{
|
|
DocxConverter *docx_converter = dynamic_cast<DocxConverter*>(this);
|
|
if (docx_converter)
|
|
{
|
|
odf_context()->start_text_context();
|
|
|
|
//docx_converter->convert(oox_shape->oTextBoxShape.GetPointer());
|
|
convert(oox_shape->oTextBoxBodyPr.GetPointer());
|
|
|
|
if (oox_shape->style.IsInit())
|
|
convert(&oox_shape->style->fontRef);
|
|
|
|
for (size_t i = 0; i < oox_shape->oTextBoxShape->m_arrItems.size(); i++)
|
|
{
|
|
docx_converter->convert(oox_shape->oTextBoxShape->m_arrItems[i]);
|
|
|
|
convert(oox_shape->oTextBoxBodyPr.GetPointer());
|
|
|
|
if (oox_shape->style.IsInit())
|
|
convert(&oox_shape->style->fontRef);
|
|
}
|
|
odf_context()->drawing_context()->set_text( odf_context()->text_context());
|
|
|
|
odf_context()->end_text_context();
|
|
}
|
|
}
|
|
else
|
|
convert(oox_shape->txBody.GetPointer(), oox_shape->style.GetPointer());
|
|
}
|
|
|
|
odf_context()->drawing_context()->end_shape();
|
|
|
|
if (oox_shape->txXfrm.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->end_drawing();
|
|
|
|
odf_context()->drawing_context()->start_drawing();
|
|
odf_context()->drawing_context()->start_text_box();
|
|
|
|
convert(oox_shape->txXfrm.GetPointer(), oox_shape->spPr.xfrm.GetPointer());
|
|
convert(oox_shape->txBody.GetPointer(), oox_shape->style.GetPointer());
|
|
|
|
odf_context()->drawing_context()->start_line_properties();
|
|
odf_context()->drawing_context()->set_no_fill();
|
|
odf_context()->drawing_context()->end_line_properties();
|
|
|
|
odf_context()->drawing_context()->end_shape();
|
|
odf_context()->drawing_context()->end_drawing();
|
|
|
|
odf_context()->drawing_context()->end_group();
|
|
}
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::SpPr *oox_spPr, PPTX::Logic::ShapeStyle* oox_sp_style)
|
|
{
|
|
if (oox_spPr == NULL) return;
|
|
|
|
convert(oox_spPr->xfrm.GetPointer());
|
|
|
|
PPTX::Logic::PrstGeom* prstGeom = NULL;
|
|
PPTX::Logic::CustGeom* custGeom = NULL;
|
|
|
|
if (oox_spPr->Geometry.is<PPTX::Logic::PrstGeom>())
|
|
{
|
|
prstGeom = &oox_spPr->Geometry.as<PPTX::Logic::PrstGeom>();
|
|
}
|
|
if (oox_spPr->Geometry.is<PPTX::Logic::CustGeom>())
|
|
{
|
|
custGeom = &oox_spPr->Geometry.as<PPTX::Logic::CustGeom>();
|
|
}
|
|
|
|
convert(prstGeom);
|
|
convert(custGeom);
|
|
|
|
bool bLine = odf_context()->drawing_context()->isLineShape();
|
|
|
|
if (custGeom && !custGeom->cxnLst.empty() && !odf_context()->drawing_context()->isCustomClosed())
|
|
bLine = true;
|
|
|
|
odf_context()->drawing_context()->start_area_properties();
|
|
{
|
|
if (bLine)
|
|
{
|
|
odf_context()->drawing_context()->set_no_fill();
|
|
}
|
|
else
|
|
{
|
|
if (oox_spPr->Fill.is_init())
|
|
convert(&oox_spPr->Fill);
|
|
else if (oox_sp_style)
|
|
convert(&oox_sp_style->fillRef, 1);
|
|
}
|
|
}
|
|
odf_context()->drawing_context()->end_area_properties();
|
|
|
|
odf_context()->drawing_context()->start_line_properties();
|
|
{
|
|
convert(oox_spPr->ln.GetPointer(), 0, oox_sp_style);
|
|
}
|
|
odf_context()->drawing_context()->end_line_properties();
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
PPTX::Logic::EffectLst* effectLst = dynamic_cast<PPTX::Logic::EffectLst*>(oox_spPr->EffectList.List.GetPointer());
|
|
|
|
if (effectLst) convert(effectLst);
|
|
else if (oox_sp_style) convert(&oox_sp_style->effectRef, 3);
|
|
|
|
convert(oox_spPr->scene3d.GetPointer());
|
|
convert(oox_spPr->sp3d.GetPointer());
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
}
|
|
|
|
void OoxConverter::convert(OOX::Drawing::COfficeArtExtensionList *ext_list)
|
|
{
|
|
if (ext_list == NULL)return;
|
|
|
|
for (size_t i = 0; i < ext_list->m_arrExt.size(); i++)
|
|
{
|
|
convert(ext_list->m_arrExt[i]);
|
|
}
|
|
}
|
|
|
|
void OoxConverter::convert(OOX::Drawing::COfficeArtExtension *art_ext)
|
|
{
|
|
if (art_ext == NULL)return;
|
|
|
|
if (art_ext->m_oSparklineGroups.IsInit() || art_ext->m_oAltTextTable.IsInit())
|
|
{
|
|
XlsxConverter *xlsx_converter = dynamic_cast<XlsxConverter*>(this);
|
|
if (xlsx_converter)
|
|
{
|
|
xlsx_converter->convert(art_ext->m_oSparklineGroups.GetPointer());
|
|
xlsx_converter->convert(art_ext->m_oAltTextTable.GetPointer());
|
|
}
|
|
}
|
|
convert(art_ext->m_oChartFiltering.GetPointer());
|
|
convert(art_ext->m_oChartDataLabel.GetPointer());
|
|
|
|
//convert(art_ext->m_oCompatExt.GetPointer());
|
|
//convert(art_ext->m_oDataModelExt.GetPointer());
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::UniFill *oox_fill, DWORD nARGB)
|
|
{
|
|
if (oox_fill == NULL) return;
|
|
|
|
if (oox_fill->is<PPTX::Logic::GrpFill>()) odf_context()->drawing_context()->set_group_fill();
|
|
if (oox_fill->is<PPTX::Logic::NoFill>()) odf_context()->drawing_context()->set_no_fill();
|
|
|
|
if (oox_fill->is<PPTX::Logic::BlipFill>()) convert(&oox_fill->as<PPTX::Logic::BlipFill>());
|
|
if (oox_fill->is<PPTX::Logic::GradFill>()) convert(&oox_fill->as<PPTX::Logic::GradFill>(), nARGB);
|
|
if (oox_fill->is<PPTX::Logic::SolidFill>()) convert(&oox_fill->as<PPTX::Logic::SolidFill>(),nARGB);
|
|
if (oox_fill->is<PPTX::Logic::PattFill>()) convert(&oox_fill->as<PPTX::Logic::PattFill>(), nARGB);
|
|
}
|
|
|
|
int OoxConverter::convert(PPTX::Logic::PrstTxWarp *oox_text_preset)
|
|
{
|
|
if (oox_text_preset == NULL) return -1;
|
|
|
|
if (oox_text_preset->prst.GetBYTECode() == SimpleTypes::textshapetypeTextNoShape ||
|
|
oox_text_preset->prst.GetBYTECode() == SimpleTypes::textshapetypeTextPlain) // в зависимости от других настроек
|
|
{
|
|
return 2000;
|
|
}
|
|
else
|
|
{
|
|
return 2001 + oox_text_preset->prst.GetBYTECode();
|
|
}
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::PrstGeom *oox_geom)
|
|
{
|
|
if (!oox_geom) return;
|
|
|
|
if (oox_geom->prst.get() == L"ellipse")
|
|
{
|
|
odf_context()->drawing_context()->set_viewBox(21600, 21600);
|
|
odf_context()->drawing_context()->set_path(L"U 10800 10800 10800 10800 0 360 Z N");
|
|
odf_context()->drawing_context()->set_draw_type(L"circle");
|
|
return;
|
|
}
|
|
|
|
for (size_t i = 0; i < oox_geom->avLst.size(); i++)
|
|
{
|
|
odf_context()->drawing_context()->add_modifier(oox_geom->avLst[i].fmla.get_value_or(L"0"));
|
|
}
|
|
}
|
|
|
|
static std::wstring process_gd_formula(const PPTX::Logic::Gd& gd, odf_writer::odf_drawing_context* drawing_context, size_t& last_gd_index)
|
|
{
|
|
std::vector<std::wstring> args;
|
|
boost::algorithm::split(args, gd.fmla.get_value_or(L""), boost::is_any_of("\t "), boost::token_compress_on);
|
|
|
|
std::wstring fmla = gd.fmla.get_value_or(L"");
|
|
|
|
if (args.size() >= 4 && gd.GetFormulaType(args.front()) == 0) // if formula is "('*/') - Multiply Divide Formula"
|
|
{
|
|
if (boost::algorithm::starts_with(args[3], L"gd"))
|
|
{
|
|
const std::wstring abs_name = std::wstring(L"gd") + std::to_wstring(last_gd_index + 1);
|
|
const std::wstring abs_fmla = L"abs " + args[3];
|
|
|
|
const std::wstring cmp_name = std::wstring(L"gd") + std::to_wstring(last_gd_index + 2);
|
|
const std::wstring cmp_fmla = L"?: " + abs_name + L" " + args[3] + L" 1";
|
|
|
|
last_gd_index += 2;
|
|
|
|
drawing_context->add_formula(abs_name, abs_fmla);
|
|
drawing_context->add_formula(cmp_name, cmp_fmla);
|
|
|
|
args[3] = cmp_name;
|
|
|
|
fmla = boost::algorithm::join(args, L" ");
|
|
}
|
|
}
|
|
|
|
return fmla;
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::CustGeom *oox_cust_geom)
|
|
{
|
|
if (!oox_cust_geom) return;
|
|
|
|
if (oox_cust_geom->gdLst.size())
|
|
{
|
|
size_t last_gd_index = oox_cust_geom->gdLst.size() - 1;
|
|
|
|
for (size_t i = 0; i < oox_cust_geom->gdLst.size(); i++)
|
|
{
|
|
const PPTX::Logic::Gd& gd = oox_cust_geom->gdLst[i];
|
|
|
|
const std::wstring fmla = process_gd_formula(gd, odf_context()->drawing_context(), last_gd_index);
|
|
|
|
odf_context()->drawing_context()->add_formula(gd.name.get_value_or(L""), fmla);
|
|
}
|
|
}
|
|
|
|
for (size_t i = 0; i < oox_cust_geom->pathLst.size(); i++)
|
|
{
|
|
convert(&oox_cust_geom->pathLst[i]);
|
|
}
|
|
for (size_t i = 0; i < oox_cust_geom->avLst.size(); i++)
|
|
{
|
|
odf_context()->drawing_context()->add_modifier(oox_cust_geom->avLst[i].fmla.get_value_or(L"0"));
|
|
}
|
|
for (size_t i = 0; i < oox_cust_geom->ahLst.size(); i++)
|
|
{
|
|
convert(oox_cust_geom->ahLst[i].ah.GetPointer());
|
|
}
|
|
if (oox_cust_geom->rect.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->set_textarea (oox_cust_geom->rect->l.get_value_or(L"0"),
|
|
oox_cust_geom->rect->t.get_value_or(L"0"),
|
|
oox_cust_geom->rect->r.get_value_or(L"0"),
|
|
oox_cust_geom->rect->b.get_value_or(L"0"));
|
|
}
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::AhXY *oox_handle)
|
|
{
|
|
if (!oox_handle) return;
|
|
|
|
odf_context()->drawing_context()->add_handle(oox_handle->x, oox_handle->y,
|
|
oox_handle->gdRefX.get_value_or(L""), oox_handle->gdRefY.get_value_or(L""),
|
|
oox_handle->minX.get_value_or(L""), oox_handle->maxX.get_value_or(L""),
|
|
oox_handle->minX.get_value_or(L""), oox_handle->maxY.get_value_or(L""));
|
|
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::AhPolar *oox_handle)
|
|
{
|
|
if (!oox_handle) return;
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::EffectDag *oox_effect_dag, DWORD ARGB)
|
|
{
|
|
if (!oox_effect_dag) return;
|
|
|
|
//type - sib, value
|
|
for (size_t i = 0; i < oox_effect_dag->Effects.size(); ++i)
|
|
{
|
|
convert(oox_effect_dag->Effects[i].Effect.GetPointer()/*, ARGB*/);
|
|
}
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::EffectLst *oox_effect_list, DWORD ARGB)
|
|
{
|
|
if (!oox_effect_list) return;
|
|
|
|
convert(oox_effect_list->blur.GetPointer(), ARGB);
|
|
convert(oox_effect_list->fillOverlay.GetPointer(), ARGB);
|
|
convert(oox_effect_list->glow.GetPointer(), ARGB);
|
|
convert(oox_effect_list->reflection.GetPointer(), ARGB);
|
|
convert(oox_effect_list->softEdge.GetPointer(), ARGB);
|
|
convert(oox_effect_list->innerShdw.GetPointer(), ARGB);
|
|
convert(oox_effect_list->outerShdw.GetPointer(), ARGB);
|
|
convert(oox_effect_list->prstShdw.GetPointer(), ARGB);
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::AlphaModFix *oox_alpha, DWORD ARGB)
|
|
{
|
|
if (oox_alpha == NULL) return;
|
|
if (false == oox_alpha->amt.IsInit()) return;
|
|
|
|
odf_context()->drawing_context()->set_opacity(oox_alpha->amt.get() / 1000.);
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::Blur *oox_effect, DWORD ARGB)
|
|
{
|
|
if (oox_effect == NULL) return;
|
|
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::FillOverlay *oox_effect, DWORD ARGBt)
|
|
{
|
|
if (oox_effect == NULL) return;
|
|
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::Reflection *oox_effect, DWORD ARGB)
|
|
{
|
|
if (oox_effect == NULL) return;
|
|
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::Glow *oox_effect, DWORD ARGB)
|
|
{
|
|
if (oox_effect == NULL) return;
|
|
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::SoftEdge *oox_effect, DWORD ARGB)
|
|
{
|
|
if (oox_effect == NULL) return;
|
|
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::Grayscl *oox_effect, DWORD ARGB)
|
|
{
|
|
if (oox_effect == NULL) return;
|
|
|
|
odf_context()->drawing_context()->set_grayscale();
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::Duotone *oox_effect, DWORD ARGB)
|
|
{
|
|
if (oox_effect == NULL) return;
|
|
|
|
if (oox_effect->Colors.empty()) return;
|
|
|
|
convert(&oox_effect->Colors[0], ARGB);
|
|
|
|
if (ARGB != 0)
|
|
{
|
|
double blue = GETBITS(ARGB, 0, 7) * 100. / 255.;
|
|
double green = GETBITS(ARGB, 8, 15) * 100. / 255.;
|
|
double red = GETBITS(ARGB, 16, 23) * 100. / 255.;
|
|
|
|
odf_context()->drawing_context()->set_white_balance(red, green, blue);
|
|
}
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::InnerShdw *oox_shadow, DWORD ARGB)
|
|
{
|
|
if (oox_shadow == NULL) return;
|
|
|
|
std::wstring hexColor;
|
|
_CP_OPT(double) opacity;
|
|
|
|
convert(&oox_shadow->Color, hexColor, opacity, ARGB);
|
|
|
|
double dist = oox_shadow->dist.IsInit() ? oox_shadow->dist.get() / 12700. : 0;
|
|
double dir = oox_shadow->dir.IsInit() ? oox_shadow->dir.get() / 60000. : 0;
|
|
|
|
double offset_x = dist * cos(dir * M_PI / 180);
|
|
double offset_y = dist * sin(dir * M_PI / 180);
|
|
|
|
odf_context()->drawing_context()->set_shadow(2, hexColor, opacity, offset_x, offset_y);
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::OuterShdw *oox_shadow, DWORD ARGB)
|
|
{
|
|
if (oox_shadow == NULL) return;
|
|
|
|
std::wstring hexColor;
|
|
_CP_OPT(double) opacity;
|
|
|
|
convert(&oox_shadow->Color, hexColor, opacity, ARGB);
|
|
|
|
double dist = oox_shadow->dist.IsInit() ? oox_shadow->dist.get() / 12700. : 0;
|
|
double dir = oox_shadow->dir.IsInit() ? oox_shadow->dir.get() / 60000. : 0;
|
|
|
|
double offset_x = dist * cos(dir * M_PI / 180);
|
|
double offset_y = dist * sin(dir * M_PI / 180);
|
|
|
|
odf_context()->drawing_context()->set_shadow(1, hexColor, opacity, offset_x, offset_y);
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::PrstShdw *oox_shadow, DWORD ARGB)
|
|
{
|
|
if (oox_shadow == NULL) return;
|
|
|
|
std::wstring hexColor;
|
|
_CP_OPT(double) opacity;
|
|
|
|
convert(&oox_shadow->Color, hexColor, opacity, ARGB);
|
|
|
|
//odf_context()->drawing_context()->set_shadow(1, hexColor, opacity, oox_shadow->dist.IsInit() ? oox_shadow->dist.get() / 12700. : 0);
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::EffectStyle *oox_effects, DWORD ARGB)
|
|
{
|
|
if (!oox_effects) return;
|
|
|
|
if (oox_effects->Effects.is_init())
|
|
{
|
|
if (oox_effects->Effects.is<PPTX::Logic::EffectLst>())
|
|
{
|
|
convert(dynamic_cast<PPTX::Logic::EffectLst*>(oox_effects->Effects.List.GetPointer()), ARGB);
|
|
}
|
|
else if(oox_effects->Effects.is<PPTX::Logic::EffectDag>())
|
|
{
|
|
convert(dynamic_cast<PPTX::Logic::EffectDag*>(oox_effects->Effects.List.GetPointer()), ARGB);
|
|
}
|
|
}
|
|
if (oox_effects->scene3d.IsInit())
|
|
{
|
|
}
|
|
if (oox_effects->sp3d.IsInit())
|
|
{
|
|
}
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::Path2D *oox_geom_path)
|
|
{
|
|
if (!oox_geom_path) return;
|
|
|
|
odf_context()->drawing_context()->set_viewBox(oox_geom_path->w.get_value_or(0), oox_geom_path->h.get_value_or(0));
|
|
|
|
for (size_t i = 0 ; i < oox_geom_path->Paths.size(); i++)
|
|
{
|
|
if (oox_geom_path->Paths[i].Path2D.is<PPTX::Logic::PathBase>())
|
|
convert(&oox_geom_path->Paths[i].Path2D.as<PPTX::Logic::PathBase>());
|
|
}
|
|
|
|
if (oox_geom_path->stroke.IsInit() && *oox_geom_path->stroke == false)
|
|
odf_context()->drawing_context()->add_path_element(std::wstring(L"S"), L"");
|
|
|
|
if(oox_geom_path->fill.IsInit() && oox_geom_path->fill->GetBYTECode() == 4) // fill == "none"
|
|
odf_context()->drawing_context()->add_path_element(std::wstring(L"F"), L"");
|
|
|
|
odf_context()->drawing_context()->add_path_element(std::wstring(L"N"), L"");
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::PathBase *oox_path)
|
|
{
|
|
if (!oox_path) return;
|
|
|
|
PPTX::Logic::MoveTo* moveTo = dynamic_cast<PPTX::Logic::MoveTo*> (oox_path);
|
|
PPTX::Logic::LineTo* lineTo = dynamic_cast<PPTX::Logic::LineTo*> (oox_path);
|
|
PPTX::Logic::CubicBezTo* cubicBezTo = dynamic_cast<PPTX::Logic::CubicBezTo*>(oox_path);
|
|
PPTX::Logic::Close* close = dynamic_cast<PPTX::Logic::Close*> (oox_path);
|
|
PPTX::Logic::ArcTo* arcTo = dynamic_cast<PPTX::Logic::ArcTo*> (oox_path);
|
|
PPTX::Logic::QuadBezTo* quadBezTo = dynamic_cast<PPTX::Logic::QuadBezTo*> (oox_path);
|
|
|
|
if (moveTo) convert(moveTo);
|
|
if (lineTo) convert(lineTo);
|
|
if (cubicBezTo) convert(cubicBezTo);
|
|
if (quadBezTo) convert(quadBezTo);
|
|
if (arcTo) convert(arcTo);
|
|
if (close) convert(close);
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::BlipFill *oox_bitmap_fill)
|
|
{
|
|
if (oox_bitmap_fill == NULL)return;
|
|
|
|
odf_context()->drawing_context()->start_bitmap_style();
|
|
odf_context()->drawing_context()->start_area_properties();
|
|
{
|
|
double Width=0, Height = 0;
|
|
if (oox_bitmap_fill->blip.IsInit())
|
|
{
|
|
std::wstring sID, pathImage;
|
|
|
|
bool bExternal = false;
|
|
if (oox_bitmap_fill->blip->embed.IsInit())
|
|
{
|
|
sID = oox_bitmap_fill->blip->embed->get();
|
|
pathImage = find_link_by_id(sID, 1, bExternal);
|
|
|
|
if (!pathImage.empty())
|
|
{
|
|
odf_context()->drawing_context()->set_bitmap_link(pathImage, bExternal);
|
|
_graphics_utils_::GetResolution(pathImage.c_str(), Width, Height);
|
|
|
|
Width /= 96; //to inch (current dpi file)
|
|
Height /= 96;
|
|
}
|
|
}
|
|
else if (oox_bitmap_fill->blip->link.IsInit())
|
|
{
|
|
sID = oox_bitmap_fill->blip->link->get();
|
|
|
|
pathImage = find_link_by_id(sID, 1, bExternal); //reconstruction.pptx
|
|
|
|
if (pathImage.empty())
|
|
pathImage = sID;
|
|
|
|
odf_context()->drawing_context()->set_bitmap_link(pathImage, bExternal);
|
|
}
|
|
for (size_t i = 0 ; i < oox_bitmap_fill->blip->Effects.size(); i++)
|
|
{
|
|
convert(oox_bitmap_fill->blip->Effects[i].Effect.GetPointer());
|
|
}
|
|
}
|
|
if (oox_bitmap_fill->srcRect.IsInit() && Width > 0 && Height > 0)//часть изображения
|
|
{
|
|
odf_context()->drawing_context()->set_image_client_rect_inch(
|
|
(oox_bitmap_fill->srcRect->l.IsInit() ? XmlUtils::GetInteger(oox_bitmap_fill->srcRect->l.get()) : 0 ) / 100000. * Width,
|
|
(oox_bitmap_fill->srcRect->t.IsInit() ? XmlUtils::GetInteger(oox_bitmap_fill->srcRect->t.get()) : 0 ) / 100000. * Height,
|
|
(oox_bitmap_fill->srcRect->r.IsInit() ? XmlUtils::GetInteger(oox_bitmap_fill->srcRect->r.get()) : 0 ) / 100000. * Width,
|
|
(oox_bitmap_fill->srcRect->b.IsInit() ? XmlUtils::GetInteger(oox_bitmap_fill->srcRect->b.get()) : 0 ) / 100000. * Height);
|
|
}
|
|
if (oox_bitmap_fill->tile.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->set_image_style_repeat(2);
|
|
|
|
if (oox_bitmap_fill->tile->algn.IsInit())
|
|
odf_context()->drawing_context()->set_bitmap_tile_align(oox_bitmap_fill->tile->algn->GetBYTECode());
|
|
|
|
if (oox_bitmap_fill->tile->flip.IsInit()) {}
|
|
|
|
if (oox_bitmap_fill->tile->sx.IsInit() && Width > 0)
|
|
{
|
|
odf_context()->drawing_context()->set_bitmap_tile_scale_x(*oox_bitmap_fill->tile->sx / 100000. * Width);
|
|
}
|
|
if (oox_bitmap_fill->tile->sy.IsInit()&& Height > 0)
|
|
{
|
|
odf_context()->drawing_context()->set_bitmap_tile_scale_y(*oox_bitmap_fill->tile->sy / 100000. * Height);
|
|
}
|
|
if (oox_bitmap_fill->tile->tx.IsInit() && Width > 0)
|
|
{
|
|
odf_context()->drawing_context()->set_bitmap_tile_translate_x(*oox_bitmap_fill->tile->tx * 100000. / Width );
|
|
}
|
|
if (oox_bitmap_fill->tile->ty.IsInit() && Height > 0)
|
|
{
|
|
odf_context()->drawing_context()->set_bitmap_tile_translate_y(*oox_bitmap_fill->tile->ty * 100000. / Height );
|
|
}
|
|
}
|
|
if (oox_bitmap_fill->stretch.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->set_image_style_repeat(1);
|
|
if (oox_bitmap_fill->stretch->fillRect.IsInit()){} //заполнение неполного объема
|
|
}
|
|
}
|
|
odf_context()->drawing_context()->end_area_properties();
|
|
odf_context()->drawing_context()->end_bitmap_style();
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::GradFill *oox_grad_fill, DWORD nARGB)
|
|
{
|
|
if (!oox_grad_fill) return;
|
|
|
|
odf_context()->drawing_context()->start_gradient_style();
|
|
{
|
|
odf_types::gradient_style::type grad_style = odf_types::gradient_style::linear;
|
|
|
|
if ( (oox_grad_fill->lin.IsInit()) && (oox_grad_fill->lin->ang.IsInit()))
|
|
{
|
|
odf_context()->drawing_context()->set_gradient_angle(oox_grad_fill->lin->ang.get()/60000.);
|
|
}
|
|
if ( (oox_grad_fill->path.IsInit()) && (oox_grad_fill->path->path.IsInit()))
|
|
{
|
|
grad_style = odf_types::gradient_style::linear;
|
|
switch(oox_grad_fill->path->path->GetBYTECode())
|
|
{
|
|
case SimpleTypes::pathshadetypeCircle: grad_style = odf_types::gradient_style::radial; break;
|
|
case SimpleTypes::pathshadetypeRect: grad_style = odf_types::gradient_style::rectangular; break;
|
|
case SimpleTypes::pathshadetypeShape: grad_style = odf_types::gradient_style::square; break;
|
|
}
|
|
if (oox_grad_fill->path->rect.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->set_gradient_rect( XmlUtils::GetInteger(oox_grad_fill->path->rect->l.get_value_or(L"")) / 1000.,
|
|
XmlUtils::GetInteger(oox_grad_fill->path->rect->t.get_value_or(L"")) / 1000.,
|
|
XmlUtils::GetInteger(oox_grad_fill->path->rect->r.get_value_or(L"")) / 1000.,
|
|
XmlUtils::GetInteger(oox_grad_fill->path->rect->b.get_value_or(L"")) / 1000.);
|
|
}
|
|
else if (grad_style == odf_types::gradient_style::radial)
|
|
{
|
|
odf_context()->drawing_context()->set_gradient_center(0.5, 0.5);
|
|
}
|
|
}
|
|
odf_context()->drawing_context()->set_gradient_type(grad_style);
|
|
|
|
bool bOpacity = false;
|
|
std::vector<std::wstring> hexColors;
|
|
std::vector<_CP_OPT(double)> opacities;
|
|
|
|
for (size_t i = 0; i < oox_grad_fill->GsLst.size(); ++i)
|
|
{
|
|
hexColors.emplace_back();
|
|
opacities.emplace_back();
|
|
|
|
convert(&oox_grad_fill->GsLst[i].color, hexColors.back(), opacities.back(), nARGB);
|
|
if (opacities.back())
|
|
bOpacity = true;
|
|
|
|
odf_context()->drawing_context()->set_gradient_stop(hexColors.back(), oox_grad_fill->GsLst[i].pos);
|
|
}
|
|
std::reverse(hexColors.begin(), hexColors.end());
|
|
std::reverse(opacities.begin(), opacities.end());
|
|
|
|
if (hexColors.size() > 0)
|
|
odf_context()->drawing_context()->set_gradient_start(hexColors[0], opacities[0]);
|
|
if (hexColors.size() > 1)
|
|
odf_context()->drawing_context()->set_gradient_end (hexColors[hexColors.size() - 1], opacities[opacities.size() - 1]);
|
|
|
|
odf_context()->drawing_context()->end_gradient_style();
|
|
|
|
if (bOpacity && opacities.size() > 1)
|
|
{
|
|
if (!opacities[0]) opacities[0] = 100;
|
|
if (!opacities[opacities.size() - 1]) opacities[opacities.size() - 1] = 100;
|
|
|
|
if (*opacities[0] == *opacities[opacities.size() - 1] && opacities.size() < 3)
|
|
{
|
|
odf_context()->drawing_context()->set_opacity(*opacities[0]);
|
|
}
|
|
else
|
|
{
|
|
odf_context()->drawing_context()->start_opacity_style();
|
|
odf_context()->drawing_context()->set_opacity_type(grad_style);
|
|
odf_context()->drawing_context()->set_opacity_start(*opacities[0]);
|
|
odf_context()->drawing_context()->set_opacity_end(*opacities[opacities.size() - 1]);
|
|
|
|
for (size_t i = 0; i < oox_grad_fill->GsLst.size(); ++i)
|
|
{
|
|
odf_context()->drawing_context()->set_opacity_stop(opacities[i], oox_grad_fill->GsLst[i].pos);
|
|
}
|
|
|
|
if (oox_grad_fill->lin.is_init())
|
|
{
|
|
odf_context()->drawing_context()->set_opacity_angle(oox_grad_fill->lin->ang.get() / 60000.);
|
|
}
|
|
else if (oox_grad_fill->path.is_init() && oox_grad_fill->path->rect.is_init())
|
|
{
|
|
odf_context()->drawing_context()->set_opacity_rect(XmlUtils::GetInteger(oox_grad_fill->path->rect->l.get_value_or(L"")),
|
|
XmlUtils::GetInteger(oox_grad_fill->path->rect->t.get_value_or(L"")),
|
|
XmlUtils::GetInteger(oox_grad_fill->path->rect->r.get_value_or(L"")),
|
|
XmlUtils::GetInteger(oox_grad_fill->path->rect->b.get_value_or(L"")));
|
|
}
|
|
odf_context()->drawing_context()->end_opacity_style();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::UniColor * color, DWORD & nARGB)
|
|
{
|
|
if (!color) return;
|
|
|
|
smart_ptr<PPTX::Logic::ClrMap> clrMap(oox_clrMap()); clrMap.AddRef();
|
|
smart_ptr<PPTX::Theme> theme(oox_theme()); theme.AddRef();
|
|
|
|
nARGB = color->GetRGBColor(theme, clrMap, nARGB);
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::UniColor * color, std::wstring & hexString, _CP_OPT(double) & opacity, DWORD nARGB)
|
|
{
|
|
if (!color) return;
|
|
|
|
convert(color, nARGB);
|
|
|
|
if (nARGB != 0)
|
|
{
|
|
hexString = XmlUtils::ToString((unsigned int)(nARGB & 0x00FFFFFF), L"#%06X");
|
|
|
|
if ((nARGB >> 24) != 0xff)
|
|
{
|
|
opacity = ((nARGB >> 24) /255.) * 100.;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//not found in theme
|
|
}
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::SolidFill *oox_fill, DWORD nARGB)
|
|
{
|
|
if (!oox_fill) return;
|
|
|
|
std::wstring hexString;
|
|
_CP_OPT(double) opacity;
|
|
|
|
convert(&oox_fill->Color, hexString, opacity, nARGB);
|
|
|
|
odf_context()->drawing_context()->set_solid_fill(hexString);
|
|
|
|
if (opacity)
|
|
{
|
|
odf_context()->drawing_context()->set_opacity(*opacity);
|
|
}
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::PattFill *oox_pattern_fill, DWORD nARGB)
|
|
{
|
|
if (!oox_pattern_fill) return;
|
|
|
|
odf_context()->drawing_context()->start_hatch_style();
|
|
{
|
|
if (oox_pattern_fill->prst.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->set_hatch_type(oox_pattern_fill->prst->GetBYTECode());
|
|
}
|
|
if (oox_pattern_fill->fgClr.is_init())
|
|
{
|
|
std::wstring hexColor;
|
|
_CP_OPT(double) opacity;
|
|
|
|
convert(&oox_pattern_fill->fgClr, hexColor, opacity, nARGB);
|
|
|
|
odf_context()->drawing_context()->set_hatch_line_color(hexColor);
|
|
}
|
|
if (oox_pattern_fill->bgClr.is_init())
|
|
{
|
|
std::wstring hexColor;
|
|
_CP_OPT(double) opacity;
|
|
|
|
convert(&oox_pattern_fill->bgClr, hexColor, opacity, nARGB);
|
|
|
|
odf_context()->drawing_context()->set_hatch_area_color(hexColor);
|
|
}
|
|
}
|
|
odf_context()->drawing_context()->end_hatch_style();
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::Ln *oox_line_prop, DWORD ARGB, PPTX::Logic::ShapeStyle* oox_sp_style)
|
|
{
|
|
if (oox_sp_style)
|
|
{
|
|
convert(&oox_sp_style->lnRef, 2);
|
|
}
|
|
|
|
if (!oox_line_prop) return;
|
|
|
|
if (oox_line_prop->Fill.is_init())
|
|
{
|
|
convert (&oox_line_prop->Fill, ARGB);
|
|
}
|
|
if (oox_line_prop->w.IsInit())
|
|
{
|
|
int width = oox_line_prop->w.get();
|
|
|
|
if (width == 12700 && false == oox_line_prop->Fill.is_init())
|
|
{
|
|
width = 0;
|
|
odf_context()->drawing_context()->set_no_fill();
|
|
}
|
|
|
|
odf_context()->drawing_context()->set_line_width(width / 12700.); //pt
|
|
}
|
|
if (oox_line_prop->headEnd.IsInit())
|
|
{
|
|
if (oox_line_prop->headEnd->len.IsInit() || oox_line_prop->headEnd->type.IsInit() || oox_line_prop->headEnd->w.IsInit())
|
|
{
|
|
int type = 0, w = 1, len = 1;//medium arrow
|
|
if (oox_line_prop->headEnd->len.IsInit()) len = oox_line_prop->headEnd->len->GetBYTECode();
|
|
if (oox_line_prop->headEnd->type.IsInit()) type = oox_line_prop->headEnd->type->GetBYTECode();
|
|
if (oox_line_prop->headEnd->w.IsInit()) w = oox_line_prop->headEnd->w->GetBYTECode();
|
|
|
|
odf_context()->drawing_context()->set_line_head(type, len, w);
|
|
}
|
|
}
|
|
if (oox_line_prop->tailEnd.IsInit())
|
|
{
|
|
if (oox_line_prop->tailEnd->len.IsInit() || oox_line_prop->tailEnd->type.IsInit() || oox_line_prop->tailEnd->w.IsInit())
|
|
{
|
|
int type = 1, w = 1, len = 1;//medium arrow
|
|
if (oox_line_prop->tailEnd->len.IsInit()) len = oox_line_prop->tailEnd->len->GetBYTECode();
|
|
if (oox_line_prop->tailEnd->type.IsInit()) type = oox_line_prop->tailEnd->type->GetBYTECode();
|
|
if (oox_line_prop->tailEnd->w.IsInit()) w = oox_line_prop->tailEnd->w->GetBYTECode();
|
|
|
|
odf_context()->drawing_context()->set_line_tail(type, len, w);
|
|
}
|
|
}
|
|
|
|
//if (oox_line_prop->custDash.IsInit())
|
|
//{
|
|
// //через задание стиля и описание геометрии
|
|
//}
|
|
if (oox_line_prop->prstDash.IsInit() && oox_line_prop->prstDash->val.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->set_line_dash_preset(oox_line_prop->prstDash->val->GetBYTECode());
|
|
}
|
|
//nullable<SimpleTypes::CPenAlignment<>> m_oAlgn;
|
|
//nullable<SimpleTypes::CLineCap<>> m_oCap;
|
|
//nullable<SimpleTypes::CCompoundLine<>> m_oCmpd;
|
|
|
|
|
|
//ELineJoinType m_eJoinType; // Тип соединения линий
|
|
//nullable<OOX::Drawing::CLineJoinBevel> m_oBevel;
|
|
//nullable<OOX::Drawing::CLineJoinMiterProperties> m_oMiter;
|
|
//nullable<OOX::Drawing::CLineJoinRound> m_oRound;
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::BodyPr *oox_bodyPr)
|
|
{
|
|
if (!oox_bodyPr) return;
|
|
|
|
if ((oox_bodyPr->fromWordArt.IsInit() && (*oox_bodyPr->fromWordArt)) && oox_bodyPr->prstTxWarp.IsInit())
|
|
{
|
|
for (size_t i = 0; i < oox_bodyPr->prstTxWarp->avLst.size(); i++)
|
|
{
|
|
if (oox_bodyPr->prstTxWarp->avLst[i].fmla.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->add_modifier(oox_bodyPr->prstTxWarp->avLst[i].fmla.get());
|
|
}
|
|
}
|
|
}
|
|
if (oox_bodyPr->vert.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->set_textarea_writing_mode (oox_bodyPr->vert->GetBYTECode());
|
|
}
|
|
if (oox_bodyPr->anchor.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->set_textarea_vertical_align (oox_bodyPr->anchor->GetBYTECode());
|
|
}
|
|
|
|
_CP_OPT(double) lIns, tIns, rIns, bIns;
|
|
|
|
if (oox_bodyPr->lIns.IsInit()) lIns = oox_bodyPr->lIns.get() / 12700.; //pt
|
|
if (oox_bodyPr->tIns.IsInit()) tIns = oox_bodyPr->tIns.get() / 12700.;
|
|
if (oox_bodyPr->rIns.IsInit()) rIns = oox_bodyPr->rIns.get() / 12700.;
|
|
if (oox_bodyPr->bIns.IsInit()) bIns = oox_bodyPr->bIns.get() / 12700.;
|
|
|
|
odf_context()->drawing_context()->set_textarea_padding (lIns, tIns, rIns, bIns);
|
|
|
|
if (oox_bodyPr->wrap.IsInit())
|
|
odf_context()->drawing_context()->set_textarea_wrap(oox_bodyPr->wrap->GetBYTECode());
|
|
|
|
if ((oox_bodyPr->numCol.IsInit()) && (oox_bodyPr->numCol.get() > 1))
|
|
{
|
|
int cols = oox_bodyPr->numCol.get();
|
|
int gap_cms = oox_bodyPr->spcCol.IsInit() ? oox_bodyPr->spcCol.get() / 360000 : 0;
|
|
|
|
odf_context()->drawing_context()->start_style_columns(cols, gap_cms);
|
|
odf_context()->drawing_context()->end_style_columns();
|
|
}
|
|
if (oox_bodyPr->rot.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->set_textarea_rotation(oox_bodyPr->rot.get() / 60000);
|
|
}
|
|
|
|
switch(oox_bodyPr->Fit.type)
|
|
{
|
|
case PPTX::Logic::TextFit::FitSpAuto:
|
|
{//изменяемы размеры шейпа под текст
|
|
odf_context()->drawing_context()->set_text_box_min_size(true);//уже выставленые в min
|
|
}break;
|
|
case PPTX::Logic::TextFit::FitNo:
|
|
{
|
|
}break;
|
|
case PPTX::Logic::TextFit::FitNormAuto:
|
|
{
|
|
}break;
|
|
default:
|
|
{
|
|
}
|
|
}
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::NvSpPr *oox_nvSpPr)
|
|
{
|
|
if (!oox_nvSpPr) return;
|
|
|
|
convert (&oox_nvSpPr->cNvPr);
|
|
convert (&oox_nvSpPr->cNvSpPr);
|
|
convert (&oox_nvSpPr->nvPr);
|
|
}
|
|
|
|
static bool is_sound_hlink(const std::wstring& hlink)
|
|
{
|
|
const std::wstring ext = NSFile::GetFileExtention(hlink);
|
|
if (ext == L"wav" ||
|
|
ext == L"wma" ||
|
|
ext == L"mp3" ||
|
|
ext == L"ogg")
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
static bool is_relative_path(const std::wstring& path)
|
|
{
|
|
if (path.size() <= 0)
|
|
return false;
|
|
|
|
if (path.find(L"://") != std::wstring::npos)
|
|
return false;
|
|
|
|
if (path[0] == '/')
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::CNvPr *oox_cnvPr)
|
|
{
|
|
if (!oox_cnvPr) return;
|
|
|
|
odf_context()->drawing_context()->set_name(oox_cnvPr->name);
|
|
|
|
if (oox_cnvPr->id != -1)
|
|
{
|
|
cpdoccore::odf_writer::odp_conversion_context* odp_context =
|
|
dynamic_cast<cpdoccore::odf_writer::odp_conversion_context*>(odf_context());
|
|
if (odp_context)
|
|
{
|
|
const std::wstring xml_id = odp_context->map_indentifier(std::to_wstring(oox_cnvPr->id));
|
|
odf_context()->drawing_context()->set_xml_id(xml_id);
|
|
}
|
|
}
|
|
|
|
if (oox_cnvPr->descr.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->set_description(oox_cnvPr->descr.get());
|
|
}
|
|
if (oox_cnvPr->hidden.IsInit())
|
|
{
|
|
odf_context()->drawing_context()->set_hidden(oox_cnvPr->hidden.get());
|
|
}
|
|
if (oox_cnvPr->hlinkClick.IsInit())
|
|
{
|
|
convert(oox_cnvPr->hlinkClick.GetPointer());
|
|
}
|
|
//nullable_string title;
|
|
//nullable<Hyperlink> hlinkHover;
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::CNvSpPr *oox_cnvSpPr)
|
|
{
|
|
if (!oox_cnvSpPr) return;
|
|
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::CNvCxnSpPr *oox_cnvSpPr)
|
|
{
|
|
if (!oox_cnvSpPr) return;
|
|
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::NvCxnSpPr *oox_nvSpPr)
|
|
{
|
|
if (!oox_nvSpPr) return;
|
|
|
|
convert(&oox_nvSpPr->cNvPr);
|
|
convert(&oox_nvSpPr->cNvCxnSpPr);
|
|
convert(&oox_nvSpPr->nvPr);
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::NvPr *oox_nvPr)
|
|
{
|
|
if (!oox_nvPr) return;
|
|
|
|
|
|
|
|
//ph уровнем выше
|
|
|
|
}
|
|
|
|
void OoxConverter::convert_list_level(PPTX::Logic::TextParagraphPr *oox_para_props, int level)
|
|
{//одномерные списки тока
|
|
//if (!oox_list)return;
|
|
|
|
if (!oox_para_props) return;
|
|
|
|
PPTX::Theme *theme = oox_theme();
|
|
|
|
PPTX::Logic::Bullet & bullet = oox_para_props->ParagraphBullet;
|
|
|
|
if (bullet.is<PPTX::Logic::BuNone>())return;
|
|
|
|
int odf_list_type = 13; // 1, 2, 3 ...
|
|
|
|
if (bullet.is<PPTX::Logic::BuAutoNum>())
|
|
{
|
|
const PPTX::Logic::BuAutoNum & buAutoNum = bullet.as<PPTX::Logic::BuAutoNum>();
|
|
int pptx_type = buAutoNum.type.GetBYTECode();
|
|
|
|
if ( pptx_type < 3) odf_list_type = 46;
|
|
if (pptx_type > 2 && pptx_type < 6) odf_list_type = 60;
|
|
if (pptx_type > 28 && pptx_type < 32) odf_list_type = 47;
|
|
if (pptx_type > 31 && pptx_type < 35) odf_list_type = 61;
|
|
|
|
odf_context()->styles_context()->lists_styles().start_style_level(level, odf_list_type);
|
|
|
|
if (buAutoNum.startAt.IsInit())
|
|
{
|
|
int start_value = *buAutoNum.startAt;
|
|
if (start_value > 1)
|
|
odf_context()->styles_context()->lists_styles().set_start_number(start_value);
|
|
}
|
|
}
|
|
if (bullet.is<PPTX::Logic::BuChar>())
|
|
{
|
|
odf_list_type = 5;
|
|
|
|
const PPTX::Logic::BuChar & buChar = bullet.as<PPTX::Logic::BuChar>();
|
|
odf_context()->styles_context()->lists_styles().start_style_level(level, odf_list_type);
|
|
|
|
odf_context()->styles_context()->lists_styles().set_bullet_char(buChar.Char);
|
|
}
|
|
if (bullet.is<PPTX::Logic::BuBlip>())
|
|
{
|
|
const PPTX::Logic::BuBlip & buBlip = bullet.as<PPTX::Logic::BuBlip>();
|
|
|
|
std::wstring odf_ref;
|
|
bool bExternal = false;
|
|
|
|
if (buBlip.blip.embed.IsInit())
|
|
{
|
|
std::wstring sID = buBlip.blip.embed->get();
|
|
|
|
std::wstring pathImage = find_link_by_id(sID, 1, bExternal);
|
|
|
|
if (pathImage.empty())
|
|
pathImage = buBlip.blip.GetFullPicName(); // only for presentation merge shapes !!
|
|
|
|
odf_ref = odf_context()->add_image(pathImage, bExternal);
|
|
}
|
|
else if (buBlip.blip.link.IsInit())
|
|
{
|
|
odf_ref = buBlip.blip.link->get();
|
|
bExternal = true;
|
|
}
|
|
|
|
if (!odf_ref.empty())
|
|
{
|
|
odf_list_type = 1000;
|
|
odf_context()->styles_context()->lists_styles().start_style_level(level, odf_list_type );
|
|
odf_context()->styles_context()->lists_styles().set_bullet_image(odf_ref);
|
|
}
|
|
else
|
|
{
|
|
odf_list_type = 5;
|
|
odf_context()->styles_context()->lists_styles().start_style_level(level, odf_list_type );
|
|
odf_context()->styles_context()->lists_styles().set_bullet_char(L"\x2022");
|
|
}
|
|
}
|
|
|
|
//odf_writer::style_list_level_label_alignment * aligment_props = odf_context()->styles_context()->lists_styles().get_list_level_alignment_properties();
|
|
odf_writer::style_list_level_properties* level_props = odf_context()->styles_context()->lists_styles().get_list_level_properties();
|
|
odf_writer::text_format_properties* text_properties = odf_context()->styles_context()->lists_styles().get_text_properties();
|
|
|
|
convert(oox_para_props->defRPr.GetPointer(), text_properties);
|
|
|
|
if (oox_para_props->indent.IsInit() && level_props)
|
|
{
|
|
level_props->text_min_label_width_ = odf_types::length(- oox_para_props->indent.get() / 12700., odf_types::length::pt);
|
|
level_props->text_space_before_ = odf_types::length(1, odf_types::length::pt);
|
|
|
|
}else
|
|
{
|
|
//aligment_props->fo_text_indent_ = odf_types::length(0, odf_types::length::cm);
|
|
//aligment_props->fo_margin_left_ = odf_types::length(0, odf_types::length::cm);
|
|
}
|
|
|
|
if (oox_para_props->buColor.is<PPTX::Logic::BuClrTx>())
|
|
{
|
|
const PPTX::Logic::BuClrTx & buClrTx = oox_para_props->buColor.as<PPTX::Logic::BuClrTx>();
|
|
}
|
|
if (oox_para_props->buColor.is<PPTX::Logic::BuClr>())
|
|
{
|
|
PPTX::Logic::BuClr & buClr = oox_para_props->buColor.as<PPTX::Logic::BuClr>();
|
|
|
|
std::wstring hexColor;
|
|
_CP_OPT(double) opacity;
|
|
|
|
convert(&buClr.Color, hexColor, opacity);
|
|
if (!hexColor.empty())
|
|
{
|
|
if (std::wstring::npos == hexColor.find(L"#"))
|
|
hexColor = std::wstring(L"#") + hexColor;
|
|
if (text_properties) text_properties->fo_color_ = odf_types::color(hexColor);
|
|
}
|
|
}
|
|
//-----------------------------------
|
|
if (oox_para_props->buSize.is<PPTX::Logic::BuSzPts>())
|
|
{
|
|
const PPTX::Logic::BuSzPts & buSzPts = oox_para_props->buSize.as<PPTX::Logic::BuSzPts>();
|
|
if (buSzPts.val.IsInit())
|
|
{
|
|
if (text_properties)
|
|
text_properties->fo_font_size_ = odf_types::length(*buSzPts.val, odf_types::length::pt);
|
|
else if (odf_list_type == 1000)
|
|
odf_context()->styles_context()->lists_styles().set_bullet_image_size(*buSzPts.val);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double size_pt = oox_para_props->defRPr.IsInit() ? (oox_para_props->defRPr->sz.IsInit() ? *oox_para_props->defRPr->sz /100. : 0) : 0;
|
|
|
|
if (size_pt < 0.001 && odf_list_type == 1000)
|
|
{
|
|
odf_writer::odf_style_state_ptr state = odf_context()->styles_context()->last_state(odf_types::style_family::Paragraph);
|
|
odf_writer::text_format_properties *text_props = state ? state->get_text_properties() : NULL;
|
|
|
|
if (text_props && text_props->fo_font_size_)
|
|
{
|
|
size_pt = text_props->fo_font_size_->get_length().get_value_unit(odf_types::length::pt);
|
|
}
|
|
if (size_pt < 0.001)
|
|
{
|
|
odf_writer::odf_style_state_ptr style_state;
|
|
odf_context()->styles_context()->find_odf_default_style_state(odf_types::style_family::Text, style_state);
|
|
if (style_state)
|
|
text_props = style_state->get_text_properties();
|
|
|
|
if (text_props && text_props->fo_font_size_)
|
|
{
|
|
size_pt = text_props->fo_font_size_->get_length().get_value_unit(odf_types::length::pt);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (oox_para_props->buSize.is<PPTX::Logic::BuSzTx>())
|
|
{
|
|
//equal tet size
|
|
}
|
|
|
|
if (oox_para_props->buSize.is<PPTX::Logic::BuSzPct>())
|
|
{
|
|
const PPTX::Logic::BuSzPct & buSzPct = oox_para_props->buSize.as<PPTX::Logic::BuSzPct>();
|
|
if (buSzPct.val.IsInit())
|
|
{
|
|
if (text_properties)
|
|
text_properties->fo_font_size_ = odf_types::percent(*buSzPct.val / 1000.);
|
|
|
|
size_pt *= *buSzPct.val / 100000.;
|
|
}
|
|
}
|
|
if (text_properties && !text_properties->fo_font_size_)
|
|
text_properties->fo_font_size_ = odf_types::percent(100.);
|
|
else if (odf_list_type == 1000)
|
|
{
|
|
odf_context()->styles_context()->lists_styles().set_bullet_image_size(size_pt);
|
|
}
|
|
}
|
|
//----------------
|
|
if (oox_para_props->buTypeface.is<PPTX::Logic::BuFontTx>())
|
|
{
|
|
const PPTX::Logic::BuFontTx & buFontTx = oox_para_props->buTypeface.as<PPTX::Logic::BuFontTx>();
|
|
}
|
|
if (oox_para_props->buTypeface.is<PPTX::Logic::TextFont>())
|
|
{
|
|
const PPTX::Logic::TextFont & textFont = oox_para_props->buTypeface.as<PPTX::Logic::TextFont>();
|
|
|
|
std::wstring font = textFont.typeface;
|
|
convert_font(theme, font);
|
|
if (!font.empty() && text_properties)
|
|
text_properties->fo_font_family_ = font;
|
|
}
|
|
|
|
odf_context()->styles_context()->lists_styles().end_style_level();
|
|
}
|
|
|
|
static bool is_empty_run_elems(const std::vector<PPTX::Logic::RunElem>& runElems)
|
|
{
|
|
using namespace PPTX::Logic;
|
|
|
|
auto runIt = std::find_if_not(runElems.begin(), runElems.end(),
|
|
[](const RunElem& r) {
|
|
return !r.is<Run>();
|
|
});
|
|
if (runIt != runElems.end())
|
|
{
|
|
const Run& run = runIt->as<Run>();
|
|
if (!run.HasText())
|
|
return true;
|
|
}
|
|
else
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::Paragraph *oox_paragraph, PPTX::Logic::TextListStyle *oox_list_style)
|
|
{
|
|
if (!oox_paragraph)return;
|
|
|
|
bool styled = false;
|
|
|
|
bool list_local = false;
|
|
bool list_present = false;
|
|
std::wstring list_style_name;
|
|
|
|
int list_level = 0;//-1;
|
|
|
|
NSCommon::nullable<PPTX::Logic::TextParagraphPr> paraPr;
|
|
|
|
if (oox_paragraph->pPr.IsInit())
|
|
{
|
|
if (oox_paragraph->pPr->lvl.IsInit())
|
|
list_level = *oox_paragraph->pPr->lvl;
|
|
if (oox_paragraph->pPr->ParagraphBullet.is_init())
|
|
list_local = true;
|
|
}
|
|
|
|
if (oox_list_style)
|
|
{
|
|
int i = (list_level >= 0 && list_level < 10) ? list_level : 0;
|
|
|
|
if (oox_list_style->levels[i].IsInit())
|
|
oox_list_style->levels[i]->Merge(paraPr);
|
|
}
|
|
if (oox_paragraph->pPr.IsInit())
|
|
oox_paragraph->pPr->Merge(paraPr);
|
|
|
|
if (paraPr.IsInit())
|
|
{
|
|
list_level = paraPr->lvl.IsInit() ? *paraPr->lvl : 0;
|
|
|
|
if (list_level > 0) list_present = true;
|
|
if (paraPr->ParagraphBullet.is_init())
|
|
{
|
|
list_present = true;
|
|
if (paraPr->ParagraphBullet.is<PPTX::Logic::BuNone>())
|
|
list_present = false;
|
|
}
|
|
else
|
|
list_present = false;
|
|
//свойства могут быть приписаны не только к параграфу, но и к самому объекту
|
|
odf_writer::paragraph_format_properties* paragraph_properties = odf_context()->text_context()->get_paragraph_properties();
|
|
odf_writer::text_format_properties* text_properties = odf_context()->text_context()->get_text_properties();
|
|
|
|
if (!paragraph_properties)
|
|
{
|
|
odf_context()->text_context()->get_styles_context()->create_style(L"", odf_types::style_family::Paragraph, true, false, -1);
|
|
|
|
paragraph_properties = odf_context()->text_context()->get_styles_context()->last_state()->get_paragraph_properties();
|
|
text_properties = odf_context()->text_context()->get_styles_context()->last_state()->get_text_properties();
|
|
|
|
styled = true;
|
|
}
|
|
convert(paraPr.GetPointer(), paragraph_properties, text_properties);
|
|
|
|
if (odf_context()->drawing_context()->is_wordart())
|
|
odf_context()->drawing_context()->set_paragraph_properties(paragraph_properties);
|
|
|
|
if (styled && odf_context()->drawing_context()->is_placeholder())
|
|
{
|
|
odf_writer::odf_style_state_ptr state = odf_context()->text_context()->get_styles_context()->last_state(odf_types::style_family::Paragraph);
|
|
odf_context()->drawing_context()->set_placeholder_style(state->get_name());
|
|
}
|
|
}
|
|
|
|
if (is_empty_run_elems(oox_paragraph->RunElems))
|
|
list_present = false;
|
|
|
|
//if (oox_paragraph->RunElems.empty() && list_present) list_present = false; // ms не обозначает присутствие списка, libra - показывает значек
|
|
|
|
while ((int)odf_context()->text_context()->list_state_.levels.size() > list_level)
|
|
{
|
|
odf_context()->text_context()->end_list();
|
|
}
|
|
|
|
if(list_present)
|
|
{
|
|
if (odf_context()->text_context()->list_state_.levels.empty())
|
|
{
|
|
odf_context()->text_context()->list_state_.started_list = false;
|
|
odf_context()->text_context()->list_state_.style_name = L"";
|
|
}
|
|
|
|
if (list_local)
|
|
{
|
|
_CP_OPT(int) inStyles = odf_context()->drawing_context()->get_presentation();
|
|
|
|
odf_context()->styles_context()->lists_styles().start_style(inStyles && *inStyles > 0);
|
|
convert_list_level(oox_paragraph->pPr.GetPointer(), list_level /*- 1*/);
|
|
odf_context()->styles_context()->lists_styles().end_style();
|
|
|
|
}
|
|
list_style_name = odf_context()->styles_context()->lists_styles().get_style_name(); //last added
|
|
|
|
list_level++;
|
|
|
|
if ((int)odf_context()->text_context()->list_state_.levels.size() < list_level)
|
|
{
|
|
while ((int)odf_context()->text_context()->list_state_.levels.size() < list_level)
|
|
{
|
|
if (false == odf_context()->text_context()->start_list(list_style_name))
|
|
{
|
|
break;
|
|
}
|
|
odf_context()->text_context()->start_list_item();
|
|
|
|
if (odf_context()->text_context()->list_state_.style_name == list_style_name)
|
|
list_style_name = L"";
|
|
}
|
|
}
|
|
else
|
|
odf_context()->text_context()->start_list_item();
|
|
}
|
|
else if (odf_context()->text_context()->list_state_.started_list == true)
|
|
{
|
|
odf_context()->text_context()->end_list();
|
|
}
|
|
odf_context()->text_context()->start_paragraph(styled);
|
|
|
|
if (oox_paragraph->RunElems.size() > 0)
|
|
{
|
|
for (size_t i = 0; i < oox_paragraph->RunElems.size(); i++)
|
|
{
|
|
convert(&oox_paragraph->RunElems[i].as<OOX::WritingElement>());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool styled = oox_paragraph->endParaRPr.IsInit() && oox_paragraph->endParaRPr->sz.IsInit();
|
|
|
|
odf_context()->text_context()->start_span(styled);
|
|
odf_context()->text_context()->end_span();
|
|
}
|
|
|
|
odf_context()->text_context()->end_paragraph();
|
|
|
|
//if(list_present)
|
|
//{
|
|
// odf_context()->text_context()->end_list_item();
|
|
//}
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::TextListStyle *oox_list_style, int level, odf_writer::paragraph_format_properties * paragraph_properties
|
|
, odf_writer::text_format_properties * text_properties)
|
|
{
|
|
if (!oox_list_style) return;
|
|
if (!paragraph_properties) return;
|
|
|
|
convert(oox_list_style->levels[9].GetPointer(), paragraph_properties, text_properties);
|
|
if (level < 0 || level > 9) return;
|
|
|
|
convert(oox_list_style->levels[level].GetPointer(), paragraph_properties, text_properties);
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::TextParagraphPr *oox_paragraph_pr , odf_writer::paragraph_format_properties * paragraph_properties
|
|
, odf_writer::text_format_properties * text_properties)
|
|
{
|
|
if (!oox_paragraph_pr) return;
|
|
|
|
if (paragraph_properties)
|
|
{
|
|
if (oox_paragraph_pr->lnSpc.IsInit())
|
|
{
|
|
odf_types::length_or_percent length;
|
|
convert(oox_paragraph_pr->lnSpc.GetPointer(), length);
|
|
paragraph_properties->fo_line_height_ = odf_types::line_width(length);
|
|
}
|
|
if (oox_paragraph_pr->spcAft.IsInit())
|
|
{
|
|
odf_types::length_or_percent length;
|
|
convert(oox_paragraph_pr->spcAft.GetPointer(), length);
|
|
paragraph_properties->fo_margin_bottom_ = length;
|
|
}
|
|
if (oox_paragraph_pr->spcBef.IsInit())
|
|
{
|
|
odf_types::length_or_percent length;
|
|
convert(oox_paragraph_pr->spcBef.GetPointer(), length);
|
|
paragraph_properties->fo_margin_top_ = length;
|
|
}
|
|
if (oox_paragraph_pr->algn.IsInit())
|
|
{
|
|
switch(oox_paragraph_pr->algn->GetBYTECode())
|
|
{
|
|
case 0 : paragraph_properties->fo_text_align_ = odf_types::text_align(odf_types::text_align::Center); break;
|
|
case 1 :
|
|
case 2 :
|
|
case 3 : paragraph_properties->fo_text_align_ = odf_types::text_align(odf_types::text_align::Justify); break;
|
|
case 5 : paragraph_properties->fo_text_align_ = odf_types::text_align(odf_types::text_align::Right); break;
|
|
case 4 :
|
|
default:
|
|
paragraph_properties->fo_text_align_ = odf_types::text_align(odf_types::text_align::Left); break;
|
|
}
|
|
}
|
|
if (oox_paragraph_pr->marL.IsInit())
|
|
{
|
|
paragraph_properties->fo_margin_left_ = odf_types::length_or_percent(odf_types::length(oox_paragraph_pr->marL.get() / 12700., odf_types::length::pt));
|
|
}
|
|
if (oox_paragraph_pr->marR.IsInit())
|
|
{
|
|
paragraph_properties->fo_margin_right_ = odf_types::length_or_percent(odf_types::length(oox_paragraph_pr->marR.get() / 12700., odf_types::length::pt));
|
|
}
|
|
if (oox_paragraph_pr->indent.IsInit())
|
|
{
|
|
paragraph_properties->fo_text_indent_ = odf_types::length_or_percent(odf_types::length(oox_paragraph_pr->indent.get() / 12700., odf_types::length::pt));
|
|
}
|
|
if (oox_paragraph_pr->rtl.IsInit() && *oox_paragraph_pr->rtl)
|
|
{
|
|
paragraph_properties->style_writing_mode_= odf_types::writing_mode(odf_types::writing_mode::RlTb);
|
|
}
|
|
}
|
|
//defTabSz;
|
|
//fontAlgn;
|
|
|
|
if (oox_paragraph_pr->defRPr.IsInit())
|
|
{
|
|
convert(oox_paragraph_pr->defRPr.GetPointer(), text_properties);
|
|
|
|
//надо подумать как брать последний по family !!!
|
|
//convert(oox_paragraph_pr->m_oDefRunProperty.GetPointer());
|
|
//odf_context()->text_context()->set_parent_span_style(odf_context()->styles_context()->last_state().get_name());
|
|
}
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::TextSpacing *oox_spacing, cpdoccore::odf_types::length_or_percent & length_or_percent)
|
|
{
|
|
if (!oox_spacing) return;
|
|
|
|
if ( oox_spacing->spcPct.IsInit() )
|
|
{
|
|
odf_types::percent percent = odf_types::percent(oox_spacing->GetVal());
|
|
length_or_percent = odf_types::length_or_percent(percent);
|
|
}
|
|
if ( oox_spacing->spcPts.IsInit() )
|
|
{
|
|
odf_types::length length = odf_types::length(-oox_spacing->GetVal() / 100., odf_types::length::pt);
|
|
length_or_percent = odf_types::length_or_percent(length);
|
|
}
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::RunProperties *oox_run_pr, odf_writer::text_format_properties * text_properties)
|
|
{
|
|
if (!oox_run_pr) return;
|
|
if (!text_properties) return;
|
|
|
|
PPTX::Theme *theme = oox_theme();
|
|
|
|
//------------------------------------------------------
|
|
odf_writer::odf_drawing_context *drawing = odf_context()->drawing_context();
|
|
if (drawing) //from styles drawing impossible( ... todoooo ???
|
|
{
|
|
//if ((oox_run_pr->Fill.is<PPTX::Logic::GradFill>()) ||
|
|
// (oox_run_pr->ln.IsInit() /*&& (oox_run_pr->ln->Fill.is_init() && oox_run_pr->ln->Fill.getType() != OOX::et_a_noFill)*/))
|
|
//{
|
|
// drawing->change_text_box_2_wordart();
|
|
//}
|
|
|
|
if (drawing->is_wordart())
|
|
{
|
|
if (oox_run_pr->Fill.is_init())
|
|
{
|
|
drawing->start_area_properties();
|
|
convert(&oox_run_pr->Fill);
|
|
drawing->end_area_properties();
|
|
}
|
|
if (oox_run_pr->ln.is_init())
|
|
{
|
|
drawing->start_line_properties(true);
|
|
if (oox_run_pr->ln->Fill.is_init() && oox_run_pr->ln->Fill.getType() != OOX::et_a_noFill )
|
|
{
|
|
drawing->set_line_dash_preset(6);
|
|
convert(oox_run_pr->ln.GetPointer());
|
|
}
|
|
else if (drawing->is_wordart())
|
|
drawing->set_no_fill();
|
|
drawing->end_line_properties();
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------
|
|
_CP_OPT(double) opacityText;
|
|
std::wstring hexColorText;
|
|
|
|
PPTX::Logic::GradFill* gradFill = NULL;
|
|
PPTX::Logic::SolidFill* solidFill = NULL;
|
|
|
|
if (oox_run_pr->ln.is_init())
|
|
{
|
|
if (drawing)
|
|
drawing->start_line_properties(true);
|
|
if (oox_run_pr->ln->Fill.is_init() && oox_run_pr->ln->Fill.getType() == OOX::et_a_solidFill )
|
|
{
|
|
solidFill = &oox_run_pr->ln->Fill.as<PPTX::Logic::SolidFill>();
|
|
}
|
|
}
|
|
if (!solidFill && oox_run_pr->Fill.is<PPTX::Logic::GradFill>())
|
|
{
|
|
gradFill = &oox_run_pr->Fill.as<PPTX::Logic::GradFill>();
|
|
}
|
|
else if (!solidFill && oox_run_pr->Fill.is<PPTX::Logic::SolidFill>())
|
|
{
|
|
solidFill = &oox_run_pr->Fill.as<PPTX::Logic::SolidFill>();
|
|
}
|
|
|
|
if (gradFill && !gradFill->GsLst.empty())
|
|
{
|
|
convert(&gradFill->GsLst[0].color, hexColorText, opacityText);
|
|
}
|
|
if (solidFill)
|
|
{
|
|
convert(&solidFill->Color, hexColorText, opacityText);
|
|
}
|
|
if (!hexColorText.empty())
|
|
{
|
|
if (std::wstring::npos == hexColorText.find(L"#"))
|
|
hexColorText = std::wstring(L"#") + hexColorText;
|
|
text_properties->fo_color_ = odf_types::color(hexColorText);
|
|
}
|
|
//---------------------------------------
|
|
if (oox_run_pr->b.IsInit())
|
|
{
|
|
if (oox_run_pr->b.get() == true)
|
|
text_properties->fo_font_weight_ = odf_types::font_weight(odf_types::font_weight::WBold);
|
|
else
|
|
text_properties->fo_font_weight_ = odf_types::font_weight(odf_types::font_weight::WNormal);
|
|
}
|
|
|
|
if (oox_run_pr->i.IsInit())
|
|
{
|
|
if (oox_run_pr->i.get() ==true)
|
|
text_properties->fo_font_style_ = odf_types::font_style(odf_types::font_style::Italic);
|
|
else
|
|
text_properties->fo_font_style_ = odf_types::font_style(odf_types::font_style::Normal);
|
|
}
|
|
if (oox_run_pr->sz.IsInit())
|
|
{
|
|
convert(oox_run_pr->sz.get()/100., text_properties->fo_font_size_);
|
|
convert(oox_run_pr->sz.get()/100., text_properties->style_font_size_asian_);
|
|
convert(oox_run_pr->sz.get()/100., text_properties->style_font_size_complex_);
|
|
}
|
|
if (oox_run_pr->latin.IsInit())
|
|
{
|
|
if (!oox_run_pr->latin->typeface.empty())
|
|
{
|
|
std::wstring font = oox_run_pr->latin->typeface;
|
|
convert_font(theme, font);
|
|
|
|
if (!font.empty())
|
|
text_properties->fo_font_family_ = font;
|
|
}
|
|
else
|
|
{
|
|
text_properties->fo_font_family_ = L"Calibri";//default_font; ????
|
|
}
|
|
}
|
|
if (oox_run_pr->ea.IsInit())
|
|
{
|
|
if (!oox_run_pr->ea->typeface.empty())
|
|
{
|
|
std::wstring font = oox_run_pr->ea->typeface;
|
|
convert_font(theme, font);
|
|
|
|
if (!font.empty())
|
|
text_properties->style_font_family_asian_ = font;
|
|
}
|
|
else
|
|
{
|
|
}
|
|
}
|
|
if (oox_run_pr->cs.IsInit())
|
|
{
|
|
if (!oox_run_pr->cs->typeface.empty())
|
|
{
|
|
std::wstring font = oox_run_pr->cs->typeface;
|
|
convert_font(theme, font);
|
|
|
|
if (!font.empty())
|
|
text_properties->style_font_family_complex_ = font;
|
|
}
|
|
else
|
|
{
|
|
}
|
|
}
|
|
if (oox_run_pr->lang.IsInit())
|
|
{
|
|
std::wstring oox_language = oox_run_pr->lang.get(), oox_country;
|
|
size_t res = oox_language.find(L"-");
|
|
if (res != std::wstring::npos)
|
|
{
|
|
oox_country = oox_language.substr(res + 1);
|
|
oox_language = oox_language.substr(0, res);
|
|
}
|
|
|
|
text_properties->fo_language_ = oox_language;
|
|
if (!oox_country.empty())
|
|
text_properties->fo_country_ = oox_country;
|
|
|
|
}
|
|
if (oox_run_pr->spc.IsInit())
|
|
{
|
|
text_properties->fo_letter_spacing_ = odf_types::letter_spacing(odf_types::length(oox_run_pr->spc.get()/100., odf_types::length::pt));
|
|
}
|
|
if (oox_run_pr->u.IsInit())
|
|
{
|
|
text_properties->style_text_underline_style_ = odf_types::line_style (odf_types::line_style::Solid);
|
|
text_properties->style_text_underline_type_ = odf_types::line_type (odf_types::line_type::Single);
|
|
|
|
switch(oox_run_pr->u->GetBYTECode())
|
|
{
|
|
case 12:
|
|
text_properties->style_text_underline_style_ = boost::none;
|
|
text_properties->style_text_underline_type_ = odf_types::line_type(odf_types::line_type::None);break;
|
|
case 0:
|
|
case 1:
|
|
text_properties->style_text_underline_style_ = odf_types::line_style(odf_types::line_style::Dash);break;
|
|
case 5:
|
|
case 6:
|
|
text_properties->style_text_underline_style_ = odf_types::line_style(odf_types::line_style::DotDash);break;
|
|
case 2:
|
|
case 3:
|
|
text_properties->style_text_underline_style_ = odf_types::line_style(odf_types::line_style::LongDash);break;
|
|
case 7:
|
|
case 8:
|
|
text_properties->style_text_underline_style_ = odf_types::line_style(odf_types::line_style::DotDotDash);break;
|
|
case 9:
|
|
case 10:
|
|
text_properties->style_text_underline_style_ = odf_types::line_style(odf_types::line_style::Dotted);break;
|
|
case 14:
|
|
case 16:
|
|
text_properties->style_text_underline_style_ = odf_types::line_style(odf_types::line_style::Wave);break;
|
|
case 4:
|
|
text_properties->style_text_underline_type_ = odf_types::line_type(odf_types::line_type::Double);break;
|
|
case 15:
|
|
text_properties->style_text_underline_type_ = odf_types::line_type(odf_types::line_type::Double);
|
|
text_properties->style_text_underline_style_ = odf_types::line_style(odf_types::line_style::Wave);break;
|
|
}
|
|
PPTX::Logic::UniFill *fill = NULL;
|
|
if (oox_run_pr->uFillTx.IsInit()) fill = &oox_run_pr->uFillTx->Fill;
|
|
else if (oox_run_pr->uFill.IsInit()) fill = &oox_run_pr->uFill->Fill;
|
|
if (fill && fill->is<PPTX::Logic::SolidFill>() )
|
|
{
|
|
PPTX::Logic::SolidFill &solid = fill->as<PPTX::Logic::SolidFill>();
|
|
|
|
_CP_OPT(double) opacityText;
|
|
std::wstring hexColorText;
|
|
convert(&solid.Color, hexColorText, opacityText);
|
|
if (!hexColorText.empty())
|
|
{
|
|
text_properties->style_text_underline_color_ = odf_types::color(hexColorText);
|
|
}
|
|
}
|
|
}
|
|
if (oox_run_pr->highlight.IsInit())
|
|
{
|
|
_CP_OPT(double) opacityText;
|
|
std::wstring hexColorText;
|
|
convert(&oox_run_pr->highlight->Color, hexColorText, opacityText);
|
|
|
|
text_properties->fo_background_color_ = odf_types::color(hexColorText);
|
|
}
|
|
|
|
if (oox_run_pr->strike.IsInit())
|
|
{
|
|
switch(oox_run_pr->strike->GetBYTECode())
|
|
{
|
|
case 0:
|
|
text_properties->style_text_line_through_style_ = odf_types::line_style (odf_types::line_style::Solid);
|
|
text_properties->style_text_line_through_type_ = odf_types::line_type(odf_types::line_type::Double); break;
|
|
case 1:
|
|
text_properties->style_text_line_through_style_ = boost::none;
|
|
text_properties->style_text_line_through_type_ = odf_types::line_type(odf_types::line_type::None); break;
|
|
case 2:
|
|
text_properties->style_text_line_through_style_ = odf_types::line_style (odf_types::line_style::Solid);
|
|
text_properties->style_text_line_through_type_ = odf_types::line_type(odf_types::line_type::Single); break;
|
|
}
|
|
}
|
|
|
|
if (oox_run_pr->baseline.IsInit())
|
|
{
|
|
text_properties->style_text_position_ = odf_types::text_position(*oox_run_pr->baseline / 1000.);
|
|
}
|
|
if (oox_run_pr->cap.IsInit())
|
|
{
|
|
switch(oox_run_pr->cap->GetBYTECode())
|
|
{
|
|
case 0:
|
|
text_properties->fo_text_transform_ = odf_types::text_transform(odf_types::text_transform::Uppercase); break;
|
|
case 1:
|
|
text_properties->fo_font_variant_ = odf_types::font_variant(odf_types::font_variant::SmallCaps); break;
|
|
case 2:
|
|
text_properties->fo_font_variant_ = odf_types::font_variant(odf_types::font_variant::Normal); break;
|
|
}
|
|
|
|
}
|
|
if (oox_run_pr->normalizeH.IsInit() && *oox_run_pr->normalizeH)
|
|
{
|
|
text_properties->fo_text_transform_ = odf_types::text_transform(odf_types::text_transform::Capitalize);
|
|
}
|
|
}
|
|
static std::vector<std::wstring> split_tabs(const std::wstring& text)
|
|
{
|
|
std::vector<std::wstring> result;
|
|
std::wstringstream ss;
|
|
const wchar_t tabChar = L'\t';
|
|
|
|
for (const auto& c : text)
|
|
{
|
|
if (c == tabChar)
|
|
{
|
|
if (!ss.str().empty())
|
|
{
|
|
result.push_back(ss.str());
|
|
ss.str(std::wstring());
|
|
}
|
|
|
|
result.push_back(L"\t");
|
|
}
|
|
else
|
|
ss << c;
|
|
}
|
|
|
|
if(!ss.str().empty())
|
|
result.push_back(ss.str());
|
|
|
|
return result;
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::Run *oox_run)
|
|
{
|
|
if (!oox_run) return;
|
|
bool styled = false;
|
|
|
|
odf_writer::odf_text_context* text_context = odf_context()->text_context();
|
|
|
|
if (oox_run->rPr.IsInit())
|
|
{
|
|
odf_writer::text_format_properties * text_properties = text_context->get_text_properties();
|
|
|
|
if (!text_properties)
|
|
{
|
|
text_context->get_styles_context()->create_style(L"", odf_types::style_family::Text, true, false, -1);
|
|
text_properties = text_context->get_styles_context()->last_state()->get_text_properties();
|
|
styled = true;
|
|
}
|
|
convert(oox_run->rPr.GetPointer(), text_properties);
|
|
}
|
|
|
|
text_context->start_span(styled);
|
|
|
|
if ((oox_run->rPr.IsInit()) && (oox_run->rPr->hlinkClick.IsInit()) && (oox_run->rPr->hlinkClick->id.IsInit()))
|
|
{
|
|
odf_writer::text_format_properties* text_properties = text_context->get_text_properties();
|
|
|
|
if (!text_properties->fo_color_)
|
|
{
|
|
PPTX::Logic::UniColor colorLink;
|
|
colorLink.Color.reset(new PPTX::Logic::SchemeClr());
|
|
|
|
PPTX::Logic::SchemeClr & clr = colorLink.as<PPTX::Logic::SchemeClr>();
|
|
clr.val.set(L"hlink");
|
|
|
|
std::wstring strHexColor;
|
|
_CP_OPT(double) opacity;
|
|
convert(&colorLink, strHexColor, opacity);
|
|
if (!strHexColor.empty())
|
|
text_properties->fo_color_ = strHexColor;
|
|
}
|
|
text_properties->style_text_underline_type_ = odf_types::line_type::Single;
|
|
text_properties->style_text_underline_style_ = odf_types::line_style::Solid;
|
|
|
|
bool bExternal = false;
|
|
std::wstring hlink = find_link_by_id(oox_run->rPr->hlinkClick->id.get(), 2, bExternal);
|
|
std::wstring location;
|
|
|
|
smart_ptr<OOX::File> file = find_file_by_id(oox_run->rPr->hlinkClick->id.get());
|
|
OOX::HyperLink* hyperlink = dynamic_cast<OOX::HyperLink*>(file.GetPointer());
|
|
|
|
if (hyperlink)
|
|
location = hyperlink->Uri().GetBasename();
|
|
|
|
if (oox_run->rPr->hlinkClick->action.IsInit() && location.empty())
|
|
{
|
|
const std::wstring& action = *oox_run->rPr->hlinkClick->action;
|
|
|
|
if (std::wstring::npos != action.find(L"previousslide"))
|
|
location = L"previous-page";
|
|
else if (std::wstring::npos != action.find(L"nextslide"))
|
|
location = L"next-page";
|
|
else if (std::wstring::npos != action.find(L"firstslide"))
|
|
location = L"first-page";
|
|
else if (std::wstring::npos != action.find(L"lastslide"))
|
|
location = L"last-page";
|
|
else if (std::wstring::npos != action.find(L"endshow"))
|
|
location = L"end";
|
|
}
|
|
|
|
text_context->add_hyperlink(hlink, oox_run->GetText(), location);
|
|
}
|
|
else
|
|
{
|
|
const std::wstring& text = oox_run->GetText();
|
|
std::vector<std::wstring> tabSplit = split_tabs(text);
|
|
|
|
for (const std::wstring& str : tabSplit)
|
|
{
|
|
if (str == L"\t")
|
|
text_context->add_tab();
|
|
else
|
|
text_context->add_text_content(str);
|
|
}
|
|
}
|
|
text_context->end_span();
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::Fld *oox_fld)
|
|
{
|
|
if (!oox_fld) return;
|
|
|
|
bool styled = false;
|
|
|
|
if (oox_fld->rPr.IsInit())
|
|
{
|
|
odf_writer::text_format_properties * text_properties = odf_context()->text_context()->get_text_properties();
|
|
|
|
if (!text_properties)
|
|
{
|
|
odf_context()->styles_context()->create_style(L"", odf_types::style_family::Text, true, false, -1);
|
|
text_properties = odf_context()->styles_context()->last_state()->get_text_properties();
|
|
styled = true;
|
|
}
|
|
convert(oox_fld->rPr.GetPointer(), text_properties);
|
|
}
|
|
|
|
odf_context()->text_context()->start_span(styled);
|
|
|
|
std::wstring fld_type = oox_fld->type.get_value_or(L"");
|
|
|
|
if ((oox_fld->rPr.IsInit()) && (oox_fld->rPr->hlinkClick.IsInit()) && (oox_fld->rPr->hlinkClick->id.IsInit()))
|
|
{
|
|
bool bExternal = false;
|
|
std::wstring hlink = find_link_by_id(oox_fld->rPr->hlinkClick->id.get(), 2, bExternal);
|
|
std::wstring location;
|
|
|
|
odf_context()->text_context()->add_hyperlink(hlink, oox_fld->GetText(), location);
|
|
|
|
}
|
|
else if (fld_type == L"slidenum")
|
|
{
|
|
odf_context()->text_context()->add_text_page_number( oox_fld->GetText());
|
|
}
|
|
else if (fld_type == L"datetime1")
|
|
{
|
|
odf_context()->text_context()->add_text_date( oox_fld->GetText());
|
|
}
|
|
else
|
|
{
|
|
odf_context()->text_context()->add_text_content( oox_fld->GetText());
|
|
}
|
|
odf_context()->text_context()->end_span();
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::Br *oox_br)
|
|
{
|
|
if (!oox_br) return;
|
|
odf_context()->text_context()->set_type_break(2, true);
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::MathParaWrapper *oox_math)
|
|
{
|
|
if (!oox_math) return;
|
|
|
|
odf_context()->math_context()->in_text_box_ = false;
|
|
|
|
odf_context()->start_drawing_context();
|
|
|
|
convert(oox_math->m_oMathPara.GetPointer());
|
|
convert(oox_math->m_oMath.GetPointer());
|
|
|
|
odf_context()->end_drawing_context();
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::LineTo *oox_geom_path)
|
|
{
|
|
if (!oox_geom_path) return;
|
|
|
|
std::wstring path_elm = oox_geom_path->x + L" " + oox_geom_path->y;
|
|
|
|
odf_context()->drawing_context()->add_path_element(std::wstring(L"L"), path_elm);
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::MoveTo *oox_geom_path)
|
|
{
|
|
if (!oox_geom_path) return;
|
|
|
|
std::wstring path_elm = oox_geom_path->x + L" " + oox_geom_path->y;
|
|
|
|
odf_context()->drawing_context()->add_path_element(std::wstring(L"M"), path_elm);
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::TextListStyle *oox_list_style)
|
|
{
|
|
if (!oox_list_style) return;
|
|
|
|
_CP_OPT(int) inStyles = odf_context()->drawing_context()->get_presentation();
|
|
|
|
odf_context()->styles_context()->lists_styles().start_style(inStyles && *inStyles > 0); // masters
|
|
for (int i = 0; i < 9; i++)
|
|
{
|
|
OoxConverter::convert_list_level(oox_list_style->levels[i].GetPointer(), i);
|
|
}
|
|
odf_context()->styles_context()->lists_styles().end_style();
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::Hyperlink* oox_hyperlink)
|
|
{
|
|
if (!oox_hyperlink)
|
|
return;
|
|
|
|
bool bExternal = false;
|
|
if (odf_context()->drawing_context()->is_current_empty())
|
|
{
|
|
if (oox_hyperlink->id.IsInit())
|
|
{
|
|
std::wstring hlink = find_link_by_id(oox_hyperlink->id.get(), 2, bExternal);
|
|
|
|
odf_context()->drawing_context()->start_link_object(hlink);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
odf_context()->drawing_context()->start_action(oox_hyperlink->action.get_value_or(L""));
|
|
|
|
if (oox_hyperlink->snd.IsInit())
|
|
{
|
|
std::wstring sound = find_link_by_id(oox_hyperlink->snd->embed.get(), 3, bExternal);
|
|
|
|
std::wstring href = odf_context()->add_media(sound, bExternal);
|
|
odf_context()->drawing_context()->add_sound(href);
|
|
}
|
|
if (oox_hyperlink->id.IsInit())
|
|
{
|
|
std::wstring hlink = find_link_by_id(oox_hyperlink->id.get(), 2, bExternal);
|
|
boost::replace_all(hlink, L"\\", L"/"); // NOTE(Kamil Kerimov): Always use forward slash in odf for filepaths
|
|
|
|
if (is_sound_hlink(hlink))
|
|
{
|
|
std::wstring href = odf_context()->add_media(hlink, bExternal);
|
|
odf_context()->drawing_context()->add_sound(href);
|
|
}
|
|
else
|
|
{
|
|
if (is_relative_path(hlink))
|
|
hlink = L"../" + hlink;
|
|
odf_context()->drawing_context()->add_link(hlink);
|
|
}
|
|
|
|
|
|
smart_ptr<OOX::File> file = find_file_by_id(oox_hyperlink->id.get());
|
|
OOX::HyperLink* hyperlink = dynamic_cast<OOX::HyperLink*>(file.GetPointer());
|
|
|
|
if (hyperlink)
|
|
{
|
|
odf_context()->add_hyperlink(
|
|
odf_context()->drawing_context()->get_current_element(),
|
|
hyperlink->Uri().GetBasename()
|
|
);
|
|
}
|
|
}
|
|
odf_context()->drawing_context()->end_action();
|
|
}
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::TxBody *oox_txBody, PPTX::Logic::ShapeStyle* oox_style)
|
|
{
|
|
if (!oox_txBody) return;
|
|
if (oox_txBody->Paragrs.empty()) return;
|
|
|
|
odf_context()->start_text_context();
|
|
|
|
convert(oox_txBody->lstStyle.GetPointer());
|
|
|
|
//single math - либра не тянет сложные вложенности
|
|
bool bSingleMath = false;
|
|
if (odf_context()->drawing_context()->is_text_box() &&
|
|
oox_txBody->Paragrs.size() == 1 &&
|
|
oox_txBody->Paragrs[0].RunElems.size() == 1 &&
|
|
oox_txBody->Paragrs[0].RunElems[0].getType() == OOX::et_p_MathPara)
|
|
{
|
|
bSingleMath = true;
|
|
|
|
odf_context()->math_context()->in_text_box_ = true;
|
|
|
|
PPTX::Logic::MathParaWrapper *oox_math = dynamic_cast<PPTX::Logic::MathParaWrapper*>(oox_txBody->Paragrs[0].RunElems[0].GetElem().GetPointer());
|
|
convert(oox_math->m_oMathPara.GetPointer());
|
|
convert(oox_math->m_oMath.GetPointer());
|
|
|
|
odf_context()->math_context()->in_text_box_ = false;
|
|
}
|
|
//----------------------------------------------------------------------------------------------
|
|
for (size_t i = 0; !bSingleMath && i < oox_txBody->Paragrs.size(); i++)
|
|
{
|
|
convert(&oox_txBody->Paragrs[i], oox_txBody->lstStyle.GetPointer());
|
|
|
|
//внешние настройки для текста
|
|
convert(oox_txBody->bodyPr.GetPointer());
|
|
|
|
if (oox_style)
|
|
{
|
|
convert(&oox_style->fontRef);
|
|
}
|
|
}
|
|
odf_context()->drawing_context()->set_text( odf_context()->text_context());
|
|
|
|
odf_context()->end_text_context();
|
|
}
|
|
|
|
static std::wstring convert_arc_angle(const std::wstring& angle, odf_writer::odf_drawing_context* dc)
|
|
{
|
|
std::wstring result = L"0";
|
|
|
|
int angleInt = XmlUtils::GetInteger(angle);
|
|
|
|
if (angleInt == 0 && angle != L"0")
|
|
{
|
|
result = std::wstring(L"gd") + std::to_wstring(dc->get_formulas_count());
|
|
dc->add_formula(result, L"*/ 1 " + angle + L" 60000");
|
|
}
|
|
else
|
|
result = std::to_wstring(angleInt / 60000);
|
|
|
|
return result;
|
|
}
|
|
|
|
void OoxConverter::convert(PPTX::Logic::ArcTo *oox_geom_path)
|
|
{
|
|
if (!oox_geom_path) return;
|
|
|
|
const std::wstring stAng = convert_arc_angle(oox_geom_path->stAng, odf_context()->drawing_context());
|
|
const std::wstring swAng = convert_arc_angle(oox_geom_path->swAng, odf_context()->drawing_context());
|
|
|
|
std::wstring path_elm = oox_geom_path->wR + L" " + oox_geom_path->hR + L" " + stAng + L" " + swAng;
|
|
|
|
odf_context()->drawing_context()->add_path_element(std::wstring(L"G"), path_elm);
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::QuadBezTo *oox_geom_path)
|
|
{
|
|
if (!oox_geom_path) return;
|
|
|
|
std::wstring path_elm = oox_geom_path->x[0] + L" " + oox_geom_path->y[0] + L" " + oox_geom_path->x[1] + L" " + oox_geom_path->y[1];
|
|
|
|
odf_context()->drawing_context()->add_path_element(std::wstring(L"S"), path_elm);
|
|
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::CubicBezTo *oox_geom_path)
|
|
{
|
|
if (!oox_geom_path) return;
|
|
|
|
std::wstring path_elm = oox_geom_path->x[0] + L" " + oox_geom_path->y[0] + L" " +
|
|
oox_geom_path->x[1] + L" " + oox_geom_path->y[1] + L" " +
|
|
oox_geom_path->x[2] + L" " + oox_geom_path->y[2];
|
|
|
|
odf_context()->drawing_context()->add_path_element(std::wstring(L"C"), path_elm);
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::Close *oox_geom_path)
|
|
{
|
|
if (!oox_geom_path) return;
|
|
|
|
std::wstring path_elm ;
|
|
odf_context()->drawing_context()->add_path_element(std::wstring(L"Z"), path_elm);
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::StyleRef *style_ref, int type)
|
|
{
|
|
if (!style_ref) return;
|
|
|
|
DWORD nARGB = 0;
|
|
convert(&style_ref->Color, nARGB);
|
|
|
|
if (style_ref->idx.IsInit() == false)
|
|
{
|
|
std::wstring hexColor = XmlUtils::ToString((unsigned int)(nARGB & 0x00FFFFFF), L"#%06X");
|
|
_CP_OPT(double) opacity;
|
|
|
|
if ((nARGB >> 24) != 0xff)
|
|
{
|
|
opacity = ((nARGB >> 24) /255.) * 100.;
|
|
}
|
|
|
|
if (type != 3) //?? todooo
|
|
{
|
|
odf_context()->drawing_context()->set_solid_fill(hexColor);
|
|
|
|
if (opacity)
|
|
odf_context()->drawing_context()->set_opacity(*opacity);
|
|
}
|
|
return;
|
|
}
|
|
|
|
int index = *style_ref->idx;
|
|
|
|
PPTX::Theme *theme = oox_theme();
|
|
if (!theme) return;
|
|
|
|
OOX::IFileContainer* old = oox_current_child_document;
|
|
oox_current_child_document = theme;
|
|
|
|
if (type == 1)
|
|
{
|
|
PPTX::Logic::UniFill *fill = NULL;
|
|
if (index < 1000)
|
|
{
|
|
index -= 1;
|
|
if (index >= 0 && index < (int)theme->themeElements.fmtScheme.fillStyleLst.size())
|
|
{
|
|
fill = &theme->themeElements.fmtScheme.fillStyleLst[index];
|
|
}
|
|
}
|
|
else if (index > 1000)
|
|
{
|
|
index -= 1001;
|
|
if (index >= 0 && index < (int)theme->themeElements.fmtScheme.bgFillStyleLst.size())
|
|
{
|
|
fill = &theme->themeElements.fmtScheme.bgFillStyleLst[index];
|
|
}
|
|
}
|
|
|
|
convert(fill, nARGB);
|
|
}
|
|
else if (type == 2)
|
|
{
|
|
index -= 1;
|
|
if (index >= 0 && index < (int)theme->themeElements.fmtScheme.lnStyleLst.size())
|
|
{
|
|
convert(&theme->themeElements.fmtScheme.lnStyleLst[index], nARGB);
|
|
}
|
|
}
|
|
else if (type == 3)
|
|
{
|
|
index -= 1;
|
|
if (index >= 0 && index < (int)theme->themeElements.fmtScheme.effectStyleLst.size())
|
|
{
|
|
convert(&theme->themeElements.fmtScheme.effectStyleLst[index], nARGB);
|
|
}
|
|
}
|
|
oox_current_child_document = old;
|
|
}
|
|
void OoxConverter::convert(PPTX::Logic::FontRef *style_font_ref)
|
|
{
|
|
if (!style_font_ref) return;
|
|
|
|
PPTX::Theme *theme = oox_theme();
|
|
if (!theme) return;
|
|
|
|
std::wstring hexColor;
|
|
_CP_OPT(double) opacity;
|
|
|
|
convert(&style_font_ref->Color, hexColor, opacity);
|
|
odf_context()->drawing_context()->set_textarea_fontcolor(hexColor);
|
|
|
|
if (style_font_ref->idx.IsInit())
|
|
{
|
|
PPTX::Logic::FontCollection *style_font = NULL;
|
|
if (style_font_ref->idx->GetBYTECode() == SimpleTypes::fontcollectionindexMajor)
|
|
{
|
|
style_font = &theme->themeElements.fontScheme.majorFont;
|
|
}
|
|
if (style_font_ref->idx->GetBYTECode() == SimpleTypes::fontcollectionindexMinor)
|
|
{
|
|
style_font = &theme->themeElements.fontScheme.minorFont;
|
|
}
|
|
if (style_font)
|
|
{
|
|
std::wstring latin = style_font->latin.typeface;
|
|
std::wstring ea = style_font->ea.typeface;
|
|
std::wstring cs = style_font->cs.typeface;
|
|
|
|
//theme->themeElements.fontScheme
|
|
|
|
odf_context()->drawing_context()->set_textarea_font(latin, ea, cs);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|