pengjunjie/core
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/core.git synced 2026-07-11 10:59:17 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
feature/libxml2
core/OOXML/PPTXFormat/DrawingConverter/ASCOfficeDrawingConverter.cpp
Oleg Korshul 5f6075ca33 Merge branch 'release/v9.4.0' into develop
2026-05-19 16:46:09 +03:00

6078 lines
213 KiB
C++
Raw Permalink Blame History

/*
* Copyright (C) Ascensio System SIA, 2009-2026
*
* 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, together with the
* additional terms provided in the LICENSE file.
*
* 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: https://www.gnu.org/licenses/agpl-3.0.html
*
* You can contact Ascensio System SIA by email at info@onlyoffice.com
* or by postal mail at 20A-6 Ernesta Birznieka-Upisha Street, Riga,
* LV-1050, Latvia, European Union.
*
* The interactive user interfaces in modified versions of the Program
* are required to display Appropriate Legal Notices in accordance with
* Section 5 of the GNU AGPL version 3.
*
* No trademark rights are granted under this License.
*
* All non-code elements of the Product, including illustrations,
* icon sets, and technical writing content, are licensed under the
* Creative Commons Attribution-ShareAlike 4.0 International License:
* https://creativecommons.org/licenses/by-sa/4.0/legalcode
*
* This license applies only to such non-code elements and does not
* modify or replace the licensing terms applicable to the Program's
* source code, which remains licensed under the GNU Affero General
* Public License v3.
*
* SPDX-License-Identifier: AGPL-3.0-only
*/
#include "ASCOfficeDrawingConverter.h"
#include "../../PPTXFormat/Logic/SpTreeElem.h"
#include "../../PPTXFormat/Logic/Geometry.h"
#include "../../PPTXFormat/Logic/SpTreeElem.h"
#include "../../PPTXFormat/Logic/Shape.h"
#include "../../PPTXFormat/Logic/Pic.h"
#include "../../PPTXFormat/Logic/CxnSp.h"
#include "../../PPTXFormat/Logic/SpTree.h"
#include "../../PPTXFormat/Logic/GraphicFrame.h"
#include "../../PPTXFormat/Logic/Colors/SrgbClr.h"
#include "../../PPTXFormat/Logic/Colors/PrstClr.h"
#include "../../PPTXFormat/Logic/Colors/SchemeClr.h"
#include "../../PPTXFormat/Logic/Colors/SysClr.h"
#include "../../PPTXFormat/Logic/Effects/AlphaModFix.h"
#include "../../PPTXFormat/Logic/Effects/Duotone.h"
#include "../../PPTXFormat/PPTX.h"
#include "../../PPTXFormat/LegacyDiagramText.h"
#include "../../../MsBinaryFile/PptFile/Drawing/Elements.h"
#include "../../../MsBinaryFile/Common/Vml/PPTXShape/Pptx2PptShapeConverter.h"
#include "../../../MsBinaryFile/Common/Vml/toVmlConvert.h"
#include "../../../DesktopEditor/common/Directory.h"
#include "../../../DesktopEditor/graphics/pro/Fonts.h"
#include "../../DocxFormat/VmlDrawing.h"
#include "../../DocxFormat/Diagram/DiagramData.h"
#include "../../DocxFormat/Diagram/DiagramDrawing.h"
#include "../../DocxFormat/Drawing/DrawingExt.h"
#include "../../DocxFormat/Media/Image.h"
#include "../../Common/SimpleTypes_Base.h"
#include "../../Common/SimpleTypes_Vml.h"
#include "../../Binary/Presentation/BinWriters.h"
const double g_emu_koef = 25.4 * 36000 / 72.0;
const std::wstring _start_xml_object(L"<main xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" \
xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" \
xmlns:p=\"urn:schemas-microsoft-com:office:powerpoint\" \
xmlns:v=\"urn:schemas-microsoft-com:vml\" \
xmlns:x=\"urn:schemas-microsoft-com:office:excel\" \
xmlns:o=\"urn:schemas-microsoft-com:office:office\" \
xmlns:w10=\"urn:schemas-microsoft-com:office:word\" \
xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" \
xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" \
xmlns:ve=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" \
xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" \
xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" \
xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" \
xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" \
xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" \
xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" \
xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" \
xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" \
xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" \
xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" \
xmlns:a14=\"http://schemas.microsoft.com/office/drawing/2010/main\" \
xmlns:pic=\"http://schemas.openxmlformats.org/drawingml/2006/picture\" \
xmlns:xdr=\"http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing\">");
const std::wstring _end_xml_object(L"</main>");
static void GetColorWithEffect(const std::wstring& sColor, const int& R, const int& G, const int& B,
int& resR, int& resG, int& resB)
{
resR = R;
resG = G;
resB = B;
double param = 0;
std::wstring::size_type pos1 = sColor.find('(');
std::wstring::size_type pos2 = sColor.find(')');
if (pos1 == std::wstring::npos || pos2 == std::wstring::npos)
return;
if (pos2 < (pos1 + 2))
return;
std::wstring s = sColor.substr(pos1 + 1, pos2 - pos1 - 1);
param = XmlUtils::GetInteger(s);
bool isEffect = false;
if (0 == sColor.find(L"darken"))
{
resR = (int)(R * param / 255);
resG = (int)(G * param / 255);
resB = (int)(B * param / 255);
isEffect = true;
}
else if (0 == sColor.find(L"lighten"))
{
resR = 255 - (int)((255 - R) * param / 255);
resG = 255 - (int)((255 - G) * param / 255);
resB = 255 - (int)((255 - B) * param / 255);
isEffect = true;
}
else if (0 == sColor.find(L"add"))
{
resR = R + (int)param;
resG = G + (int)param;
resB = B + (int)param;
isEffect = true;
}
else if (0 == sColor.find(L"subtract"))
{
resR = R - (int)param;
resG = G - (int)param;
resB = B - (int)param;
isEffect = true;
}
else if (0 == sColor.find(L"reversesubtract"))
{
resR = (int)param - R;
resG = (int)param - G;
resB = (int)param - B;
isEffect = true;
}
else if (0 == sColor.find(L"blackwhite"))
{
resR = (R < (int)param) ? 0 : 255;
resG = (G < (int)param) ? 0 : 255;
resB = (B < (int)param) ? 0 : 255;
isEffect = true;
}
if (isEffect)
{
resR = (resR < 0) ? 0 : resR;
resR = (resR > 255) ? 255 : resR;
resG = (resG < 0) ? 0 : resG;
resG = (resG > 255) ? 255 : resG;
resB = (resB < 0) ? 0 : resB;
resB = (resB > 255) ? 255 : resB;
}
}
namespace PPTX2EditorAdvanced
{
OOXMLShapes::ShapeType GetShapeTypeFromStr(const std::wstring& str)//const
{
if (str == _T(""))
return OOXMLShapes::sptNil;
switch ((CHAR)str[0])
{
case 'a':
if (str == _T("accentBorderCallout1")) return OOXMLShapes::sptCAccentBorderCallout1;
if (str == _T("accentBorderCallout2")) return OOXMLShapes::sptCAccentBorderCallout2;
if (str == _T("accentBorderCallout3")) return OOXMLShapes::sptCAccentBorderCallout3;
if (str == _T("accentCallout1")) return OOXMLShapes::sptCAccentCallout1;
if (str == _T("accentCallout2")) return OOXMLShapes::sptCAccentCallout2;
if (str == _T("accentCallout3")) return OOXMLShapes::sptCAccentCallout3;
if (str == _T("actionButtonBackPrevious")) return OOXMLShapes::sptCActionButtonBackPrevious;
if (str == _T("actionButtonBeginning")) return OOXMLShapes::sptCActionButtonBeginning;
if (str == _T("actionButtonBlank")) return OOXMLShapes::sptCActionButtonBlank;
if (str == _T("actionButtonDocument")) return OOXMLShapes::sptCActionButtonDocument;
if (str == _T("actionButtonEnd")) return OOXMLShapes::sptCActionButtonEnd;
if (str == _T("actionButtonForwardNext")) return OOXMLShapes::sptCActionButtonForwardNext;
if (str == _T("actionButtonHelp")) return OOXMLShapes::sptCActionButtonHelp;
if (str == _T("actionButtonHome")) return OOXMLShapes::sptCActionButtonHome;
if (str == _T("actionButtonInformation")) return OOXMLShapes::sptCActionButtonInformation;
if (str == _T("actionButtonMovie")) return OOXMLShapes::sptCActionButtonMovie;
if (str == _T("actionButtonReturn")) return OOXMLShapes::sptCActionButtonReturn;
if (str == _T("actionButtonSound")) return OOXMLShapes::sptCActionButtonSound;
if (str == _T("arc")) return OOXMLShapes::sptCArc;
break;
case 'b':
if (str == _T("bentArrow")) return OOXMLShapes::sptCBentArrow;
if (str == _T("bentConnector2")) return OOXMLShapes::sptCBentConnector2;
if (str == _T("bentConnector3")) return OOXMLShapes::sptCBentConnector3;
if (str == _T("bentConnector4")) return OOXMLShapes::sptCBentConnector4;
if (str == _T("bentConnector5")) return OOXMLShapes::sptCBentConnector5;
if (str == _T("bentUpArrow")) return OOXMLShapes::sptCBentUpArrow;
if (str == _T("bevel")) return OOXMLShapes::sptCBevel;
if (str == _T("blockArc")) return OOXMLShapes::sptCBlockArc;
if (str == _T("borderCallout1")) return OOXMLShapes::sptCBorderCallout1;
if (str == _T("borderCallout2")) return OOXMLShapes::sptCBorderCallout2;
if (str == _T("borderCallout3")) return OOXMLShapes::sptCBorderCallout3;
if (str == _T("bracePair")) return OOXMLShapes::sptCBracePair;
if (str == _T("bracketPair")) return OOXMLShapes::sptCBracketPair;
break;
case 'c':
if (str == _T("callout1")) return OOXMLShapes::sptCCallout1;
if (str == _T("callout2")) return OOXMLShapes::sptCCallout2;
if (str == _T("callout3")) return OOXMLShapes::sptCCallout3;
if (str == _T("can")) return OOXMLShapes::sptCCan;
if (str == _T("chartPlus")) return OOXMLShapes::sptCChartPlus;
if (str == _T("chartStar")) return OOXMLShapes::sptCChartStar;
if (str == _T("chartX")) return OOXMLShapes::sptCChartX;
if (str == _T("chevron")) return OOXMLShapes::sptCChevron;
if (str == _T("chord")) return OOXMLShapes::sptCChord;
if (str == _T("circularArrow")) return OOXMLShapes::sptCCircularArrow;
if (str == _T("cloud")) return OOXMLShapes::sptCCloud;
if (str == _T("cloudCallout")) return OOXMLShapes::sptCCloudCallout;
if (str == _T("corner")) return OOXMLShapes::sptCCorner;
if (str == _T("cornerTabs")) return OOXMLShapes::sptCCornerTabs;
if (str == _T("cube")) return OOXMLShapes::sptCCube;
if (str == _T("curvedConnector2")) return OOXMLShapes::sptCCurvedConnector2;
if (str == _T("curvedConnector3")) return OOXMLShapes::sptCCurvedConnector3;
if (str == _T("curvedConnector4")) return OOXMLShapes::sptCCurvedConnector4;
if (str == _T("curvedConnector5")) return OOXMLShapes::sptCCurvedConnector5;
if (str == _T("curvedDownArrow")) return OOXMLShapes::sptCCurvedDownArrow;
if (str == _T("curvedLeftArrow")) return OOXMLShapes::sptCCurvedLeftArrow;
if (str == _T("curvedRightArrow")) return OOXMLShapes::sptCCurvedRightArrow;
if (str == _T("curvedUpArrow")) return OOXMLShapes::sptCCurvedUpArrow;
break;
case 'd':
if (str == _T("decagon")) return OOXMLShapes::sptCDecagon;
if (str == _T("diagStripe")) return OOXMLShapes::sptCDiagStripe;
if (str == _T("diamond")) return OOXMLShapes::sptCDiamond;
if (str == _T("dodecagon")) return OOXMLShapes::sptCDodecagon;
if (str == _T("donut")) return OOXMLShapes::sptCDonut;
if (str == _T("doubleWave")) return OOXMLShapes::sptCDoubleWave;
if (str == _T("downArrow")) return OOXMLShapes::sptCDownArrow;
if (str == _T("downArrowCallout")) return OOXMLShapes::sptCDownArrowCallout;
break;
case 'e':
if (str == _T("ellipse")) return OOXMLShapes::sptCEllipse;
if (str == _T("ellipseRibbon")) return OOXMLShapes::sptCEllipseRibbon;
if (str == _T("ellipseRibbon2")) return OOXMLShapes::sptCEllipseRibbon2;
break;
case 'f':
if (str == _T("flowChartAlternateProcess")) return OOXMLShapes::sptCFlowChartAlternateProcess;
if (str == _T("flowChartCollate")) return OOXMLShapes::sptCFlowChartCollate;
if (str == _T("flowChartConnector")) return OOXMLShapes::sptCFlowChartConnector;
if (str == _T("flowChartDecision")) return OOXMLShapes::sptCFlowChartDecision;
if (str == _T("flowChartDelay")) return OOXMLShapes::sptCFlowChartDelay;
if (str == _T("flowChartDisplay")) return OOXMLShapes::sptCFlowChartDisplay;
if (str == _T("flowChartDocument")) return OOXMLShapes::sptCFlowChartDocument;
if (str == _T("flowChartExtract")) return OOXMLShapes::sptCFlowChartExtract;
if (str == _T("flowChartInputOutput")) return OOXMLShapes::sptCFlowChartInputOutput;
if (str == _T("flowChartInternalStorage")) return OOXMLShapes::sptCFlowChartInternalStorage;
if (str == _T("flowChartMagneticDisk")) return OOXMLShapes::sptCFlowChartMagneticDisk;
if (str == _T("flowChartMagneticDrum")) return OOXMLShapes::sptCFlowChartMagneticDrum;
if (str == _T("flowChartMagneticTape")) return OOXMLShapes::sptCFlowChartMagneticTape;
if (str == _T("flowChartManualInput")) return OOXMLShapes::sptCFlowChartManualInput;
if (str == _T("flowChartManualOperation")) return OOXMLShapes::sptCFlowChartManualOperation;
if (str == _T("flowChartMerge")) return OOXMLShapes::sptCFlowChartMerge;
if (str == _T("flowChartMultidocument")) return OOXMLShapes::sptCFlowChartMultidocument;
if (str == _T("flowChartOfflineStorage")) return OOXMLShapes::sptCFlowChartOfflineStorage;
if (str == _T("flowChartOffpageConnector")) return OOXMLShapes::sptCFlowChartOffpageConnector;
if (str == _T("flowChartOnlineStorage")) return OOXMLShapes::sptCFlowChartOnlineStorage;
if (str == _T("flowChartOr")) return OOXMLShapes::sptCFlowChartOr;
if (str == _T("flowChartPredefinedProcess")) return OOXMLShapes::sptCFlowChartPredefinedProcess;
if (str == _T("flowChartPreparation")) return OOXMLShapes::sptCFlowChartPreparation;
if (str == _T("flowChartProcess")) return OOXMLShapes::sptCFlowChartProcess;
if (str == _T("flowChartPunchedCard")) return OOXMLShapes::sptCFlowChartPunchedCard;
if (str == _T("flowChartPunchedTape")) return OOXMLShapes::sptCFlowChartPunchedTape;
if (str == _T("flowChartSort")) return OOXMLShapes::sptCFlowChartSort;
if (str == _T("flowChartSummingJunction")) return OOXMLShapes::sptCFlowChartSummingJunction;
if (str == _T("flowChartTerminator")) return OOXMLShapes::sptCFlowChartTerminator;
if (str == _T("foldedCorner")) return OOXMLShapes::sptCFoldedCorner;
if (str == _T("frame")) return OOXMLShapes::sptCFrame;
if (str == _T("funnel")) return OOXMLShapes::sptCFunnel;
break;
case 'g':
if (str == _T("gear6")) return OOXMLShapes::sptCGear6;
if (str == _T("gear9")) return OOXMLShapes::sptCGear9;
break;
case 'h':
if (str == _T("halfFrame")) return OOXMLShapes::sptCHalfFrame;
if (str == _T("heart")) return OOXMLShapes::sptCHeart;
if (str == _T("heptagon")) return OOXMLShapes::sptCHeptagon;
if (str == _T("hexagon")) return OOXMLShapes::sptCHexagon;
if (str == _T("homePlate")) return OOXMLShapes::sptCHomePlate;
if (str == _T("horizontalScroll")) return OOXMLShapes::sptCHorizontalScroll;
break;
case 'i':
if (str == _T("irregularSeal1")) return OOXMLShapes::sptCIrregularSeal1;
if (str == _T("irregularSeal2")) return OOXMLShapes::sptCIrregularSeal2;
break;
case 'l':
if (str == _T("leftArrow")) return OOXMLShapes::sptCLeftArrow;
if (str == _T("leftArrowCallout")) return OOXMLShapes::sptCLeftArrowCallout;
if (str == _T("leftBrace")) return OOXMLShapes::sptCLeftBrace;
if (str == _T("leftBracket")) return OOXMLShapes::sptCLeftBracket;
if (str == _T("leftCircularArrow")) return OOXMLShapes::sptCLeftCircularArrow;
if (str == _T("leftRightArrow")) return OOXMLShapes::sptCLeftRightArrow;
if (str == _T("leftRightArrowCallout")) return OOXMLShapes::sptCLeftRightArrowCallout;
if (str == _T("leftRightCircularArrow")) return OOXMLShapes::sptCLeftRightCircularArrow;
if (str == _T("leftRightRibbon")) return OOXMLShapes::sptCLeftRightRibbon;
if (str == _T("leftRightUpArrow")) return OOXMLShapes::sptCLeftRightUpArrow;
if (str == _T("leftUpArrow")) return OOXMLShapes::sptCLeftUpArrow;
if (str == _T("lightningBolt")) return OOXMLShapes::sptCLightningBolt;
if (str == _T("line")) return OOXMLShapes::sptCLine;
if (str == _T("lineInv")) return OOXMLShapes::sptCLineInv;
break;
case 'm':
if (str == _T("mathDivide")) return OOXMLShapes::sptCMathDivide;
if (str == _T("mathEqual")) return OOXMLShapes::sptCMathEqual;
if (str == _T("mathMinus")) return OOXMLShapes::sptCMathMinus;
if (str == _T("mathMultiply")) return OOXMLShapes::sptCMathMultiply;
if (str == _T("mathNotEqual")) return OOXMLShapes::sptCMathNotEqual;
if (str == _T("mathPlus")) return OOXMLShapes::sptCMathPlus;
if (str == _T("moon")) return OOXMLShapes::sptCMoon;
break;
case 'n':
if (str == _T("nonIsoscelesTrapezoid")) return OOXMLShapes::sptCNonIsoscelesTrapezoid;
if (str == _T("noSmoking")) return OOXMLShapes::sptCNoSmoking;
if (str == _T("notchedRightArrow")) return OOXMLShapes::sptCNotchedRightArrow;
break;
case 'o':
if (str == _T("octagon")) return OOXMLShapes::sptCOctagon;
break;
case 'p':
if (str == _T("parallelogram")) return OOXMLShapes::sptCParallelogram;
if (str == _T("pentagon")) return OOXMLShapes::sptCPentagon;
if (str == _T("pie")) return OOXMLShapes::sptCPie;
if (str == _T("pieWedge")) return OOXMLShapes::sptCPieWedge;
if (str == _T("plaque")) return OOXMLShapes::sptCPlaque;
if (str == _T("plaqueTabs")) return OOXMLShapes::sptCPlaqueTabs;
if (str == _T("plus")) return OOXMLShapes::sptCPlus;
break;
case 'q':
if (str == _T("quadArrow")) return OOXMLShapes::sptCQuadArrow;
if (str == _T("quadArrowCallout")) return OOXMLShapes::sptCQuadArrowCallout;
break;
case 'r':
if (str == _T("rect")) return OOXMLShapes::sptCRect;
if (str == _T("ribbon")) return OOXMLShapes::sptCRibbon;
if (str == _T("ribbon2")) return OOXMLShapes::sptCRibbon2;
if (str == _T("rightArrow")) return OOXMLShapes::sptCRightArrow;
if (str == _T("rightArrowCallout")) return OOXMLShapes::sptCRightArrowCallout;
if (str == _T("rightBrace")) return OOXMLShapes::sptCRightBrace;
if (str == _T("rightBracket")) return OOXMLShapes::sptCRightBracket;
if (str == _T("round1Rect")) return OOXMLShapes::sptCRound1Rect;
if (str == _T("round2DiagRect")) return OOXMLShapes::sptCRound2DiagRect;
if (str == _T("round2SameRect")) return OOXMLShapes::sptCRound2SameRect;
if (str == _T("roundRect")) return OOXMLShapes::sptCRoundRect;
if (str == _T("rtTriangle")) return OOXMLShapes::sptCRtTriangle;
break;
case 's':
if (str == _T("smileyFace")) return OOXMLShapes::sptCSmileyFace;
if (str == _T("snip1Rect")) return OOXMLShapes::sptCSnip1Rect;
if (str == _T("snip2DiagRect")) return OOXMLShapes::sptCSnip2DiagRect;
if (str == _T("snip2SameRect")) return OOXMLShapes::sptCSnip2SameRect;
if (str == _T("snipRoundRect")) return OOXMLShapes::sptCSnipRoundRect;
if (str == _T("squareTabs")) return OOXMLShapes::sptCSquareTabs;
if (str == _T("star10")) return OOXMLShapes::sptCStar10;
if (str == _T("star12")) return OOXMLShapes::sptCStar12;
if (str == _T("star16")) return OOXMLShapes::sptCStar16;
if (str == _T("star24")) return OOXMLShapes::sptCStar24;
if (str == _T("star32")) return OOXMLShapes::sptCStar32;
if (str == _T("star4")) return OOXMLShapes::sptCStar4;
if (str == _T("star5")) return OOXMLShapes::sptCStar5;
if (str == _T("star6")) return OOXMLShapes::sptCStar6;
if (str == _T("star7")) return OOXMLShapes::sptCStar7;
if (str == _T("star8")) return OOXMLShapes::sptCStar8;
if (str == _T("straightConnector1")) return OOXMLShapes::sptCStraightConnector1;
if (str == _T("stripedRightArrow")) return OOXMLShapes::sptCStripedRightArrow;
if (str == _T("sun")) return OOXMLShapes::sptCSun;
if (str == _T("swooshArrow")) return OOXMLShapes::sptCSwooshArrow;
break;
case 't':
if (str == _T("teardrop")) return OOXMLShapes::sptCTeardrop;
if (str == _T("trapezoid")) return OOXMLShapes::sptCTrapezoid;
if (str == _T("triangle")) return OOXMLShapes::sptCTriangle;
break;
case 'u':
if (str == _T("upArrow")) return OOXMLShapes::sptCUpArrow;
if (str == _T("upArrowCallout")) return OOXMLShapes::sptCUpArrowCallout;
if (str == _T("upDownArrow")) return OOXMLShapes::sptCUpDownArrow;
if (str == _T("upDownArrowCallout")) return OOXMLShapes::sptCUpDownArrowCallout;
if (str == _T("uturnArrow")) return OOXMLShapes::sptCUturnArrow;
break;
case 'v':
if (str == _T("verticalScroll")) return OOXMLShapes::sptCVerticalScroll;
break;
case 'w':
if (str == _T("wave")) return OOXMLShapes::sptCWave;
if (str == _T("wedgeEllipseCallout")) return OOXMLShapes::sptCWedgeEllipseCallout;
if (str == _T("wedgeRectCallout")) return OOXMLShapes::sptCWedgeRectCallout;
if (str == _T("wedgeRoundRectCallout")) return OOXMLShapes::sptCWedgeRoundRectCallout;
break;
}
return OOXMLShapes::sptNil;
}
}
namespace NS_DWC_Common
{
void CorrentCropString(std::wstring& s)
{
size_t nLen = s.length();
if (nLen > 0 && (s[nLen - 1] == ((wchar_t)'f')))
{
s.erase(nLen - 1);
int nVal = XmlUtils::GetInteger(s);
double dKoef = 100000.0 / 65536;
nVal = (int)(dKoef * nVal + 0.5);
s = std::to_wstring(nVal);
}
}
BYTE getOpacityFromString(const std::wstring opacityStr)
{
BYTE alpha = 0xff;
if (opacityStr.find(L"f") != std::wstring::npos)
{
alpha = (BYTE)(XmlUtils::GetDouble(opacityStr) / 65536 * 256);
}
else
{
if (opacityStr.find(L"%") != std::wstring::npos)
{
alpha = (BYTE)(XmlUtils::GetDouble(opacityStr.substr(0, opacityStr.length() - 1)) / 100. * 256);
}
else if (0 == opacityStr.find(L"."))
{
std::wstring str = L"0" + opacityStr;
alpha = (BYTE)(XmlUtils::GetDouble(str) * 256);
}
else
{
alpha = (BYTE)(XmlUtils::GetDouble(opacityStr) * 256);
}
}
return alpha;
}
long getRealFromString(const std::wstring& str)
{
long val = 0;
if (str.find(L"f") != -1)
val = XmlUtils::GetInteger(str);
else
val = (long)(XmlUtils::GetDouble(str) * 65536);
return val;
}
int getRotateAngle(const std::wstring& str, const nullable_bool& flipX, const nullable_bool& flipY)
{
bool bIsInvertAngle = false;
int nCheckInvert = 0;
if (flipX.is_init() && flipX.get() == true)
nCheckInvert += 1;
if (flipY.is_init() && flipY.get() == true)
nCheckInvert += 1;
int nRot = XmlUtils::GetInteger(str);
if (str.rfind(wchar_t('f')) != -1)
{
double dVal = (double)nRot;
dVal /= 65536;
if (nCheckInvert == 1)
{
dVal = -dVal;
}
if (dVal > 360)
{
int nPart = (int)(dVal / 360);
dVal = dVal - nPart * 360;
}
else if (dVal < 0)
{
int nPart = (int)(dVal / 360);
nPart = 1 - nPart;
dVal = dVal + nPart * 360;
}
nRot = (int)(dVal * 60000);
}
else
{
if (nCheckInvert == 1)
{
nRot = -nRot;
}
if (nRot > 360)
{
int nPart = (int)(nRot / 360);
nRot = nRot - nPart * 360;
}
else if (nRot < 0)
{
int nPart = (int)(nRot / 360);
nPart = 1 - nPart;
nRot = nRot + nPart * 360;
}
nRot *= 60000;
}
return nRot;
}
const static int shemeDefaultColor[] =
{
0x00000000, 0x00FFFFFF, 0x00FF0000, 0x0000FF00, 0x000000FF, 0x00FFFF00, 0x00FF00FF, 0x0000FFFF,
0x00000000, 0x00FFFFFF, 0x00FF0000, 0x0000FF00, 0x000000FF, 0x00FFFF00, 0x00FF00FF, 0x0000FFFF,
0x00800000, 0x00008000, 0x00000080, 0x00808000, 0x00800080, 0x00008080, 0x00C0C0C0, 0x00808080,
0x009999FF, 0x00993366, 0x00FFFFCC, 0x00CCFFFF, 0x00660066, 0x00FF8080, 0x000066CC, 0x00CCCCFF,
0x00000080, 0x00FF00FF, 0x00FFFF00, 0x0000FFFF, 0x00800080, 0x00800000, 0x00008080, 0x000000FF,
0x0000CCFF, 0x00CCFFFF, 0x00CCFFCC, 0x00FFFF99, 0x0099CCFF, 0x00FF99CC, 0x00CC99FF, 0x00FFCC99,
0x003366FF, 0x0033CCCC, 0x0099CC00, 0x00FFCC00, 0x00FF9900, 0x00FF6600, 0x00666699, 0x00969696,
0x00003366, 0x00339966, 0x00003300, 0x00333300, 0x00993300, 0x00993366, 0x00333399, 0x00333333
};
//const static int controlPanelColors1[] =
//{
// 0x00FFFFFF, 0x00CCCCCC, 0x00FFFFFF, 0x006363CE,
// 0x00DDDDDD, 0x00DDDDDD, 0x00888888, 0x00000000,
// 0x00000000, 0x00808080, 0x00B5D5FF, 0x00000000,
// 0x00FFFFFF, 0x00FFFFFF, 0x007F7F7F, 0x00FBFCC5,
// 0x00000000, 0x00F7F7F7, 0x00000000, 0x00FFFFFF,
// 0x00666666, 0x00C0C0C0, 0x00DDDDDD, 0x00C0C0C0,
// 0x00888888, 0x00FFFFFF, 0x00CCCCCC, 0x00000000
//};
//const static int controlPanelColors2[] =
//{
// 0x00000000, 0x00FFFFFF, 0x00000000, 0x00FFFFFF,
// 0x00000000, 0x00000000, 0x00000000, 0x00FFFFFF,
// 0x00FFFFFF, 0x00000000, 0x00FFFFFF, 0x00FFFFFF,
// 0x00000000, 0x00000000, 0x00000000, 0x00000000,
// 0x00FFFFFF, 0x00FFFFFF, 0x00FFFFFF, 0x00000000,
// 0x00FFFFFF, 0x00000000, 0x00000000, 0x00000000,
// 0x00000000, 0x00000000, 0x00FFFFFF, 0x00FFFFFF
//};
bool getColorFromString(const std::wstring& colorStr, ODRAW::CColor & color)
{
bool bSet = false;
int RGB = 0;
std::wstring str;
size_t pos = colorStr.find(L"["); //"buttonFace [67]" "#9c0 [50]"
if (pos != std::wstring::npos)
{
size_t pos1 = colorStr.find(L"]", pos + 1);
if (pos1 != std::wstring::npos)
{
str = colorStr.substr(pos + 1, pos1 - pos - 1);
if (NSStringUtils::IsNumber(str))
{
int index = XmlUtils::GetInteger(str);
if (index < 64)
{
RGB = shemeDefaultColor[index];
bSet = true;
}
}
}
//else if (index < 93)
//{
// RGB = background ? controlPanelColors2[index - 65] : controlPanelColors1[index - 65];
// bSet = true;
//}
}
if (!bSet && colorStr.find(L"#") == 0) // "#9c0 [50]"
{
size_t pos_end = colorStr.find(L" ", 1); //"buttonFace [67]" "#9c0 [50]"
if (pos_end == std::wstring::npos) pos_end = colorStr.length();
if (pos_end == 4)
{
int lColor = XmlUtils::GetColorBGR(colorStr.substr(1, 3));
BYTE lB = ((lColor >> 16) & 0x0F);
BYTE lG = ((lColor >> 20) & 0x0F);
BYTE lR = ((lColor >> 8) & 0x0F);
color.R = ((lR << 4) + lR);
color.G = ((lG << 4) + lG);
color.B = ((lB << 4) + lB);
color.A = 0;
}
else
{
int lColor = XmlUtils::GetColorBGR(colorStr.substr(1, 6));
color.R = (BYTE)(lColor >> 0);
color.G = (BYTE)(lColor >> 8);
color.B = (BYTE)(lColor >> 16);
color.A = 0;
}
RGB = color.GetLONG_RGB();
bSet = true;
}
if (!bSet)
{
pos = colorStr.find(' ');
if (pos == std::wstring::npos)
str = colorStr;
else
str = colorStr.substr(0, pos);
switch (str[0])
{
case 'a':
if (str == L"aliceBlue") { RGB = 0xF0F8FF; bSet = true; break; } // (Alice Blue Preset Color) Specifies a color with RGB value (240,248,255)
else if (str == L"antiqueWhite") { RGB = 0xFAEBD7; bSet = true; break; } // (Antique White Preset Color) Specifies a color with RGB value (250,235,215)
else if (str == L"aqua") { RGB = 0x00FFFF; bSet = true; break; } // (Aqua Preset Color) Specifies a color with RGB value (0,255,255)
else if (str == L"aquamarine") { RGB = 0x7FFFD4; bSet = true; break; } // (Aquamarine Preset Color) Specifies a color with RGB value (127,255,212)
else if (str == L"azure") { RGB = 0xF0FFFF; bSet = true; break; } // (Azure Preset Color) Specifies a color with RGB value (240,255,255)
break;
case 'b':
if (str == L"beige") { RGB = 0xF5F5DC; bSet = true; break; } // (Beige Preset Color) Specifies a color with RGB value (245,245,220)
else if (str == L"bisque") { RGB = 0xFFE4C4; bSet = true; break; } // (Bisque Preset Color) Specifies a color with RGB value (255,228,196)
else if (str == L"black") { RGB = 0x000000; bSet = true; break; } // (Black Preset Color) Specifies a color with RGB value (0,0,0)
else if (str == L"blanchedAlmond") { RGB = 0xFFEBCD; bSet = true; break; } // (Blanched Almond Preset Color) Specifies a color with RGB value (255,235,205)
else if (str == L"blue") { RGB = 0x0000FF; bSet = true; break; } // (Blue Preset Color) Specifies a color with RGB value (0,0,255)
else if (str == L"blueViolet") { RGB = 0x8A2BE2; bSet = true; break; } // (Blue Violet Preset Color) Specifies a color with RGB value (138,43,226)
else if (str == L"brown") { RGB = 0xA52A2A; bSet = true; break; } // (Brown Preset Color) Specifies a color with RGB value (165,42,42)
else if (str == L"burlyWood") { RGB = 0xDEB887; bSet = true; break; } // (Burly Wood Preset Color) Specifies a color with RGB value (222,184,135)
else if (str == L"buttonFace") { RGB = 0xF0F0F0; bSet = true; break; }
else if (str == L"buttonText") { RGB = 0x000000; bSet = true; break; }
break;
case 'c':
if (str == L"cadetBlue") { RGB = 0x5F9EA0; bSet = true; break; } // (Cadet Blue Preset Color) Specifies a color with RGB value (95,158,160)
else if (str == L"chartreuse") { RGB = 0x7FFF00; bSet = true; break; } // (Chartreuse Preset Color) Specifies a color with RGB value (127,255,0)
else if (str == L"chocolate") { RGB = 0xD2691E; bSet = true; break; } // (Chocolate Preset Color) Specifies a color with RGB value (210,105,30)
else if (str == L"coral") { RGB = 0xFF7F50; bSet = true; break; } // (Coral Preset Color) Specifies a color with RGB value (255,127,80)
else if (str == L"cornflowerBlue") { RGB = 0x6495ED; bSet = true; break; } // (Cornflower Blue Preset Color) Specifies a color with RGB value (100,149,237)
else if (str == L"cornsilk") { RGB = 0xFFF8DC; bSet = true; break; } // (Cornsilk Preset Color) Specifies a color with RGB value (255,248,220)
else if (str == L"crimson") { RGB = 0xDC143C; bSet = true; break; } // (Crimson Preset Color) Specifies a color with RGB value (220,20,60)
else if (str == L"cyan") { RGB = 0x00FFFF; bSet = true; break; } // (Cyan Preset Color) Specifies a color with RGB value (0,255,255)
break;
case 'd':
if (str == L"darkBlue") { RGB = 0x00008B; bSet = true; break; } // (Dark Blue Preset Color) Specifies a color with RGB value (0,0,139)
else if (str == L"darkCyan") { RGB = 0x008B8B; bSet = true; break; } // (Dark Cyan Preset Color) Specifies a color with RGB value (0,139,139)
else if (str == L"darkGoldenrod") { RGB = 0xB8860B; bSet = true; break; } // (Dark Goldenrod Preset Color) Specifies a color with RGB value (184,134,11)
else if (str == L"darkGray") { RGB = 0xA9A9A9; bSet = true; break; } // (Dark Gray Preset Color) Specifies a color with RGB value (169,169,169)
else if (str == L"darkGreen") { RGB = 0x006400; bSet = true; break; } // (Dark Green Preset Color) Specifies a color with RGB value (0,100,0)
else if (str == L"darkGrey") { RGB = 0xA9A9A9; bSet = true; break; } // (Dark Gray Preset Color) Specifies a color with RGB value (169,169,169)
else if (str == L"darkKhaki") { RGB = 0xBDB76B; bSet = true; break; } // (Dark Khaki Preset Color) Specifies a color with RGB value (189,183,107)
else if (str == L"darkMagenta") { RGB = 0x8B008B; bSet = true; break; } // (Dark Magenta Preset Color) Specifies a color with RGB value (139,0,139)
else if (str == L"darkOliveGreen") { RGB = 0x556B2F; bSet = true; break; } // (Dark Olive Green Preset Color) Specifies a color with RGB value (85,107,47)
else if (str == L"darkOrange") { RGB = 0xFF8C00; bSet = true; break; } // (Dark Orange Preset Color) Specifies a color with RGB value (255,140,0)
else if (str == L"darkOrchid") { RGB = 0x9932CC; bSet = true; break; } // (Dark Orchid Preset Color) Specifies a color with RGB value (153,50,204)
else if (str == L"darkRed") { RGB = 0x8B0000; bSet = true; break; } // (Dark Red Preset Color) Specifies a color with RGB value (139,0,0)
else if (str == L"darkSalmon") { RGB = 0xE9967A; bSet = true; break; } // (Dark Salmon Preset Color) Specifies a color with RGB value (233,150,122)
else if (str == L"darkSeaGreen") { RGB = 0x8FBC8F; bSet = true; break; } // (Dark Sea Green Preset Color) Specifies a color with RGB value (143,188,143)
else if (str == L"darkSlateBlue") { RGB = 0x483D8B; bSet = true; break; } // (Dark Slate Blue Preset Color) Specifies a color with RGB value (72,61,139)
else if (str == L"darkSlateGray") { RGB = 0x2F4F4F; bSet = true; break; } // (Dark Slate Gray Preset Color) Specifies a color with RGB value (47,79,79)
else if (str == L"darkSlateGrey") { RGB = 0x2F4F4F; bSet = true; break; } // (Dark Slate Gray Preset Color) Specifies a color with RGB value (47,79,79)
else if (str == L"darkTurquoise") { RGB = 0x00CED1; bSet = true; break; } // (Dark Turquoise Preset Color) Specifies a color with RGB value (0,206,209)
else if (str == L"darkViolet") { RGB = 0x9400D3; bSet = true; break; } // (Dark Violet Preset Color) Specifies a color with RGB value (148,0,211)
else if (str == L"deepPink") { RGB = 0xFF1493; bSet = true; break; } // (Deep Pink Preset Color) Specifies a color with RGB value (255,20,147)
else if (str == L"deepSkyBlue") { RGB = 0x00BFFF; bSet = true; break; } // (Deep Sky Blue Preset Color) Specifies a color with RGB value (0,191,255)
else if (str == L"dimGray") { RGB = 0x696969; bSet = true; break; } // (Dim Gray Preset Color) Specifies a color with RGB value (105,105,105)
else if (str == L"dimGrey") { RGB = 0x696969; bSet = true; break; } // (Dim Gray Preset Color) Specifies a color with RGB value (105,105,105)
else if (str == L"dkBlue") { RGB = 0x00008B; bSet = true; break; } // (Dark Blue Preset Color) Specifies a color with RGB value (0,0,139)
else if (str == L"dkCyan") { RGB = 0x008B8B; bSet = true; break; } // (Dark Cyan Preset Color) Specifies a color with RGB value (0,139,139)
else if (str == L"dkGoldenrod") { RGB = 0xB8860B; bSet = true; break; } // (Dark Goldenrod Preset Color) Specifies a color with RGB value (184,134,11)
else if (str == L"dkGray") { RGB = 0xA9A9A9; bSet = true; break; } // (Dark Gray Preset Color) Specifies a color with RGB value (169,169,169)
else if (str == L"dkGreen") { RGB = 0x006400; bSet = true; break; } // (Dark Green Preset Color) Specifies a color with RGB value (0,100,0)
else if (str == L"dkGrey") { RGB = 0xA9A9A9; bSet = true; break; } // (Dark Gray Preset Color) Specifies a color with RGB value (169,169,169)
else if (str == L"dkKhaki") { RGB = 0xBDB76B; bSet = true; break; } // (Dark Khaki Preset Color) Specifies a color with RGB value (189,183,107)
else if (str == L"dkMagenta") { RGB = 0x8B008B; bSet = true; break; } // (Dark Magenta Preset Color) Specifies a color with RGB value (139,0,139)
else if (str == L"dkOliveGreen") { RGB = 0x556B2F; bSet = true; break; } // (Dark Olive Green Preset Color) Specifies a color with RGB value (85,107,47)
else if (str == L"dkOrange") { RGB = 0xFF8C00; bSet = true; break; } // (Dark Orange Preset Color) Specifies a color with RGB value (255,140,0)
else if (str == L"dkOrchid") { RGB = 0x9932CC; bSet = true; break; } // (Dark Orchid Preset Color) Specifies a color with RGB value (153,50,204)
else if (str == L"dkRed") { RGB = 0x8B0000; bSet = true; break; } // (Dark Red Preset Color) Specifies a color with RGB value (139,0,0)
else if (str == L"dkSalmon") { RGB = 0xE9967A; bSet = true; break; } // (Dark Salmon Preset Color) Specifies a color with RGB value (233,150,122)
else if (str == L"dkSeaGreen") { RGB = 0x8FBC8B; bSet = true; break; } // (Dark Sea Green Preset Color) Specifies a color with RGB value (143,188,139)
else if (str == L"dkSlateBlue") { RGB = 0x483D8B; bSet = true; break; } // (Dark Slate Blue Preset Color) Specifies a color with RGB value (72,61,139)
else if (str == L"dkSlateGray") { RGB = 0x2F4F4F; bSet = true; break; } // (Dark Slate Gray Preset Color) Specifies a color with RGB value (47,79,79)
else if (str == L"dkSlateGrey") { RGB = 0x2F4F4F; bSet = true; break; } // (Dark Slate Gray Preset Color) Specifies a color with RGB value (47,79,79)
else if (str == L"dkTurquoise") { RGB = 0x00CED1; bSet = true; break; } // (Dark Turquoise Preset Color) Specifies a color with RGB value (0,206,209)
else if (str == L"dkViolet") { RGB = 0x9400D3; bSet = true; break; } // (Dark Violet Preset Color) Specifies a color with RGB value (148,0,211)
else if (str == L"dodgerBlue") { RGB = 0x1E90FF; bSet = true; break; } // (Dodger Blue Preset Color) Specifies a color with RGB value (30,144,255)
break;
case 'f':
if (str == L"firebrick") { RGB = 0xB22222; bSet = true; break; } // (Firebrick Preset Color) Specifies a color with RGB value (178,34,34)
else if (str == L"floralWhite") { RGB = 0xFFFAF0; bSet = true; break; } // (Floral White Preset Color) Specifies a color with RGB value (255,250,240)
else if (str == L"forestGreen") { RGB = 0x228B22; bSet = true; break; } // (Forest Green Preset Color) Specifies a color with RGB value (34,139,34)
else if (str == L"fuchsia") { RGB = 0xFF00FF; bSet = true; break; } // (Fuchsia Preset Color) Specifies a color with RGB value (255,0,255)
break;
case 'g':
if (str == L"gainsboro") { RGB = 0xDCDCDC; bSet = true; break; } // (Gainsboro Preset Color) Specifies a color with RGB value (220,220,220)
else if (str == L"ghostWhite") { RGB = 0xF8F8FF; bSet = true; break; } // (Ghost White Preset Color) Specifies a color with RGB value (248,248,255)
else if (str == L"gold") { RGB = 0xFFD700; bSet = true; break; } // (Gold Preset Color) Specifies a color with RGB value (255,215,0)
else if (str == L"goldenrod") { RGB = 0xDAA520; bSet = true; break; } // (Goldenrod Preset Color) Specifies a color with RGB value (218,165,32)
else if (str == L"gray") { RGB = 0x808080; bSet = true; break; } // (Gray Preset Color) Specifies a color with RGB value (128,128,128)
else if (str == L"green") { RGB = 0x008000; bSet = true; break; } // (Green Preset Color) Specifies a color with RGB value (0,128,0)
else if (str == L"greenYellow") { RGB = 0xADFF2F; bSet = true; break; } // (Green Yellow Preset Color) Specifies a color with RGB value (173,255,47)
else if (str == L"grey") { RGB = 0x808080; bSet = true; break; } // (Gray Preset Color) Specifies a color with RGB value (128,128,128)
break;
case 'h':
if (str == L"honeydew") { RGB = 0xF0FFF0; bSet = true; break; } // (Honeydew Preset Color) Specifies a color with RGB value (240,255,240)
else if (str == L"hotPink") { RGB = 0xFF69B4; bSet = true; break; } // (Hot Pink Preset Color) Specifies a color with RGB value (255,105,180)
break;
case 'i':
if (str == L"indianRed") { RGB = 0xCD5C5C; bSet = true; break; } // (Indian Red Preset Color) Specifies a color with RGB value (205,92,92)
else if (str == L"indigo") { RGB = 0x4B0082; bSet = true; break; } // (Indigo Preset Color) Specifies a color with RGB value (75,0,130)
else if (str == L"ivory") { RGB = 0xFFFFF0; bSet = true; break; } // (Ivory Preset Color) Specifies a color with RGB value (255,255,240)
else if (str == L"infoText") { RGB = 0x000000; bSet = true; break; }
break;
case 'k':
if (str == L"khaki") { RGB = 0xF0E68C; bSet = true; break; } // (Khaki Preset Color) Specifies a color with RGB value (240,230,140)
break;
case 'l':
if (str == L"lavender") { RGB = 0xE6E6FA; bSet = true; break; } // (Lavender Preset Color) Specifies a color with RGB value (230,230,250)
else if (str == L"lavenderBlush") { RGB = 0xFFF0F5; bSet = true; break; } // (Lavender Blush Preset Color) Specifies a color with RGB value (255,240,245)
else if (str == L"lawnGreen") { RGB = 0x7CFC00; bSet = true; break; } // (Lawn Green Preset Color) Specifies a color with RGB value (124,252,0)
else if (str == L"lemonChiffon") { RGB = 0xFFFACD; bSet = true; break; } // (Lemon Chiffon Preset Color) Specifies a color with RGB value (255,250,205)
else if (str == L"lightBlue") { RGB = 0xADD8E6; bSet = true; break; } // (Light Blue Preset Color) Specifies a color with RGB value (173,216,230)
else if (str == L"lightCoral") { RGB = 0xF08080; bSet = true; break; } // (Light Coral Preset Color) Specifies a color with RGB value (240,128,128)
else if (str == L"lightCyan") { RGB = 0xE0FFFF; bSet = true; break; } // (Light Cyan Preset Color) Specifies a color with RGB value (224,255,255)
else if (str == L"lightGoldenrodYellow") { RGB = 0xFAFAD2; bSet = true; break; } // (Light Goldenrod Color) Specifies a color with RGB value (250,250,210)
else if (str == L"lightGray") { RGB = 0xD3D3D3; bSet = true; break; } // (Light Gray Preset Color) Specifies a color with RGB value (211,211,211)
else if (str == L"lightGreen") { RGB = 0x90EE90; bSet = true; break; } // (Light Green Preset Color) Specifies a color with RGB value (144,238,144)
else if (str == L"lightGrey") { RGB = 0xD3D3D3; bSet = true; break; } // (Light Gray Preset Color) Specifies a color with RGB value (211,211,211)
else if (str == L"lightPink") { RGB = 0xFFB6C1; bSet = true; break; } // (Light Pink Preset Color) Specifies a color with RGB value (255,182,193)
else if (str == L"lightSalmon") { RGB = 0xFFA07A; bSet = true; break; } // (Light Salmon Preset Color) Specifies a color with RGB value (255,160,122)
else if (str == L"lightSeaGreen") { RGB = 0x20B2AA; bSet = true; break; } // (Light Sea Green Preset Color) Specifies a color with RGB value (32,178,170)
else if (str == L"lightSkyBlue") { RGB = 0x87CEFA; bSet = true; break; } // (Light Sky Blue Preset Color) Specifies a color with RGB value (135,206,250)
else if (str == L"lightSlateGray") { RGB = 0x778899; bSet = true; break; } // (Light Slate Gray Preset Color) Specifies a color with RGB value (119,136,153)
else if (str == L"lightSlateGrey") { RGB = 0x778899; bSet = true; break; } // (Light Slate Gray Preset Color) Specifies a color with RGB value (119,136,153)
else if (str == L"lightSteelBlue") { RGB = 0xB0C4DE; bSet = true; break; } // (Light Steel Blue Preset Color) Specifies a color with RGB value (176,196,222)
else if (str == L"lightYellow") { RGB = 0xFFFFE0; bSet = true; break; } // (Light Yellow Preset Color) Specifies a color with RGB value (255,255,224)
else if (str == L"lime") { RGB = 0x00FF00; bSet = true; break; } // (Lime Preset Color) Specifies a color with RGB value (0,255,0)
else if (str == L"limeGreen") { RGB = 0x32CD32; bSet = true; break; } // (Lime Green Preset Color) Specifies a color with RGB value (50,205,50)
else if (str == L"linen") { RGB = 0xFAF0E6; bSet = true; break; } // (Linen Preset Color) Specifies a color with RGB value (250,240,230)
else if (str == L"ltBlue") { RGB = 0xADD8E6; bSet = true; break; } // (Light Blue Preset Color) Specifies a color with RGB value (173,216,230)
else if (str == L"ltCoral") { RGB = 0xF08080; bSet = true; break; } // (Light Coral Preset Color) Specifies a color with RGB value (240,128,128)
else if (str == L"ltCyan") { RGB = 0xE0FFFF; bSet = true; break; } // (Light Cyan Preset Color) Specifies a color with RGB value (224,255,255)
else if (str == L"ltGoldenrodYellow") { RGB = 0xFAFA78; bSet = true; break; } // (Light Goldenrod Color) Specifies a color with RGB value (250,250,120)
else if (str == L"ltGray") { RGB = 0xD3D3D3; bSet = true; break; } // (Light Gray Preset Color) Specifies a color with RGB value (211,211,211)
else if (str == L"ltGreen") { RGB = 0x90EE90; bSet = true; break; } // (Light Green Preset Color) Specifies a color with RGB value (144,238,144)
else if (str == L"ltGrey") { RGB = 0xD3D3D3; bSet = true; break; } // (Light Gray Preset Color) Specifies a color with RGB value (211,211,211)
else if (str == L"ltPink") { RGB = 0xFFB6C1; bSet = true; break; } // (Light Pink Preset Color) Specifies a color with RGB value (255,182,193)
else if (str == L"ltSalmon") { RGB = 0xFFA07A; bSet = true; break; } // (Light Salmon Preset Color) Specifies a color with RGB value (255,160,122)
else if (str == L"ltSeaGreen") { RGB = 0x20B2AA; bSet = true; break; } // (Light Sea Green Preset Color) Specifies a color with RGB value (32,178,170)
else if (str == L"ltSkyBlue") { RGB = 0x87CEFA; bSet = true; break; } // (Light Sky Blue Preset Color) Specifies a color with RGB value (135,206,250)
else if (str == L"ltSlateGray") { RGB = 0x778899; bSet = true; break; } // (Light Slate Gray Preset Color) Specifies a color with RGB value (119,136,153)
else if (str == L"ltSlateGrey") { RGB = 0x778899; bSet = true; break; } // (Light Slate Gray Preset Color) Specifies a color with RGB value (119,136,153)
else if (str == L"ltSteelBlue") { RGB = 0xB0C4DE; bSet = true; break; } // (Light Steel Blue Preset Color) Specifies a color with RGB value (176,196,222)
else if (str == L"ltYellow") { RGB = 0xFFFFE0; bSet = true; break; } // (Light Yellow Preset Color) Specifies a color with RGB value (255,255,224)
break;
case 'm':
if (str == L"magenta") { RGB = 0xFF00FF; bSet = true; break; } // (Magenta Preset Color) Specifies a color with RGB value (255,0,255)
else if (str == L"maroon") { RGB = 0x800000; bSet = true; break; } // (Maroon Preset Color) Specifies a color with RGB value (128,0,0)
else if (str == L"medAquamarine") { RGB = 0x66CDAA; bSet = true; break; } // (Medium Aquamarine Preset Color)Specifies a color with RGB value (102,205,170)
else if (str == L"medBlue") { RGB = 0x0000CD; bSet = true; break; } // (Medium Blue Preset Color) Specifies a color with RGB value (0,0,205)
else if (str == L"mediumAquamarine") { RGB = 0x66CDAA; bSet = true; break; } // (Medium Aquamarine Color) Specifies a color with RGB value (102,205,170)
else if (str == L"mediumBlue") { RGB = 0x0000CD; bSet = true; break; } // (Medium Blue Preset Color) Specifies a color with RGB value (0,0,205)
else if (str == L"mediumOrchid") { RGB = 0xBA55D3; bSet = true; break; } // (Medium Orchid Preset Color) Specifies a color with RGB value (186,85,211)
else if (str == L"mediumPurple") { RGB = 0x9370DB; bSet = true; break; } // (Medium Purple Preset Color) Specifies a color with RGB value (147,112,219)
else if (str == L"mediumSeaGreen") { RGB = 0x3CB371; bSet = true; break; } // (Medium Sea Green Preset Color) Specifies a color with RGB value (60,179,113)
else if (str == L"mediumSlateBlue") { RGB = 0x7B68EE; bSet = true; break; } // (Medium Slate Blue Preset Color)Specifies a color with RGB value (123,104,238)
else if (str == L"mediumSpringGreen") { RGB = 0x00FA9A; bSet = true; break; } // (Medium Spring Color) Specifies a color with RGB value (0,250,154)
else if (str == L"mediumTurquoise") { RGB = 0x48D1CC; bSet = true; break; } // (Medium Turquoise Preset Color) Specifies a color with RGB value (72,209,204)
else if (str == L"mediumVioletRed") { RGB = 0xC71585; bSet = true; break; } // (Medium Violet Red Preset Color)Specifies a color with RGB value (199,21,133)
else if (str == L"medOrchid") { RGB = 0xBA55D3; bSet = true; break; } // (Medium Orchid Preset Color) Specifies a color with RGB value (186,85,211)
else if (str == L"medPurple") { RGB = 0x9370DB; bSet = true; break; } // (Medium Purple Preset Color) Specifies a color with RGB value (147,112,219)
else if (str == L"medSeaGreen") { RGB = 0x3CB371; bSet = true; break; } // (Medium Sea Green Preset Color) Specifies a color with RGB value (60,179,113)
else if (str == L"medSlateBlue") { RGB = 0x7B68EE; bSet = true; break; } // (Medium Slate Blue Preset Color)Specifies a color with RGB value (123,104,238)
else if (str == L"medSpringGreen") { RGB = 0x00FA9A; bSet = true; break; } // (Medium Spring Preset Color) Specifies a color with RGB value (0,250,154)
else if (str == L"medTurquoise") { RGB = 0x48D1CC; bSet = true; break; } // (Medium Turquoise Preset Color) Specifies a color with RGB value (72,209,204)
else if (str == L"medVioletRed") { RGB = 0xC71585; bSet = true; break; } // (Medium Violet Red Preset Color)Specifies a color with RGB value (199,21,133)
else if (str == L"midnightBlue") { RGB = 0x191970; bSet = true; break; } // (Midnight Blue Preset Color) Specifies a color with RGB value (25,25,112)
else if (str == L"mintCream") { RGB = 0xF5FFFA; bSet = true; break; } // (Mint Cream Preset Color) Specifies a color with RGB value (245,255,250)
else if (str == L"mistyRose") { RGB = 0xFFE4FF; bSet = true; break; } // (Misty Rose Preset Color) Specifies a color with RGB value (255,228,225)
else if (str == L"moccasin") { RGB = 0xFFE4B5; bSet = true; break; } // (Moccasin Preset Color) Specifies a color with RGB value (255,228,181)
else if (str == L"menuText") { RGB = 0x000000; bSet = true; break; }
break;
case 'n':
if (str == L"navajoWhite") { RGB = 0xFFDEAD; bSet = true; break; } // (Navajo White Preset Color) Specifies a color with RGB value (255,222,173)
else if (str == L"navy") { RGB = 0x000080; bSet = true; break; } // (Navy Preset Color) Specifies a color with RGB value (0,0,128)
break;
case 'o':
if (str == L"oldLace") { RGB = 0xFDF5E6; bSet = true; break; } // (Old Lace Preset Color) Specifies a color with RGB value (253,245,230)
else if (str == L"olive") { RGB = 0x808000; bSet = true; break; } // (Olive Preset Color) Specifies a color with RGB value (128,128,0)
else if (str == L"oliveDrab") { RGB = 0x6B8E23; bSet = true; break; } // (Olive Drab Preset Color) Specifies a color with RGB value (107,142,35)
else if (str == L"orange") { RGB = 0xFFA500; bSet = true; break; } // (Orange Preset Color) Specifies a color with RGB value (255,165,0)
else if (str == L"orangeRed") { RGB = 0xFF4500; bSet = true; break; } // (Orange Red Preset Color) Specifies a color with RGB value (255,69,0)
else if (str == L"orchid") { RGB = 0xDA70D6; bSet = true; break; } // (Orchid Preset Color) Specifies a color with RGB value (218,112,214)
break;
case 'p':
if (str == L"paleGoldenrod") { RGB = 0xEEE8AA; bSet = true; break; } // (Pale Goldenrod Preset Color) Specifies a color with RGB value (238,232,170)
else if (str == L"paleGreen") { RGB = 0x98FB98; bSet = true; break; } // (Pale Green Preset Color) Specifies a color with RGB value (152,251,152)
else if (str == L"paleTurquoise") { RGB = 0xAFEEEE; bSet = true; break; } // (Pale Turquoise Preset Color) Specifies a color with RGB value (175,238,238)
else if (str == L"paleVioletRed") { RGB = 0xDB7093; bSet = true; break; } // (Pale Violet Red Preset Color) Specifies a color with RGB value (219,112,147)
else if (str == L"papayaWhip") { RGB = 0xFFEFD5; bSet = true; break; } // (Papaya Whip Preset Color) Specifies a color with RGB value (255,239,213)
else if (str == L"peachPuff") { RGB = 0xFFDAB9; bSet = true; break; } // (Peach Puff Preset Color) Specifies a color with RGB value (255,218,185)
else if (str == L"peru") { RGB = 0xCD853F; bSet = true; break; } // (Peru Preset Color) Specifies a color with RGB value (205,133,63)
else if (str == L"pink") { RGB = 0xFFC0CB; bSet = true; break; } // (Pink Preset Color) Specifies a color with RGB value (255,192,203)
else if (str == L"plum") { RGB = 0xD3A0D3; bSet = true; break; } // (Plum Preset Color) Specifies a color with RGB value (221,160,221)
else if (str == L"powderBlue") { RGB = 0xB0E0E6; bSet = true; break; } // (Powder Blue Preset Color) Specifies a color with RGB value (176,224,230)
else if (str == L"purple") { RGB = 0x800080; bSet = true; break; } // (Purple Preset Color) Specifies a color with RGB value (128,0,128)
break;
case 'r':
if (str == L"red") { RGB = 0xFF0000; bSet = true; break; } // (Red Preset Color) Specifies a color with RGB value (255,0,0)
else if (str == L"rosyBrown") { RGB = 0xBC8F8F; bSet = true; break; } // (Rosy Brown Preset Color) Specifies a color with RGB value (188,143,143)
else if (str == L"royalBlue") { RGB = 0x4169E1; bSet = true; break; } // (Royal Blue Preset Color) Specifies a color with RGB value (65,105,225)
break;
case 's':
if (str == L"saddleBrown") { RGB = 0x8B4513; bSet = true; break; } // (Saddle Brown Preset Color) Specifies a color with RGB value (139,69,19)
else if (str == L"salmon") { RGB = 0xFA8072; bSet = true; break; } // (Salmon Preset Color) Specifies a color with RGB value (250,128,114)
else if (str == L"sandyBrown") { RGB = 0xF4A460; bSet = true; break; } // (Sandy Brown Preset Color) Specifies a color with RGB value (244,164,96)
else if (str == L"seaGreen") { RGB = 0x2E8B57; bSet = true; break; } // (Sea Green Preset Color) Specifies a color with RGB value (46,139,87)
else if (str == L"seaShell") { RGB = 0xFFF5EE; bSet = true; break; } // (Sea Shell Preset Color) Specifies a color with RGB value (255,245,238)
else if (str == L"sienna") { RGB = 0xA0522D; bSet = true; break; } // (Sienna Preset Color) Specifies a color with RGB value (160,82,45)
else if (str == L"silver") { RGB = 0xC0C0C0; bSet = true; break; } // (Silver Preset Color) Specifies a color with RGB value (192,192,192)
else if (str == L"skyBlue") { RGB = 0x87CEEB; bSet = true; break; } // (Sky Blue Preset Color) Specifies a color with RGB value (135,206,235)
else if (str == L"slateBlue") { RGB = 0x6A5AEB; bSet = true; break; } // (Slate Blue Preset Color) Specifies a color with RGB value (106,90,205)
else if (str == L"slateGray") { RGB = 0x708090; bSet = true; break; } // (Slate Gray Preset Color) Specifies a color with RGB value (112,128,144)
else if (str == L"slateGrey") { RGB = 0x708090; bSet = true; break; } // (Slate Gray Preset Color) Specifies a color with RGB value (112,128,144)
else if (str == L"snow") { RGB = 0xFFFAFA; bSet = true; break; } // (Snow Preset Color) Specifies a color with RGB value (255,250,250)
else if (str == L"springGreen") { RGB = 0x00FF7F; bSet = true; break; } // (Spring Green Preset Color) Specifies a color with RGB value (0,255,127)
else if (str == L"steelBlue") { RGB = 0x4682B4; bSet = true; break; } // (Steel Blue Preset Color) Specifies a color with RGB value (70,130,180)
break;
case 't':
if (str == L"tan") { RGB = 0xD2B48C; bSet = true; break; } // (Tan Preset Color) Specifies a color with RGB value (210,180,140)
else if (str == L"teal") { RGB = 0x008080; bSet = true; break; } // (Teal Preset Color) Specifies a color with RGB value (0,128,128)
else if (str == L"thistle") { RGB = 0xD8BFD8; bSet = true; break; } // (Thistle Preset Color) Specifies a color with RGB value (216,191,216)
else if (str == L"tomato") { RGB = 0xFF7347; bSet = true; break; } // (Tomato Preset Color) Specifies a color with RGB value (255,99,71)
else if (str == L"turquoise") { RGB = 0x40E0D0; bSet = true; break; } // (Turquoise Preset Color) Specifies a color with RGB value (64,224,208)
break;
case 'v':
if (str == L"violet") { RGB = 0xEE82EE; bSet = true; break; } // (Violet Preset Color) Specifies a color with RGB value (238,130,238)
break;
case 'w':
if (str == L"wheat") { RGB = 0xF5DEB3; bSet = true; break; } // (Wheat Preset Color) Specifies a color with RGB value (245,222,179)
else if (str == L"white") { RGB = 0xFFFFFF; bSet = true; break; } // (White Preset Color) Specifies a color with RGB value (255,255,255)
else if (str == L"whiteSmoke") { RGB = 0xF5F5F5; bSet = true; break; } // (White Smoke Preset Color) Specifies a color with RGB value (245,245,245)
else if (str == L"windowsText") { RGB = 0x000000; bSet = true; break; } // (White Smoke Preset Color) Specifies a color with RGB value (245,245,245)
break;
case 'y':
if (str == L"yellow") { RGB = 0xFFFF00; bSet = true; break; } // (Yellow Preset Color) Specifies a color with RGB value (255,255,0)
else if (str == L"yellowGreen") { RGB = 0x9ACD32; bSet = true; break; } // (Yellow Green Preset Color) Specifies a color with RGB value (154,205,50)
break;
}
}
if (bSet)
{
color.R = (BYTE)(RGB >> 16);
color.G = (BYTE)(RGB >> 8);
color.B = (BYTE)(RGB);
color.A = 0;
}
return bSet;
}
}
namespace PPTX
{
CStringTrimmer::CStringTrimmer()
{
m_Separator = (wchar_t)' ';
}
CStringTrimmer::~CStringTrimmer()
{
}
void CStringTrimmer::LoadFromString(std::wstring& strParams)
{
// let's not create performance bottlenecks - write without Mid, Find to have only one pass
wchar_t* pData = (wchar_t*)strParams.c_str();
int nCount = (int) strParams.length();
int nPosition = 0;
wchar_t* pDataMem = pData;
int nCurPosition = 0;
while (nPosition <= nCount)
{
if (nPosition == nCount || (pData[nPosition] == m_Separator))
{
int nLen = nPosition - nCurPosition;
if (nLen == 0)
{
m_arParams.push_back(L"");
}
else
{
m_arParams.push_back(strParams.substr(nCurPosition, nLen));
}
nCurPosition = nPosition + 1;
}
++nPosition;
}
}
double CStringTrimmer::GetParameter(int nIndex, double dDefault)
{
if (nIndex < 0 || nIndex >= (int)m_arParams.size())
return dDefault;
if (m_arParams[nIndex].length() == 0)
return dDefault;
SimpleTypes::CPoint parserPoint;
return parserPoint.FromString(m_arParams[nIndex]);
}
CCSS::CCSS()
{
Clear();
}
CCSS::~CCSS()
{
}
void CCSS::Clear()
{
m_strClassName = L"";
m_mapSettings.clear();
}
void CCSS::LoadFromString(std::wstring& strParams)
{
Clear();
// let's not create performance bottlenecks - write without Mid, Find to have only one pass
wchar_t* pData = (wchar_t*)strParams.c_str();
int nCount = (int) strParams.length();
int nPosition = 0;
wchar_t* pDataMem = pData;
while ((nPosition < nCount) && ((wchar_t(' ') == *pDataMem) || (wchar_t('\n') == *pDataMem) || (wchar_t('.') == *pDataMem)))
{
++nPosition;
++pDataMem;
}
int nPosNameStart = nPosition;
while ((nPosition < nCount) && (wchar_t(' ') != *pDataMem) && (wchar_t('{') != *pDataMem))
{
++nPosition;
++pDataMem;
}
m_strClassName = strParams.substr(nPosNameStart, nPosition - nPosNameStart);
while (true)
{
++nPosition;
++pDataMem;
// skip spaces
while ((nPosition < nCount) && ((wchar_t(' ') == *pDataMem) || (wchar_t('{') == *pDataMem)))
{
++nPosition;
++pDataMem;
}
int nPosOld = nPosition;
// find setting name
while ((nPosition < nCount) && (wchar_t(':') != *pDataMem))
{
++nPosition;
++pDataMem;
}
if (nPosOld == nPosition)
{
// no settings found
break;
}
std::wstring strName = strParams.substr(nPosOld, nPosition - nPosOld);
// remove ':'
++nPosition;
++pDataMem;
// skip setting spaces
while ((nPosition < nCount) && (wchar_t(' ') == *pDataMem))
{
++nPosition;
++pDataMem;
}
nPosOld = nPosition;
// skip setting spaces
while ((nPosition < nCount) && (wchar_t(';') != *pDataMem) && (wchar_t('}') != *pDataMem))
{
++nPosition;
++pDataMem;
}
std::wstring strValue = strParams.substr(nPosOld, nPosition - nPosOld);
if (m_mapSettings.find(strName) == m_mapSettings.end())
{
m_mapSettings.insert(std::make_pair(strName, strValue));
}
else
{
m_mapSettings[strName] += L"," + strValue;
}
}
}
void CCSS::LoadFromString2(std::wstring& strParams)
{
Clear();
// let's not create performance bottlenecks - write without Mid, Find to have only one pass
wchar_t* pData = (wchar_t*)strParams.c_str();
int nCount = (int) strParams.length();
int nPosition = 0;
wchar_t* pDataMem = pData;
m_strClassName = L"";
while (true)
{
// skip spaces
while ((nPosition < nCount) && ((wchar_t(' ') == *pDataMem) || (wchar_t('{') == *pDataMem) || (wchar_t(';') == *pDataMem)))
{
++nPosition;
++pDataMem;
}
int nPosOld = nPosition;
// find setting name
while ((nPosition < nCount) && (wchar_t(':') != *pDataMem))
{
++nPosition;
++pDataMem;
}
if (nPosOld == nPosition)
{
// no settings found
break;
}
std::wstring strName = strParams.substr(nPosOld, nPosition - nPosOld);
// remove ':'
++nPosition;
++pDataMem;
// skip setting spaces
while ((nPosition < nCount) && (wchar_t(' ') == *pDataMem))
{
++nPosition;
++pDataMem;
}
nPosOld = nPosition;
// skip setting spaces
while ((nPosition < nCount) && (wchar_t(';') != *pDataMem) && (wchar_t('}') != *pDataMem))
{
++nPosition;
++pDataMem;
}
std::wstring strValue = strParams.substr(nPosOld, nPosition - nPosOld);
if (pData[nPosOld] == WCHAR('.'))
strValue = (L"0" + strValue);
if (m_mapSettings.find(strName) == m_mapSettings.end())
{
m_mapSettings.insert(std::make_pair(strName, strValue));
}
else
{
m_mapSettings[strName] += L"," + strValue;
}
}
}
CStylesCSS::CStylesCSS() : m_arStyles()
{
}
CStylesCSS::~CStylesCSS()
{
}
void CStylesCSS::Clear()
{
m_arStyles.clear();
}
void CStylesCSS::LoadStyles(std::wstring& strParams)
{
Clear();
wchar_t* pData = (wchar_t*)strParams.c_str();
int nCount = (int) strParams.length();
int nPosition = 0;
int nPositionOld = 0;
wchar_t* pDataMem = pData;
while (nPosition < nCount)
{
if (*pDataMem == wchar_t('}'))
{
std::wstring strTemp = strParams.substr(nPositionOld, nPosition - nPositionOld + 1);
CCSS elm;
m_arStyles.push_back(elm);
m_arStyles.back().LoadFromString(strTemp);
nPositionOld = nPosition + 1;
}
++nPosition;
++pDataMem;
}
}
}
CSpTreeElemProps::CSpTreeElemProps()
{
X = 0;
Y = 0;
Width = 0;
Height = 0;
IsTop = true;
}
CElementProps::CElementProps() : m_Properties()
{
}
CElementProps::~CElementProps()
{
FinalRelease();
}
void CElementProps::FinalRelease()
{
m_Properties.clear();
}
HRESULT CElementProps::GetProperty(LONG lId, ASC_VARIANT* pProp)
{
if (NULL == pProp)
return S_FALSE;
std::map<LONG, ASC_VARIANT>::iterator pFind = m_Properties.find(lId);
if (m_Properties.end() == pFind)
return S_FALSE;
bool bIsSupportProp = CopyProperty(*pProp, pFind->second);
if (!bIsSupportProp)
{
return S_FALSE;
}
return S_OK;
}
HRESULT CElementProps::SetProperty(LONG lId, ASC_VARIANT prop)
{
ASC_VARIANT var;
bool bIsSupportProp = CopyProperty(var, prop);
if (!bIsSupportProp)
return S_FALSE;
m_Properties.insert(std::pair<LONG, ASC_VARIANT>(lId, var));
return S_OK;
}
bool CElementProps::CopyProperty(ASC_VARIANT& oDst, const ASC_VARIANT& oSrc)
{
oDst.vt = oSrc.vt;
switch (oDst.vt)
{
case ASC_VT_I4:
{
oDst.lVal = oSrc.lVal;
break;
}
case ASC_VT_R8:
{
oDst.dblVal = oSrc.dblVal;
break;
}
case ASC_VT_STR:
{
oDst.strVal = oSrc.strVal;
break;
}
default:
return false;
}
return true;
}
namespace NSBinPptxRW
{
CDrawingConverter::CElement::CElement()
{
m_pElement = NULL;
m_pProps = NULL;
}
CDrawingConverter::CElement::~CElement()
{
RELEASEOBJECT(m_pElement);
RELEASEOBJECT(m_pProps);
}
CDrawingConverter::CElement& CDrawingConverter::CElement::operator=(const CDrawingConverter::CElement& oSrc)
{
m_pElement = oSrc.m_pElement;
m_pProps = oSrc.m_pProps;
return *this;
}
CDrawingConverter::CElement::CElement(const CElement& oSrc)
{
*this = oSrc;
}
CDrawingConverter::CDrawingConverter()
{
m_nCurrentIndexObject = 0;
m_lNextId = 1;
m_lCurrentObjectTop = 0;
m_pOOXToVMLRenderer = NULL;
m_bIsUseConvertion2007 = true;
m_pBinaryWriter = new NSBinPptxRW::CBinaryFileWriter();
m_pBinaryReader = new NSBinPptxRW::CBinaryFileReader();
m_pImageManager = new NSBinPptxRW::CImageManager2();
m_pXmlWriter = new NSBinPptxRW::CXmlWriter();
m_pTheme = new NSCommon::smart_ptr<PPTX::Theme>();
m_pClrMap = new NSCommon::smart_ptr<PPTX::Logic::ClrMap>;
}
CDrawingConverter::~CDrawingConverter()
{
Clear();
RELEASEOBJECT(m_pOOXToVMLRenderer);
RELEASEOBJECT(m_pBinaryWriter);
RELEASEOBJECT(m_pBinaryReader);
RELEASEOBJECT(m_pImageManager);
RELEASEOBJECT(m_pXmlWriter);
RELEASEOBJECT(m_pTheme);
RELEASEOBJECT(m_pClrMap);
}
void CDrawingConverter::SetDocxSerializer(BinDocxRW::CDocxSerializer* pDocxSerializer)
{
m_pBinaryWriter->ClearNoAttack();
m_pBinaryWriter->m_pCommon->m_pMediaManager->Clear();
m_pBinaryWriter->m_pDocxSerializer = pDocxSerializer;
m_pBinaryReader->m_pDocxSerializer = pDocxSerializer;
m_lNextId = 1;
m_pImageManager->m_nDocumentType = m_pBinaryReader->m_nDocumentType = XMLWRITER_DOC_TYPE_DOCX;
}
void CDrawingConverter::SetSrcPath(const std::wstring& sPath, int nDocType)
{
OOX::CPath path(sPath);
m_pBinaryReader->m_pRels->m_pManager = m_pImageManager;
m_pBinaryReader->m_strFolder = path.GetPath();
m_pImageManager->m_nDocumentType = nDocType;
}
void CDrawingConverter::SetDstPath(const std::wstring& sPath)
{
m_pImageManager->SetDstFolder(sPath);
}
void CDrawingConverter::SetTempPath(const std::wstring& sPath)
{
m_pBinaryWriter->m_pCommon->m_pMediaManager->m_strTempMedia = sPath;
}
std::wstring CDrawingConverter::GetTempPath()
{
return ((m_pBinaryWriter) && (m_pBinaryWriter->m_pCommon) && (m_pBinaryWriter->m_pCommon->m_pMediaManager)) ? m_pBinaryWriter->m_pCommon->m_pMediaManager->m_strTempMedia : L"";
}
void CDrawingConverter::SetEmbedDstPath(const std::wstring& sPath)
{
m_pImageManager->SetDstEmbed(sPath);
NSDirectory::CreateDirectory(sPath);
}
void CDrawingConverter::SetMediaDstPath(const std::wstring& sPath)
{
m_pBinaryWriter->m_pCommon->m_pMediaManager->m_strDstMedia = sPath;
}
void CDrawingConverter::Clear()
{
m_mapShapeTypes.clear();
m_mapBinDatas.clear();
}
void CDrawingConverter::AddBinData(XmlUtils::CXmlNode& oNode)
{
std::wstring name = oNode.GetAttribute(L"w:name");
if (name.empty()) return;
nullable<OOX::Logic::CBinData> data(oNode);
m_mapBinDatas.insert(std::make_pair(name, data));
}
void CDrawingConverter::AddShapeType(XmlUtils::CXmlNode& oNode)
{
std::wstring strId = oNode.GetAttribute(L"id");
if (strId.empty())
{
strId = oNode.GetAttribute(L"type");
if (!strId.empty() && strId[0] == (wchar_t)('#'))
{
strId = strId.substr(1);
}
}
if (strId.empty()) return;
//if (m_mapShapeTypes.find(strId) == m_mapShapeTypes.end())//?? with overwriting ???
{
CPPTShape* pShape = new CPPTShape();
pShape->m_bIsShapeType = true;
pShape->LoadFromXMLShapeType(oNode);
CShapePtr pS = CShapePtr(new CShape(NSBaseShape::unknown, 0));
pS->setBaseShape(CBaseShapePtr(pShape));
LoadCoordSize(oNode, pS);
m_mapShapeTypes.insert(std::make_pair(strId, pS));
}
}
void CDrawingConverter::AddShapeType(const std::wstring& bsXml)
{
std::wstring strXml = L"<main ";
strXml += L"\
xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" \
xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" \
xmlns:o=\"urn:schemas-microsoft-com:office:office\" \
xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" \
xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" \
xmlns:v=\"urn:schemas-microsoft-com:vml\" \
xmlns:ve=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" \
xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" \
xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" \
xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" \
xmlns:w10=\"urn:schemas-microsoft-com:office:word\" \
xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" \
xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" \
xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" \
xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" \
xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" \
xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" \
xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" \
xmlns:a14=\"http://schemas.microsoft.com/office/drawing/2010/main\" \
xmlns:pic=\"http://schemas.openxmlformats.org/drawingml/2006/picture\"";
strXml += L">";
strXml += bsXml;
strXml += L"</main>";
XmlUtils::CXmlNode oNode;
oNode.FromXmlString(strXml);
if (oNode.IsValid())
{
XmlUtils::CXmlNode oNodeST = oNode.ReadNodeNoNS(L"shapetype");
AddShapeType(oNodeST);
}
}
bool CDrawingConverter::AddObject(const std::wstring& bsXml, std::wstring* pMainProps)
{
std::wstring strXml = _start_xml_object + bsXml + _end_xml_object;
m_pBinaryWriter->m_pCommon->CheckFontPicker();
++m_lCurrentObjectTop;
bool bResult = ParceObject(strXml, pMainProps);
--m_lCurrentObjectTop;
return bResult;
}
void CDrawingConverter::ConvertVml(const std::wstring& sXml, std::vector<nullable<PPTX::Logic::SpTreeElem>> &elements, NSCommon::nullable<OOX::WritingElement>& anchor)
{
std::wstring strXml = _start_xml_object + sXml + _end_xml_object;
XmlUtils::CXmlNode oMainNode;
if (!oMainNode.FromXmlString(strXml))
return;
std::vector<XmlUtils::CXmlNode> oNodes;
if (!oMainNode.GetNodes(L"*", oNodes))
return;
std::wstring* pMainProps = NULL;
for (size_t i = 0; i < oNodes.size(); ++i)
{
XmlUtils::CXmlNode& oParseNode = oNodes[i];
std::wstring strFullName = oParseNode.GetName();
std::wstring strNS = XmlUtils::GetNamespace(strFullName);
std::wstring strName = XmlUtils::GetNameNoNS(strFullName);
while (true)
{
if (strName == L"background")
{
nullable<PPTX::Logic::SpTreeElem> elem;
elem.Init();
ConvertShape(elem.GetPointer(), oParseNode, pMainProps, false);
elements.push_back(elem);
break;
}
else if (strName == L"pict" || strName == L"object")
{
//shape type first
XmlUtils::CXmlNode oNodeST;
if (oParseNode.GetNode(L"v:shapetype", oNodeST))
{
AddShapeType(oNodeST);
}
std::vector<XmlUtils::CXmlNode> oChilds;
if (oParseNode.GetNodes(L"*", oChilds))
{
size_t lChildsCount = oChilds.size();
bool bIsFound = false;
PPTX::Logic::COLEObject* pOle = NULL;
nullable<PPTX::Logic::SpTreeElem> pElem;
for (LONG k = 0; k < lChildsCount; k++)
{
XmlUtils::CXmlNode & oNodeP = oChilds[k];
std::wstring strNameP = XmlUtils::GetNameNoNS(oNodeP.GetName());
if (L"shape" == strNameP ||
L"rect" == strNameP ||
L"oval" == strNameP ||
L"line" == strNameP ||
L"background" == strNameP ||
L"roundrect" == strNameP ||
L"image" == strNameP ||
L"polyline" == strNameP)
{
if (false == pElem.IsInit())
{
pElem = new PPTX::Logic::SpTreeElem;
ConvertShape(pElem.GetPointer(), oNodeP, pMainProps, true);
}
}
else if (L"OLEObject" == strNameP || L"objectEmbed" == strNameP)
{
pOle = new PPTX::Logic::COLEObject();
pOle->fromXML(oNodeP);
}
else if (L"binData" == strNameP)
{
AddBinData(oNodeP);
}
else if (L"group" == strNameP)
{
if (false == pElem.IsInit())
{
pElem = new PPTX::Logic::SpTreeElem;
ConvertGroup(pElem.GetPointer(), oNodeP, pMainProps, true);
}
}
else if (L"drawing" == strNameP)
{
if (false == pElem.IsInit())
{
pElem = new PPTX::Logic::SpTreeElem;
ConvertDrawing(pElem.GetPointer(), oNodeP, pMainProps, true);
}
}
else
{
continue;
}
if (bIsFound)
break;
}
if (pElem.IsInit() && NULL != pOle && pOle->m_sProgId.IsInit() && (pOle->m_oId.IsInit() || pOle->m_OleObjectFile.IsInit()))
{
PPTX::Logic::Pic* pPicture = dynamic_cast<PPTX::Logic::Pic*>(pElem->GetElem().operator ->());
PPTX::Logic::Shape* pShape = dynamic_cast<PPTX::Logic::Shape*>(pElem->GetElem().operator ->());
if ((!pPicture && pShape) && (pShape->spPr.Fill.is<PPTX::Logic::BlipFill>()))
{//convert pptx shape to pptx picture
pPicture = new PPTX::Logic::Pic();
pPicture->nvPicPr.nvPr = pShape->nvSpPr.nvPr;
pPicture->nvPicPr.cNvPr = pShape->nvSpPr.cNvPr;
pPicture->spPr = pShape->spPr;
pPicture->blipFill = pShape->spPr.Fill.as<PPTX::Logic::BlipFill>();
pPicture->spPr.Fill = PPTX::Logic::UniFill();
pShape = NULL;
pElem->InitElem(pPicture);
}
if ((pPicture) && (pPicture->blipFill.blip.IsInit()))
{
if (pOle->m_OleObjectFile.IsInit())
{
pPicture->blipFill.blip->oleFilepathBin = pOle->m_OleObjectFile->filename().GetPath();
}
else if (pOle->m_oId.IsInit())
{
pPicture->blipFill.blip->oleRid = pOle->m_oId.get().ToString();
}
if (strName == L"object")
{
int nDxaOrig = oParseNode.ReadAttributeInt(L"w:dxaOrig");
int nDyaOrig = oParseNode.ReadAttributeInt(L"w:dyaOrig");
if (nDxaOrig > 0 && nDyaOrig > 0)
{
pOle->m_oDxaOrig = nDxaOrig;
pOle->m_oDyaOrig = nDyaOrig;
}
}
pPicture->oleObject.reset(pOle);
pOle = NULL;
}
}
if (pElem.IsInit())
elements.push_back(pElem);
RELEASEOBJECT(pOle)
}
break;
}
else
{
nullable<PPTX::Logic::SpTreeElem> elem(oParseNode);
elements.push_back(elem);
break;
}
}
}
if (pMainProps)
{
strXml = _start_xml_object + *pMainProps + _end_xml_object;
XmlUtils::CXmlLiteReader oReader;
oReader.FromString(strXml);
int nCurDepth = oReader.GetDepth();
while (oReader.ReadNextSiblingNode(nCurDepth))
{
std::wstring sName = oReader.GetName();
if (_T("wp:inline") == sName)
{
anchor = new OOX::Drawing::CInline(NULL);
anchor->fromXML(oReader);
}
else if (_T("wp:anchor") == sName)
{
anchor = new OOX::Drawing::CAnchor(NULL);
anchor->fromXML(oReader);
}
}
RELEASEOBJECT(pMainProps);
}
}
bool CDrawingConverter::ParceObject(const std::wstring& strXml, std::wstring* pMainProps)
{
XmlUtils::CXmlNode oMainNode;
if (!oMainNode.FromXmlString(strXml))
return false;
std::vector<XmlUtils::CXmlNode> oNodes;
if (!oMainNode.GetNodes(L"*", oNodes))
return false;
m_pBinaryWriter->StartRecord(0);
m_pBinaryWriter->ClearCurShapeSize();
size_t lCount = oNodes.size();
for (size_t i = 0; i < lCount; ++i)
{
XmlUtils::CXmlNode & oParseNode = oNodes[i];
std::wstring strFullName = oParseNode.GetName();
std::wstring strNS = XmlUtils::GetNamespace(strFullName);
std::wstring strName = XmlUtils::GetNameNoNS(strFullName);
while (true)
{
if (strName == L"background")
{
PPTX::Logic::SpTreeElem oElem;
ConvertShape(&oElem, oParseNode, pMainProps, false);
m_pBinaryWriter->WriteRecord1(1, oElem);
break;
}
else if (strName == L"pict" || strName == L"object")
{
//shape type first
XmlUtils::CXmlNode oNodeST;
if (oParseNode.GetNode(L"v:shapetype", oNodeST))
{
AddShapeType(oNodeST);
}
std::vector<XmlUtils::CXmlNode> oChilds;
if (oParseNode.GetNodes(L"*", oChilds))
{
size_t lChildsCount = oChilds.size();
bool bIsFound = false;
PPTX::Logic::SpTreeElem* pElem = NULL;
PPTX::Logic::COLEObject* pOle = NULL;
for (LONG k = 0; k < lChildsCount; k++)
{
XmlUtils::CXmlNode & oNodeP = oChilds[k];
std::wstring strNameP = XmlUtils::GetNameNoNS(oNodeP.GetName());
if (L"shape" == strNameP ||
L"rect" == strNameP ||
L"oval" == strNameP ||
L"line" == strNameP ||
L"background"== strNameP ||
L"roundrect" == strNameP ||
L"image" == strNameP ||
L"polyline" == strNameP)
{
if(NULL == pElem)
{
pElem = new PPTX::Logic::SpTreeElem;
ConvertShape(pElem, oNodeP, pMainProps, true);
}
}
else if (L"binData" == strNameP)
{
AddBinData(oNodeP);
}
else if (L"OLEObject" == strNameP || L"objectEmbed" == strNameP)
{
pOle = new PPTX::Logic::COLEObject();
pOle->fromXML(oNodeP);
}
else if (L"group" == strNameP)
{
if(NULL == pElem)
{
pElem = new PPTX::Logic::SpTreeElem;
ConvertGroup(pElem, oNodeP, pMainProps, true);
}
}
else if (L"drawing" == strNameP)
{
if (NULL == pElem)
{
pElem = new PPTX::Logic::SpTreeElem;
ConvertDrawing(pElem, oNodeP, pMainProps, true);
}
}
else
{
continue;
}
if (bIsFound)
break;
}
if(pElem && NULL != pOle && pOle->m_sProgId.IsInit() && (pOle->m_oId.IsInit() || pOle->m_OleObjectFile.IsInit()))
{
PPTX::Logic::Pic* pPicture = dynamic_cast<PPTX::Logic::Pic*>(pElem->GetElem().operator ->());
PPTX::Logic::Shape* pShape = dynamic_cast<PPTX::Logic::Shape*>(pElem->GetElem().operator ->());
if ((!pPicture && pShape) && (pShape->spPr.Fill.is<PPTX::Logic::BlipFill>()))
{//convert pptx shape to pptx picture
pPicture = new PPTX::Logic::Pic();
pPicture->nvPicPr.nvPr = pShape->nvSpPr.nvPr;
pPicture->nvPicPr.cNvPr = pShape->nvSpPr.cNvPr;
pPicture->spPr = pShape->spPr;
pPicture->blipFill = pShape->spPr.Fill.as<PPTX::Logic::BlipFill>();
pPicture->spPr.Fill = PPTX::Logic::UniFill();
pShape = NULL;
pElem->InitElem(pPicture);
}
if ((pPicture) && (pPicture->blipFill.blip.IsInit()))
{
if (pOle->m_OleObjectFile.IsInit())
{
pPicture->blipFill.blip->oleFilepathBin = pOle->m_OleObjectFile->filename().GetPath();
}
else if (pOle->m_oId.IsInit())
{
pPicture->blipFill.blip->oleRid = pOle->m_oId.get().ToString();
}
if(strName == L"object")
{
int nDxaOrig = oParseNode.ReadAttributeInt(L"w:dxaOrig");
int nDyaOrig = oParseNode.ReadAttributeInt(L"w:dyaOrig");
if (nDxaOrig > 0 && nDyaOrig > 0)
{
pOle->m_oDxaOrig = nDxaOrig;
pOle->m_oDyaOrig = nDyaOrig;
}
}
pPicture->oleObject.reset(pOle);
pOle = NULL;
}
}
//std::wstring test;
if (pElem)
{
m_pBinaryWriter->WriteRecord1(1, *pElem);
//test = pElem->toXML();
}
RELEASEOBJECT(pElem)
RELEASEOBJECT(pOle)
}
break;
}
else
{
PPTX::Logic::SpTreeElem oElem;
oElem = oParseNode;
if (oElem.is_init())
{
m_pBinaryWriter->WriteRecord1(1, oElem);
}
break;
}
}
}
m_pBinaryWriter->EndRecord();
return true;
}
void CDrawingConverter::ConvertDrawing(PPTX::Logic::SpTreeElem *elem, XmlUtils::CXmlNode& oNodeShape, std::wstring* pMainProps, bool bIsTop)
{
if (!elem) return;
XmlUtils::CXmlNode oNodeAnchorInline = oNodeShape.ReadNodeNoNS(L"anchor");
if (!oNodeAnchorInline.IsValid())
{
oNodeAnchorInline = oNodeShape.ReadNodeNoNS(L"inline");
}
if (oNodeAnchorInline.IsValid())
{
XmlUtils::CXmlNode oNodeExt;
if (oNodeAnchorInline.GetNode(L"wp:extent", oNodeExt))
{
double cx = oNodeExt.ReadAttributeInt(L"cx");
double cy = oNodeExt.ReadAttributeInt(L"cy");
m_pBinaryWriter->SetCurShapeSize(cx, cy);
}
XmlUtils::CXmlNode oNodeDocPr;
if (oNodeAnchorInline.GetNode(L"wp:docPr", oNodeDocPr))
{//vml shapes without id .. reset all id
oNodeDocPr.SetAttributeInt(L"id", m_lNextId++);
}
if (bIsTop)
{
SendMainProps(oNodeAnchorInline.GetXml(), pMainProps);
}
XmlUtils::CXmlNode oNodeGraphic = oNodeAnchorInline.ReadNodeNoNS(L"graphic");
XmlUtils::CXmlNode oNodeGraphicData = oNodeGraphic.ReadNodeNoNS(L"graphicData");
if (oNodeGraphicData.IsValid())
{
std::vector<XmlUtils::CXmlNode> oChilds;
oNodeGraphicData.GetNodes(L"*", oChilds);
if (1 == oChilds.size())
{
XmlUtils::CXmlNode &oNodeContent = oChilds[0];
if (L"wpc:wpc" == oNodeContent.GetName())
{
PPTX::Logic::SpTree* pTree = new PPTX::Logic::SpTree();
pTree->fromXML(oNodeContent);
elem->InitElem(pTree);
}
else
{
elem->fromXML(oNodeContent);
}
}
}
}
}
void CDrawingConverter::ConvertShape(PPTX::Logic::SpTreeElem *elem, XmlUtils::CXmlNode& oNodeShape, std::wstring* pMainProps, bool bIsTop)
{
if (!elem) return;
std::wstring strNameNode = oNodeShape.GetName();
bool bIsNeedCoordSizes = true;
bool bTextBox = false;
bool bPicture = false;
bool bStroked = true;
bool bHidden = false;
bool bShapeTypeSet = true;
std::wstring strStyleAdvenced = L"";
PPT::CShapeElement oShapeElem;
CPPTShape* pPPTShape = NULL;
bool bSetShape = false;
if (L"v:background" == strNameNode)
{
pPPTShape = new CPPTShape();
pPPTShape->SetShapeType((PPTShapes::ShapeType)1);
pPPTShape->ReCalculate();
}
else if (L"v:rect" == strNameNode)
{
pPPTShape = new CPPTShape();
pPPTShape->SetShapeType((PPTShapes::ShapeType)1);
pPPTShape->ReCalculate();
}
else if (L"v:roundrect" == strNameNode)
{
pPPTShape = new CPPTShape();
pPPTShape->SetShapeType((PPTShapes::ShapeType)2);
std::wstring strArc = oNodeShape.GetAttribute(L"arcsize");
if (false == strArc.empty())
{
SimpleTypes::CUniversalMeasureOrPercent value;
value.FromString(strArc);
if (value.IsPercent())
{
}
else
{
if (value.GetValue() < 1)
pPPTShape->SetAdjustment(0, value.GetValue() * 10000);
else
pPPTShape->SetAdjustment(0, value.GetValue() / 10.);
}
}
pPPTShape->ReCalculate();
}
else if (L"v:oval" == strNameNode)
{
pPPTShape = new CPPTShape();
pPPTShape->SetShapeType((PPTShapes::ShapeType)3);
pPPTShape->ReCalculate();
}
else if (L"v:image" == strNameNode)
{
pPPTShape = new CPPTShape();
pPPTShape->SetShapeType((PPTShapes::ShapeType)75);
pPPTShape->ReCalculate();
}
else if (L"v:line" == strNameNode)
{
pPPTShape = new CPPTShape();
pPPTShape->SetShapeType((PPTShapes::ShapeType)20);
pPPTShape->ReCalculate();
std::wstring strCoord1 = oNodeShape.GetAttributeOrValue(L"from");
std::wstring strCoord2 = oNodeShape.GetAttributeOrValue(L"to");
if (!strCoord1.empty() && !strCoord2.empty())
{
std::vector<std::wstring> oArray1;
boost::algorithm::split(oArray1, strCoord1, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
std::vector<std::wstring> oArray2;
boost::algorithm::split(oArray2, strCoord2, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
if (oArray1.size() >= 2 && oArray2.size() >= 2)
{
SimpleTypes::CPoint parserPoint;
double x1 = parserPoint.FromString(oArray1[0]);
double y1 = parserPoint.FromString(oArray1[1]);
double x2 = parserPoint.FromString(oArray2[0]);
double y2 = parserPoint.FromString(oArray2[1]);
if (x1 > x2)
{
double tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2)
{
double tmp = y1;
y1 = y2;
y2 = tmp;
}
strStyleAdvenced = L";left:" + XmlUtils::ToString(x1, L"%.2lf")
+ L";top:" + XmlUtils::ToString(y1, L"%.2lf")
+ L";width:" + XmlUtils::ToString(x2-x1, L"%.2lf")
+ L";height:" + XmlUtils::ToString(y2-y1, L"%.2lf")
+ L";";
}
}
}
else if (L"v:polyline" == strNameNode)
{
std::wstring strPoints = oNodeShape.GetAttributeOrValue(L"points");
if (L"" != strPoints)
{
std::vector<std::wstring> oArray;
boost::algorithm::split(oArray, strPoints, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
int nSize = (int)oArray.size();
if ((nSize % 2 == 0) && nSize > 3)
{
int* _POINTS = new int[nSize];
double dKoef = 25.4 * 36000 / 72.0;
for (int k = 0; k < nSize; ++k)
{
if (L"" == oArray[k])
{
_POINTS[k] = 0;
}
else
{
SimpleTypes::CPoint parserPoint;
_POINTS[k] = (int)(dKoef * parserPoint.FromString(oArray[k]));
}
}
// now define bounds
int _x = INT_MAX;
int _y = INT_MAX;
int _r = INT_MIN;
int _b = INT_MIN;
for (int k = 0; k < nSize; k += 2)
{
int tmpx = _POINTS[k];
int tmpy = _POINTS[k + 1];
if (tmpx < _x)
_x = tmpx;
if (tmpx > _r)
_r = tmpx;
if (tmpy < _y)
_y = tmpy;
if (tmpy > _b)
_b = tmpy;
}
int nOffsetX = _POINTS[0] - _x;
int nOffsetY = _POINTS[1] - _y;
strStyleAdvenced += L";margin-left:" + std::to_wstring(_x) + L";margin-top:" + std::to_wstring(_y)
+ L";width:" + std::to_wstring(_r - _x) + L";height:" + std::to_wstring(_b - _y) + L";polyline_correct:true;";
double dKoefX = 21600.0 / (std::max)((_r - _x), 1);
double dKoefY = 21600.0 / (std::max)((_b - _y), 1);
std::wstring strPath;
for (int k = 0; k < nSize; k += 2)
{
std::wstring _s;
if (k == 0) _s = L"m";
else _s = L"l";
strPath += _s + std::to_wstring((int)(dKoefX * (_POINTS[k] - _x))) + L"," + std::to_wstring((int)(dKoefY * (_POINTS[k + 1] - _y)));
}
strPath += L"e";
RELEASEARRAYOBJECTS(_POINTS);
pPPTShape = new CPPTShape();
pPPTShape->SetShapeType((PPTShapes::ShapeType)1);
// otherwise rect will be preserved
pPPTShape->m_eType = PPTShapes::sptCustom;
pPPTShape->LoadPathList(strPath);
pPPTShape->ReCalculate();
bIsNeedCoordSizes = false;
}
}
}
else if (L"v:shape" == strNameNode)
{
bShapeTypeSet = false;
std::wstring strType = oNodeShape.GetAttribute(L"type");
if (strType.length() > 2 && strType[0] == (wchar_t)('#'))
{
strType = strType.substr(1);
std::map<std::wstring, CShapePtr>::iterator pFind = m_mapShapeTypes.find(strType);
if (m_mapShapeTypes.end() != pFind)
{
CBaseShapePtr base_shape_type = pFind->second->getBaseShape();
CPPTShape* ppt_shape_type = dynamic_cast<CPPTShape*>(base_shape_type.get());
pPPTShape = new CPPTShape();
base_shape_type->SetToDublicate(pPPTShape);
pPPTShape->m_eType = ppt_shape_type->m_eType;
bShapeTypeSet = true;
}
else if (std::wstring::npos != strType.find(L"t75"))
{
pPPTShape = new CPPTShape();
pPPTShape->SetShapeType((PPTShapes::ShapeType)75);
pPPTShape->m_eType = PPTShapes::sptCFrame;
}
}
if (NULL == pPPTShape)
{
std::wstring strType = oNodeShape.GetAttribute(L"o:connectortype");
if (strType.length() > 0)
{
int type = 0;
if (strType == L"elbow") type = PPTShapes::sptCBentConnector2;
else if (strType == L"straight") type = PPTShapes::sptCStraightConnector1;
else if (strType == L"curved") type = PPTShapes::sptCCurvedConnector2;
if (type > 0)
{
pPPTShape = new CPPTShape();
pPPTShape->SetShapeType((PPTShapes::ShapeType)type);
pPPTShape->m_bIsStroked = true;
pPPTShape->ReCalculate();
}
}
else
{
pPPTShape = new CPPTShape();
pPPTShape->SetShapeType((PPTShapes::ShapeType)1);
// otherwise rect will be preserved
pPPTShape->m_eType = PPTShapes::sptCustom;
}
}
oShapeElem.m_pShape->setBaseShape(CBaseShapePtr(pPPTShape));
bSetShape = true;
if (bIsNeedCoordSizes)
{
LoadCoordPos(oNodeShape, oShapeElem.m_pShape); //for path calculate
}
pPPTShape->LoadFromXMLShapeType(oNodeShape);
}
if (pPPTShape != NULL)
{
if (!bSetShape)
{
oShapeElem.m_pShape->setBaseShape(CBaseShapePtr(pPPTShape));
bSetShape = true;
}
if (bIsNeedCoordSizes)
{
LoadCoordSize(oNodeShape, oShapeElem.m_pShape);
}
else
{
oShapeElem.m_pShape->m_dWidthLogic = 21600;
oShapeElem.m_pShape->m_dHeightLogic = 21600;
oShapeElem.m_pShape->getBaseShape()->m_oPath.SetCoordsize(21600, 21600);
}
if (pPPTShape->m_oSignatureLine.IsInit())
pPPTShape->m_eType = PPTShapes::ShapeType::sptCFrame;
if (pPPTShape->m_eType == PPTShapes::sptCTextBox)
{
bTextBox = true;
}
else if (pPPTShape->m_eType == PPTShapes::sptCFrame)
{
bPicture = true;
}
else if (pPPTShape->m_eType == PPTShapes::sptCNotchedCircularArrow)
{
bHidden = true;
}
std::wstring strXmlPPTX;
PPTX::Logic::Shape* pShape = NULL; //todoooo + CxnSp
PPTX::Logic::Pic* pPicture = NULL;
PPTX::Logic::SpPr* pSpPr = NULL;
PPTX::Logic::CNvPr* pCNvPr = NULL;
if (bPicture && false == pPPTShape->m_oSignatureLine.IsInit())
{
bStroked = false;
pPicture = new PPTX::Logic::Pic();
elem->InitElem(pPicture);
pSpPr = &pPicture->spPr;
pCNvPr = &pPicture->nvPicPr.cNvPr;
strXmlPPTX = oShapeElem.ConvertPPTShapeToPPTX(true);
}
else
{
pShape = new PPTX::Logic::Shape();
elem->InitElem(pShape);
pSpPr = &pShape->spPr;
pCNvPr = &pShape->nvSpPr.cNvPr;
if (!pShape->oTextBoxBodyPr.IsInit())
pShape->oTextBoxBodyPr = new PPTX::Logic::BodyPr();
if (pPPTShape->IsWordArt())
{
ConvertWordArtShape(elem, oNodeShape, pPPTShape);
strXmlPPTX = L"<a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom>";
}
else
{
strXmlPPTX = oShapeElem.ConvertPPTShapeToPPTX(true);
// in old shapes text rotates separately
pShape->oTextBoxBodyPr->upright = true;
}
XmlUtils::CXmlNode oNodeTextBox;
std::wstring sTextboxStyle;
bool res_text = oNodeShape.GetNode(L"v:textbox", oNodeTextBox);
if (!res_text) res_text = oNodeShape.GetNode(L"w:textbox", oNodeTextBox); // libre 4.0 does this stuff
if (res_text)
{
if (!bShapeTypeSet) pPPTShape->m_bIsStroked = false; // default for textbox easy set
if (pPPTShape->m_eType == PPTShapes::sptCNotchedCircularArrow)
{
pPPTShape->m_eType = PPTShapes::sptCTextBox;
bTextBox = true;
}
XmlUtils::CXmlNode oNodeContent;
if (oNodeTextBox.GetNode(L"w:txbxContent", oNodeContent))
{
pShape->oTextBoxShape = oNodeContent;
}
else if (oNodeTextBox.GetNode(L"div", oNodeContent))
{//The <div> tag was used to create an area in which the rotation would take place.
ConvertTextVML(oNodeTextBox, pShape);
}
std::wstring sTextInset = oNodeTextBox.GetAttribute(L"inset");
std::wstring sTextInsetMode = oNodeTextBox.GetAttribute(L"o:insetmode");
sTextboxStyle = oNodeTextBox.GetAttribute(L"style");
//if (L"" != sTextInset && ((L"" == sTextInsetMode) || (L"custom" == sTextInsetMode)))
if (sTextInsetMode.empty() || L"custom" == sTextInsetMode)
{
if (!sTextInset.empty())
{
PPTX::CStringTrimmer oTrimmer;
oTrimmer.m_Separator = (wchar_t)',';
oTrimmer.LoadFromString(sTextInset);
double dTextMarginLeft = oTrimmer.GetParameter(0, 0.1);
double dTextMarginTop = oTrimmer.GetParameter(1, 0.05);
double dTextMarginRight = oTrimmer.GetParameter(2, 0.1);
double dTextMarginBottom = oTrimmer.GetParameter(3, 0.05);
pShape->oTextBoxBodyPr->lIns = (int)(12700 * dTextMarginLeft + 0.5);
pShape->oTextBoxBodyPr->tIns = (int)(12700 * dTextMarginTop + 0.5);
pShape->oTextBoxBodyPr->rIns = (int)(12700 * dTextMarginRight + 0.5);
pShape->oTextBoxBodyPr->bIns = (int)(12700 * dTextMarginBottom + 0.5);
}
else
{
if (pPPTShape->m_eType == PPTShapes::sptCTextBox ||
pPPTShape->m_eType == PPTShapes::sptCRect ||
pPPTShape->m_eType == PPTShapes::sptCRoundRect ||
pPPTShape->m_eType == PPTShapes::sptCEllipse ||
pPPTShape->m_eType == PPTShapes::sptCWedgeRectCallout ||
pPPTShape->m_eType == PPTShapes::sptCWedgeRoundRectCallout ||
pPPTShape->m_eType == PPTShapes::sptCWedgeEllipseCallout ||
pPPTShape->m_eType == PPTShapes::sptCCloudCallout ||
pPPTShape->m_eType == PPTShapes::sptCFlowChartConnector ||
pPPTShape->m_eType == PPTShapes::sptCFlowChartProcess)
{
pShape->oTextBoxBodyPr->lIns = 91440;
pShape->oTextBoxBodyPr->tIns = 45720;
pShape->oTextBoxBodyPr->rIns = 91440;
pShape->oTextBoxBodyPr->bIns = 45720;
}
else
{
pShape->oTextBoxBodyPr->lIns = 12700;
pShape->oTextBoxBodyPr->tIns = 12700;
pShape->oTextBoxBodyPr->rIns = 12700;
pShape->oTextBoxBodyPr->bIns = 12700;
}
}
}
if (!sTextboxStyle.empty())
{//todooo implement the rest
SimpleTypes::Vml::CCssStyle oCssStyle;
oCssStyle.FromString(sTextboxStyle);
if (false == oCssStyle.m_arrProperties.empty())
{
std::map<SimpleTypes::Vml::ECssPropertyType, size_t>::iterator pFind = oCssStyle.m_mapProperties.find(SimpleTypes::Vml::cssptLayoutFlow);
if (pFind != oCssStyle.m_mapProperties.end())
{
if (oCssStyle.m_arrProperties[pFind->second]->get_Value().eLayoutFlow == SimpleTypes::Vml::csslayoutflowVertical)
{
pShape->oTextBoxBodyPr->vert = new PPTX::Limit::TextVerticalType();
pShape->oTextBoxBodyPr->vert->set(L"vert");
}
}
pFind = oCssStyle.m_mapProperties.find(SimpleTypes::Vml::cssptMsoLayoutFlowAlt);
if (pFind != oCssStyle.m_mapProperties.end())
{
if (oCssStyle.m_arrProperties[pFind->second]->get_Value().eLayoutFlowAlt == SimpleTypes::Vml::csslayoutflowaltBottomToTop)
{
if (pShape->oTextBoxBodyPr->vert.IsInit() == false)
pShape->oTextBoxBodyPr->vert = new PPTX::Limit::TextVerticalType();
pShape->oTextBoxBodyPr->vert->set(L"vert270");
}
}
if (pShape->oTextBoxBodyPr->vert.IsInit())
{
if (pShape->txBody.IsInit() == false)
pShape->txBody = new PPTX::Logic::TxBody();
if (!pShape->txBody->bodyPr.IsInit())
pShape->txBody->bodyPr = new PPTX::Logic::BodyPr();
pShape->txBody->bodyPr->vert = pShape->oTextBoxBodyPr->vert;
}
pFind = oCssStyle.m_mapProperties.find(SimpleTypes::Vml::cssptMsoRotate);
if (pFind != oCssStyle.m_mapProperties.end())
{
try
{
double val = 0;
switch (oCssStyle.m_arrProperties[pFind->second]->get_Value().eRotate)
{
case SimpleTypes::Vml::cssmsorotate90: val = 90; break;
case SimpleTypes::Vml::cssmsorotate180: val = 180; break;
case SimpleTypes::Vml::cssmsorotate270: val = 270; break;
}
pShape->oTextBoxBodyPr->rot = val * 60000; //for docx, xlsx
if (pShape->txBody.IsInit() == false) //for pptx
pShape->txBody = new PPTX::Logic::TxBody();
if (!pShape->txBody->bodyPr.IsInit())
pShape->txBody->bodyPr = new PPTX::Logic::BodyPr();
pShape->txBody->bodyPr->rot = pShape->oTextBoxBodyPr->rot;
}catch(...){}
}
pFind = oCssStyle.m_mapProperties.find(SimpleTypes::Vml::cssptMsoFitShapeToText);
if (pFind != oCssStyle.m_mapProperties.end())
{
if (oCssStyle.m_arrProperties[pFind->second]->get_Value().bValue)
{
if (pShape->txBody.IsInit() == false) //for pptx /// todooo collapse
pShape->txBody = new PPTX::Logic::TxBody();
if (!pShape->txBody->bodyPr.IsInit())
pShape->txBody->bodyPr = new PPTX::Logic::BodyPr();
pShape->txBody->bodyPr->Fit.type = PPTX::Logic::TextFit::FitSpAuto;
pShape->oTextBoxBodyPr->Fit.type = PPTX::Logic::TextFit::FitSpAuto;
}
}
pFind = oCssStyle.m_mapProperties.find(SimpleTypes::Vml::cssptMsoFitTextToShape);
if (pFind != oCssStyle.m_mapProperties.end())
{
if (oCssStyle.m_arrProperties[pFind->second]->get_Value().bValue)
{
if (pShape->txBody.IsInit() == false) //for pptx
pShape->txBody = new PPTX::Logic::TxBody();
if (!pShape->txBody->bodyPr.IsInit())
pShape->txBody->bodyPr = new PPTX::Logic::BodyPr();
pShape->txBody->bodyPr->Fit.type = PPTX::Logic::TextFit::FitNo;//?? todoooo
pShape->oTextBoxBodyPr->Fit.type = PPTX::Logic::TextFit::FitNo;//?? todoooo
}
}
pFind = oCssStyle.m_mapProperties.find(SimpleTypes::Vml::cssptMsoTextScale);
if (pFind != oCssStyle.m_mapProperties.end())
{
try
{
if (oCssStyle.m_arrProperties[pFind->second]->get_Value().oValue.eType == SimpleTypes::Vml::cssunitstypeUnits)
{
pShape->oTextBoxBodyPr->Fit.fontScale = (int)(100 * oCssStyle.m_arrProperties[pFind->second]->get_Value().oValue.dValue); //for docx, xlsx
pShape->oTextBoxBodyPr->Fit.type = PPTX::Logic::TextFit::FitNormAuto;
if (pShape->txBody.IsInit() == false) //for pptx
pShape->txBody = new PPTX::Logic::TxBody();
if (!pShape->txBody->bodyPr.IsInit())
pShape->txBody->bodyPr = new PPTX::Logic::BodyPr();
pShape->txBody->bodyPr->Fit.fontScale = pShape->oTextBoxBodyPr->Fit.fontScale;
pShape->txBody->bodyPr->Fit.type = pShape->oTextBoxBodyPr->Fit.type;
}
}catch(...){}
}
}
}
}
XmlUtils::CXmlNode oNodeTextData;
if (oNodeShape.GetNode(L"p:textdata", oNodeTextData))
{
std::wstring sId = oNodeTextData.GetAttribute(L"id");
if (sId.length() > 0 && m_pBinaryWriter->GetRelsPtr())
{
OOX::RId rId(sId);
smart_ptr<PPTX::LegacyDiagramText> pExt = m_pBinaryWriter->GetRelsPtr()->Get<PPTX::LegacyDiagramText>(rId);
if (pExt.IsInit())
{
if (pShape->txBody.IsInit() == false)
pShape->txBody = new PPTX::Logic::TxBody();
if (pShape->txBody.IsInit())
{
PPTX::Logic::Paragraph p;
PPTX::Logic::Run *r = new PPTX::Logic::Run();
r->SetText(pExt->m_Text);
if (pExt->m_arrRPr.size() > 0)
{
r->rPr = pExt->m_arrRPr[0];
}
PPTX::Logic::RunElem elm;
p.RunElems.push_back(elm);
if (pExt->m_arrPPr.size() > 0)
{
p.pPr = pExt->m_arrPPr[0];
}
p.RunElems.back().InitRun(r);
pShape->txBody->Paragrs.push_back(p);
}
}
}
}
if (bTextBox)
{
pShape->nvSpPr.cNvSpPr.txBox = true;
}
}
//-------------------------------------------------------------------------------------------------------------------
nullable_bool hr;
XmlMacroReadAttributeBase(oNodeShape, L"o:hr", hr);
if (hr.IsInit() && *hr)
{
pSpPr->Geometry.hr.Init();
XmlMacroReadAttributeBase(oNodeShape, L"o:hrpct", pSpPr->Geometry.hr->pct);
XmlMacroReadAttributeBase(oNodeShape, L"o:hralign", pSpPr->Geometry.hr->align);
XmlMacroReadAttributeBase(oNodeShape, L"o:hrnoshade", pSpPr->Geometry.hr->noshade);
}
//-------------------------------------------------------------------------------------------------------------------
XmlUtils::CXmlNode oNodeG;
oNodeG.FromXmlString(strXmlPPTX);
pSpPr->Geometry = oNodeG;
std::wstring strStyle = oNodeShape.GetAttribute(L"style") + strStyleAdvenced;
PPTX::CCSS oCSSParser;
oCSSParser.LoadFromString2(strStyle);
std::map<std::wstring, std::wstring>::iterator pFind = oCSSParser.m_mapSettings.find(L"visibility");
if (oCSSParser.m_mapSettings.end() != pFind)
{
if (L"hidden" == pFind->second)
bHidden = true;
else if (L"visible" == pFind->second)
bHidden = false;
}
if (bHidden && false == bIsTop)
{
pCNvPr->hidden = true;
}
CSpTreeElemProps oProps;
oProps.IsTop = bIsTop;
std::wstring strMainPos = GetDrawingMainProps(oNodeShape, oCSSParser, oProps);
//-------------------------------------------------------------------------------------------------------------------
if (pShape && oCSSParser.m_mapSettings.size() > 0)
{
std::map<std::wstring, std::wstring>::iterator pFind = oCSSParser.m_mapSettings.find(L"v-text-anchor");
if (pFind != oCSSParser.m_mapSettings.end())
{
if (pFind->second == L"middle") pShape->oTextBoxBodyPr->anchor = L"ctr";
if (pFind->second == L"bottom") pShape->oTextBoxBodyPr->anchor = L"b";
if (pFind->second == L"top-center") pShape->oTextBoxBodyPr->anchor = L"t";
if (pFind->second == L"middle-center") pShape->oTextBoxBodyPr->anchor = L"ctr";
if (pFind->second == L"bottom-center") pShape->oTextBoxBodyPr->anchor = L"b";
if (pFind->second == L"top-baseline") pShape->oTextBoxBodyPr->anchor = L"t";
if (pFind->second == L"bottom-baseline") pShape->oTextBoxBodyPr->anchor = L"b";
if (pFind->second == L"top-center-baseline") pShape->oTextBoxBodyPr->anchor = L"t";
if (pFind->second == L"bottom-center-baseline") pShape->oTextBoxBodyPr->anchor = L"b";
}
pFind = oCSSParser.m_mapSettings.find(L"mso-wrap-style");
if (pFind != oCSSParser.m_mapSettings.end() )
{
if (pFind->second == L"none")
pShape->oTextBoxBodyPr->wrap = L"none";
else
pShape->oTextBoxBodyPr->wrap = L"wrap";
}
else if (!pPPTShape->IsWordArt())
pShape->oTextBoxBodyPr->wrap = L"wrap";
}
////////////////////////////////////////////////////////////////////////////////////
if (bIsTop)
{
SendMainProps(strMainPos, pMainProps);
if (m_oxfrm_override.IsInit())
{
pSpPr->xfrm = m_oxfrm_override;
}
else
{
pSpPr->xfrm = new PPTX::Logic::Xfrm();
pSpPr->xfrm->offX = oProps.X;
pSpPr->xfrm->offY = oProps.Y;
pSpPr->xfrm->extX = oProps.Width;
pSpPr->xfrm->extY = oProps.Height;
}
std::map<std::wstring, std::wstring>::iterator pFind = oCSSParser.m_mapSettings.find(L"flip");
if (oCSSParser.m_mapSettings.end() != pFind)
{
if (pFind->second == L"x")
pSpPr->xfrm->flipH = true;
else if (pFind->second == L"y")
pSpPr->xfrm->flipV = true;
else if ((pFind->second == L"xy") || (pFind->second == L"yx") || (pFind->second == L"x y") || (pFind->second == L"y x")
|| (pFind->second == L"y,x") || (pFind->second == L"x,y"))
{
pSpPr->xfrm->flipH = true;
pSpPr->xfrm->flipV = true;
}
}
pFind = oCSSParser.m_mapSettings.find(L"rotation");
if (oCSSParser.m_mapSettings.end() != pFind)
{
pSpPr->xfrm->rot = NS_DWC_Common::getRotateAngle(pFind->second, pSpPr->xfrm->flipH, pSpPr->xfrm->flipV);
}
}
else
{
pSpPr->xfrm = new PPTX::Logic::Xfrm();
pSpPr->xfrm->offX = oProps.X;
pSpPr->xfrm->offY = oProps.Y;
pSpPr->xfrm->extX = oProps.Width;
pSpPr->xfrm->extY = oProps.Height;
std::map<std::wstring, std::wstring>::iterator pFind = oCSSParser.m_mapSettings.find(L"flip");
if (oCSSParser.m_mapSettings.end() != pFind)
{
if (pFind->second == L"x")
pSpPr->xfrm->flipH = true;
else if (pFind->second == L"y")
pSpPr->xfrm->flipV = true;
else if ((pFind->second == L"xy") || (pFind->second == L"yx") || (pFind->second == L"x y") || (pFind->second == L"y x")
|| (pFind->second == L"y,x") || (pFind->second == L"x,y"))
{
pSpPr->xfrm->flipH = true;
pSpPr->xfrm->flipV = true;
}
}
pFind = oCSSParser.m_mapSettings.find(L"rotation");
if (oCSSParser.m_mapSettings.end() != pFind)
{
pSpPr->xfrm->rot = NS_DWC_Common::getRotateAngle(pFind->second, pSpPr->xfrm->flipH, pSpPr->xfrm->flipV);
}
}
if (!bIsTop)
{
pCNvPr->id = m_lNextId;
m_lNextId++;
}
else
{
pCNvPr->id = -1;
}
if (pShape)
{
pShape->signatureLine = pPPTShape->m_oSignatureLine;
}
if (bStroked)
{
CheckPenShape(elem, oNodeShape, pPPTShape);
}
CheckBrushShape(elem, oNodeShape, pPPTShape);
CheckBorderShape(elem, oNodeShape, pPPTShape);
CheckEffectShape(elem, oNodeShape, pPPTShape);
////test
//NSBinPptxRW::CXmlWriter oXml;
//elem->toXmlWriter(&oXml);
//std::wstring test = oXml.GetXmlString();
}
}
void CDrawingConverter::ConvertWordArtShape(PPTX::Logic::SpTreeElem* elem, XmlUtils::CXmlNode& oNodeShape, CPPTShape* pPPTShape)
{
if (!elem) return;
if (!pPPTShape) return;
PPTX::Logic::Shape* pShape = dynamic_cast<PPTX::Logic::Shape*>(elem->GetElem().operator ->());
if (!pShape) return;
enum EFilltype
{
etBlipFill = 0,
etGradFill = 1,
etNoFill = 2,
etPattFill = 3,
etSolidFill = 4
};
PPTShapes::ShapeType eShapeType = pPPTShape->m_eType;
SimpleTypes::ETextShapeType eTextShapeType;
switch (eShapeType)
{
case PPTShapes::ShapeType::sptCTextPlain: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextPlain; break;
case PPTShapes::ShapeType::sptCTextArchUp: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextArchUp; break;
case PPTShapes::ShapeType::sptCTextArchDown: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextArchDown; break;
case PPTShapes::ShapeType::sptCTextButton: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextButton; break;
case PPTShapes::ShapeType::sptCTextCurveUp: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextCurveUp; break;
case PPTShapes::ShapeType::sptCTextCurveDown: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextCurveDown; break;
case PPTShapes::ShapeType::sptCTextCanUp: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextCanUp; break;
case PPTShapes::ShapeType::sptCTextCanDown: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextCanDown; break;
case PPTShapes::ShapeType::sptCTextWave1: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextWave1; break;
case PPTShapes::ShapeType::sptCTextWave2: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextWave2; break;
case PPTShapes::ShapeType::sptCTextWave3: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextDoubleWave1; break;
case PPTShapes::ShapeType::sptCTextWave4: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextWave4; break;
case PPTShapes::ShapeType::sptCTextInflate: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextInflate; break;
case PPTShapes::ShapeType::sptCTextDeflate: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextDeflate; break;
case PPTShapes::ShapeType::sptCTextInflateBottom: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextInflateBottom; break;
case PPTShapes::ShapeType::sptCTextDeflateBottom: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextDeflateBottom; break;
case PPTShapes::ShapeType::sptCTextInflateTop: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextInflateTop; break;
case PPTShapes::ShapeType::sptCTextDeflateTop: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextDeflateTop; break;
case PPTShapes::ShapeType::sptCTextDeflateInflate: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextDeflateInflate; break;
case PPTShapes::ShapeType::sptCTextDeflateInflateDeflate: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextDeflateInflateDeflate; break;
case PPTShapes::ShapeType::sptCTextFadeRight: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextFadeRight; break;
case PPTShapes::ShapeType::sptCTextFadeLeft: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextFadeLeft; break;
case PPTShapes::ShapeType::sptCTextFadeUp: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextFadeUp; break;
case PPTShapes::ShapeType::sptCTextFadeDown: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextFadeDown; break;
case PPTShapes::ShapeType::sptCTextSlantUp: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextSlantUp; break;
case PPTShapes::ShapeType::sptCTextSlantDown: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextSlantDown; break;
case PPTShapes::ShapeType::sptCTextCascadeUp: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextCascadeUp; break;
case PPTShapes::ShapeType::sptCTextCascadeDown: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextCascadeDown; break;
case PPTShapes::ShapeType::sptCTextButtonPour: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextButtonPour; break;
case PPTShapes::ShapeType::sptCTextStop: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextStop; break;
case PPTShapes::ShapeType::sptCTextTriangle: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextTriangle; break;
case PPTShapes::ShapeType::sptCTextTriangleInverted: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextTriangleInverted; break;
case PPTShapes::ShapeType::sptCTextChevron: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextChevron; break;
case PPTShapes::ShapeType::sptCTextChevronInverted: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextChevronInverted; break;
case PPTShapes::ShapeType::sptCTextRingInside: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextRingInside; break;
case PPTShapes::ShapeType::sptCTextRingOutside: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextRingOutside; break;
case PPTShapes::ShapeType::sptCTextCirclePour: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextCirclePour; break;
case PPTShapes::ShapeType::sptCTextArchUpPour: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextArchUpPour; break;
case PPTShapes::ShapeType::sptCTextArchDownPour: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextArchDownPour; break;
default: eTextShapeType = SimpleTypes::ETextShapeType::textshapetypeTextNoShape; break;
}
SimpleTypes::CTextShapeType oTextShapeType;
oTextShapeType.SetValue(eTextShapeType);
std::wstring strPrstTxWarp = L"<a:prstTxWarp prst=\"" + oTextShapeType.ToString() + L"\"><a:avLst/></a:prstTxWarp>";
XmlUtils::CXmlNode oPrstTxWarpNode;
oPrstTxWarpNode.FromXmlString(strPrstTxWarp);
pShape->oTextBoxBodyPr->prstTxWarp = oPrstTxWarpNode;
std::vector<XmlUtils::CXmlNode> oChilds;
if (oNodeShape.GetNodes(L"*", oChilds))
{
size_t lChildsCount = oChilds.size();
std::vector<std::wstring> wordArtString;
EFilltype eFillType = etNoFill;;
std::wstring sTxbxContent = L"<w:txbxContent>";
std::wstring sFont = L"Arial Black";
int nFontSize = 36;
bool bBold = false;
bool bItalic = false;
BYTE lAlpha;
bool bOpacity = false;
bool bOpacity2 = false;
double nFocus = 0;
int nAngle = 90;
bool bColors = false;
PPTX::Logic::ColorModifier oMod;
PPTX::Logic::ColorModifier oMod2;
std::vector<PPTX::Logic::UniColor*> arColors;
std::vector<PPTX::Logic::UniColor*> arColorsNew;
std::vector<int> arPos;
std::vector<int> arPosNew;
std::map<int, PPTX::Logic::UniColor*> arGradMap;
int R = 255, G = 255, B = 255;
nullable_string sFillColor;
XmlMacroReadAttributeBase(oNodeShape, L"fillcolor", sFillColor);
if (sFillColor.is_init())
{
eFillType = etSolidFill;
ODRAW::CColor color;
if (NS_DWC_Common::getColorFromString(*sFillColor, color))
{
PPTX::Logic::SolidFill* pSolid = new PPTX::Logic::SolidFill();
pSolid->m_namespace = L"a";
pSolid->Color.Color = new PPTX::Logic::SrgbClr();
pSolid->Color.Color->SetRGB(color.R, color.G, color.B);
arColors.push_back(&pSolid->Color);
arPos.push_back(0);
R = color.R;
G = color.G;
B = color.B;
}
}
if (eFillType == etNoFill)
{
// default color for vml = white
nullable_string sFilled;
XmlMacroReadAttributeBase(oNodeShape, L"filled", sFilled);
if (!sFilled.is_init() || (*sFilled != L"false") && *sFilled != L"f")
{
eFillType = etSolidFill;
PPTX::Logic::SolidFill* pSolid = new PPTX::Logic::SolidFill();
pSolid->m_namespace = L"a";
pSolid->Color.Color = new PPTX::Logic::SrgbClr();
pSolid->Color.Color->SetRGB(R, G, B);
arColors.push_back(&pSolid->Color);
arPos.push_back(0);
}
}
for (LONG k = 0; k < lChildsCount; k++)
{
XmlUtils::CXmlNode & oNodeP = oChilds[k];
std::wstring strNameP = XmlUtils::GetNameNoNS(oNodeP.GetName());
if (L"textpath" == strNameP)
{
std::wstring tmpString = oNodeP.GetText(); //to bypass &#xA, duplicate is written to content
if (tmpString.empty())
{
tmpString = oNodeP.GetAttribute(L"string");
CorrectXmlString(tmpString);
wordArtString.push_back(tmpString);
}
else
{
CorrectXmlString(tmpString);
int pos1 = 0, pos2 = 0;
while (pos1 < (int)tmpString.length() && pos2 < (int)tmpString.length())
{
pos2 = (int)tmpString.find(L"\n", pos1);
if (pos2 > 0)
{
wordArtString.push_back(tmpString.substr(pos1, pos2 - pos1));
pos1 = pos2 + 1;
}
else break;
}
wordArtString.push_back(tmpString.substr(pos1, tmpString.length() - pos1));
}
SimpleTypes::Vml::CCssStyle oCssStyle;
if (pPPTShape->m_textPath.sStyle)
{
oCssStyle.FromString(*pPPTShape->m_textPath.sStyle);
}
std::map<SimpleTypes::Vml::ECssPropertyType, size_t>::iterator pFind = oCssStyle.m_mapProperties.find(SimpleTypes::Vml::cssptFontFamily);
if (pFind != oCssStyle.m_mapProperties.end())
{
sFont = oCssStyle.m_arrProperties[pFind->second]->get_Value().wsValue;
XmlUtils::replace_all(sFont, L"\"", L"");
}
pFind = pFind = oCssStyle.m_mapProperties.find(SimpleTypes::Vml::cssptFontSize);
if (pFind != oCssStyle.m_mapProperties.end())
{
nFontSize = oCssStyle.m_arrProperties[pFind->second]->get_Value().oValue.dValue;
}
pFind = pFind = oCssStyle.m_mapProperties.find(SimpleTypes::Vml::cssptFontStyle);
if (pFind != oCssStyle.m_mapProperties.end())
{
bItalic = (oCssStyle.m_arrProperties[pFind->second]->get_Value().eFontStyle == SimpleTypes::Vml::cssfontstyleItalic);
}
pFind = pFind = oCssStyle.m_mapProperties.find(SimpleTypes::Vml::cssptFontWeight);
if (pFind != oCssStyle.m_mapProperties.end())
{
bBold = (oCssStyle.m_arrProperties[pFind->second]->get_Value().eFontWeight >= SimpleTypes::Vml::cssfontweight400);
}
}
else if (L"shadow" == strNameP)
{
OOX::Vml::CShadow shadow; shadow.fromXML(oNodeP);
if (shadow.m_oOn.GetBool())
{
}
}
else if (L"fill" == strNameP)
{
nullable_string sOpacity;
nullable_string sOpacity2;
nullable_string sColor2;
nullable_string sColor;
nullable_string sType;
nullable_string sFocus;
nullable_string sFocusSize;
nullable_string sFocusPosition;
nullable_string sAngle;
nullable_string sColors;
XmlMacroReadAttributeBase(oNodeP, L"opacity", sOpacity);
XmlMacroReadAttributeBase(oNodeP, L"opacity2", sOpacity2);
XmlMacroReadAttributeBase(oNodeP, L"color", sColor);
XmlMacroReadAttributeBase(oNodeP, L"color2", sColor2);
XmlMacroReadAttributeBase(oNodeP, L"type", sType);
XmlMacroReadAttributeBase(oNodeP, L"focus", sFocus);
XmlMacroReadAttributeBase(oNodeP, L"focussize", sFocusSize);
XmlMacroReadAttributeBase(oNodeP, L"focusposition", sFocusPosition);
XmlMacroReadAttributeBase(oNodeP, L"angle", sAngle);
XmlMacroReadAttributeBase(oNodeP, L"colors", sColors);
if (sType.is_init())
{
if (*sType == L"gradient") eFillType = etGradFill;
else if (*sType == L"gradientradial") eFillType = etGradFill;
else if (*sType == L"pattern") eFillType = etPattFill;
else if (*sType == L"tile") eFillType = etBlipFill;
else if (*sType == L"frame") eFillType = etBlipFill;
}
else
{
if (sFocus.is_init() || sColors.is_init() || sAngle.is_init() || sFocusSize.is_init() || sFocusPosition.is_init())
eFillType = etGradFill;
}
if (sFocus.is_init())
{
nFocus = XmlUtils::GetInteger(*sFocus) / 100.0;
}
if (sOpacity.is_init())
{
bOpacity = true;
lAlpha = NS_DWC_Common::getOpacityFromString(*sOpacity);
oMod.name = L"alpha";
oMod.val = (int)((1 - lAlpha / 255.0) * 100000.0);
if (arColors.at(0)->is_init())
arColors.at(0)->Color->Modifiers.push_back(oMod);
}
if (sColor.is_init())
{
ODRAW::CColor color;
if (sColor->find(L"fill") != -1)
{
std::wstring sColorEffect = *sColor;
if (sColorEffect.length() > 5)
sColorEffect = sColorEffect.substr(5);
int resR, resG, resB;
GetColorWithEffect(sColorEffect, R, G, B, resR, resG, resB);
color.R = resR;
color.G = resG;
color.B = resB;
PPTX::Logic::UniColor *oColor = new PPTX::Logic::UniColor();
oColor->Color = new PPTX::Logic::SrgbClr();
oColor->Color->SetRGB(color.R, color.G, color.B);
if (bOpacity)
oColor->Color->Modifiers.push_back(oMod);
arColors[0] = oColor;
}
else
{
if (NS_DWC_Common::getColorFromString(*sColor, color))
{
PPTX::Logic::UniColor *oColor = new PPTX::Logic::UniColor();
oColor->Color = new PPTX::Logic::SrgbClr();
oColor->Color->SetRGB(color.R, color.G, color.B);
if (bOpacity)
oColor->Color->Modifiers.push_back(oMod);
arColors[0] = oColor;
}
}
}
if (sOpacity2.is_init())
{
bOpacity2 = true;
lAlpha = NS_DWC_Common::getOpacityFromString(*sOpacity2);
oMod.name = L"alpha";
oMod2.val = (int)((1 - lAlpha / 255.) * 100000.);
if (arColors.at(1)->is_init())
arColors.at(1)->Color->Modifiers.push_back(oMod2);
}
if (sColor2.is_init())
{
ODRAW::CColor color;
if (sColor2->find(L"fill") != -1)
{
std::wstring sColorEffect = *sColor2;
if (sColorEffect.length() > 5)
sColorEffect = sColorEffect.substr(5);
int resR, resG, resB;
GetColorWithEffect(sColorEffect, R, G, B, resR, resG, resB);
color.R = resR;
color.G = resG;
color.B = resB;
}
else
{
if (NS_DWC_Common::getColorFromString(*sColor2, color))
{
}
}
PPTX::Logic::UniColor *oColor = new PPTX::Logic::UniColor();
oColor->Color = new PPTX::Logic::SrgbClr();
oColor->Color->SetRGB(color.R, color.G, color.B);
if (bOpacity2)
oColor->Color->Modifiers.push_back(oMod2);
if (arColors.size() > 0)
arColors.push_back(oColor);
else
{
//duplication
PPTX::Logic::UniColor *oColor1 = new PPTX::Logic::UniColor();
oColor1->Color = new PPTX::Logic::SrgbClr();
oColor1->Color->SetRGB(color.R, color.G, color.B);
arColors.push_back(oColor1);
arPos.push_back(0);
arColors.push_back(oColor);
}
arPos.push_back(100000);
}
if (sAngle.is_init())
{
nAngle = XmlUtils::GetInteger(*sAngle);
nAngle = (-1) * nAngle + 90;
}
if (sColors.is_init())
{
bColors = true;
std::wstring strColors = sColors.get();
arColors.clear();
arPos.clear();
std::vector<std::wstring> arSplit;
boost::algorithm::split(arSplit, strColors, boost::algorithm::is_any_of(L";"), boost::algorithm::token_compress_on);
for (size_t i = 0; i < arSplit.size(); i++)
{
size_t p = arSplit[i].find(L" ");
if (p == std::wstring::npos)
continue;
std::wstring strPos = arSplit[i].substr(0, p);
std::wstring strColor = arSplit[i].substr(p + 1);
double pos = XmlUtils::GetDouble(strPos);
ODRAW::CColor color;
if (NS_DWC_Common::getColorFromString(strColor, color))
{
PPTX::Logic::UniColor *oColor = new PPTX::Logic::UniColor();
oColor->Color = new PPTX::Logic::SrgbClr();
oColor->Color->SetRGB(color.R, color.G, color.B);
if (pos <= 1)
pos = 100000 * pos;
else
pos = pos / 65536 * 100000;
arColors.push_back(oColor);
arPos.push_back((int)pos);
arGradMap.insert(std::make_pair((int)pos, oColor));
}
}
}
}
/*else if (L"dashstyle") == strNameP)
{
nullable_string sStrokeDashStyle;
oNodeP.ReadAttributeBase(L"dashstyle", sStrokeDashStyle);
if (sStrokeDashStyle.is_init())
{
if (*sStrokeDashStyle == L"solid"))
sDashStyle = L"solid");
else if (*sStrokeDashStyle == L"shortdash"))
sDashStyle = L"sysDash");
else if (*sStrokeDashStyle == L"shortdot"))
sDashStyle = L"sysDot");
else if (*sStrokeDashStyle == L"shortdashdot"))
sDashStyle = L"sysDashDot");
else if (*sStrokeDashStyle == L"shortdashdotdot"))
sDashStyle = L"sysDashDotDot");
else if (*sStrokeDashStyle == L"dot"))
sDashStyle = L"dot");
else if (*sStrokeDashStyle == L"dash"))
sDashStyle = L"dash");
else if (*sStrokeDashStyle == L"longdash"))
sDashStyle = L"lgDash");
else if (*sStrokeDashStyle == L"dashdot"))
sDashStyle = L"dashDot");
else if (*sStrokeDashStyle == L"longdashdot"))
sDashStyle = L"lgDashDot");
else if (*sStrokeDashStyle == L"longdashdotdot"))
sDashStyle = L"lgDashDotDot");
else
sDashStyle = L"solid");
}
}*/
}
std::wstring strRPr, strPPr;
strPPr = L"<w:jc w:val=\"center\"/><w:spacing w:after=\"0\" w:before=\"0\"/>";
if (bBold) strRPr += L"<w:b/><w:bCs/>";
if (bItalic) strRPr += L"<w:i/><w:iCs/>";
strRPr += L"<w:rFonts w:ascii=\"" + sFont + L"\" w:hAnsi=\"" + sFont + L"\"/>";
strRPr += L"<w:sz w:val=\"" + std::to_wstring(nFontSize * 2) + L"\"/><w:szCs w:val=\"" + std::to_wstring(nFontSize * 2) + L"\"/>";
nullable_string sStrokeColor;
nullable<SimpleTypes::CEmu> oStrokeWeight;
nullable_string sStroked;
XmlMacroReadAttributeBase(oNodeShape, L"strokecolor", sStrokeColor);
XmlMacroReadAttributeBase(oNodeShape, L"strokeweight", oStrokeWeight);
XmlMacroReadAttributeBase(oNodeShape, L"stroked", sStroked);
XmlUtils::CXmlNode oNodeStroke = oNodeShape.ReadNode(L"v:stroke");
if (oNodeStroke.IsValid())
{
nullable_string sStrokeOn;
XmlMacroReadAttributeBase(oNodeStroke, L"on", sStrokeOn);
if (sStrokeOn.is_init())
{
sStroked.reset();
sStroked = sStrokeOn;
}
nullable_string sStrokeColor1;
XmlMacroReadAttributeBase(oNodeStroke, L"strokecolor", sStrokeColor1);
if (sStrokeColor1.is_init())
{
sStrokeColor1.reset();
sStrokeColor = sStrokeColor1;
}
}
//textFill
strRPr += L"<w14:textFill>";
if (eFillType == etSolidFill)
{
strRPr += L"<w14:solidFill>";
strRPr += arColors.at(0)->toXML();
strRPr += L"</w14:solidFill>";
}
else if (eFillType == etGradFill)
{
strRPr += L"<w14:gradFill><w14:gsLst>";
int nSize = (int)arColors.size();
bool bRevert = false;
int nColorsLen = (int)arColors.size();
int nDiff = nSize - 1;
if (nFocus != 1 && nFocus != 0)
nSize = nSize + nDiff;
double nShift = 100000 / nSize;
double dNewZero = 100000 * nFocus;
//(0 < nFocus && nFocus < 1)
if (((nAngle == 90) && (-1 < nFocus && nFocus < 0)) || ((nAngle != 90) && (0 < nFocus && nFocus < 1)))
{
if (nAngle == 90)
dNewZero *= -1;
arColorsNew.push_back(arColors.at(nColorsLen - 1));
arPosNew.push_back(0);
for (int i = nColorsLen - 2; i > 0; i--)
{
arColorsNew.push_back(arColors.at(i));
double dPosNew = dNewZero * arPos.at(i) / 100000;
arPosNew.push_back((int)dPosNew);
}
for (int i = 0; i < nColorsLen; i++)
{
arColorsNew.push_back(arColors.at(i));
double dPosNew = dNewZero * arPos.at(i) / 100000 + dNewZero;
arPosNew.push_back((int)dPosNew);
}
}
//else if (-1 < nFocus && nFocus < 0)
else if (((nAngle != 90) && (-1 < nFocus && nFocus < 0)) || ((nAngle == 90) && (0 < nFocus && nFocus < 1)))
{
if (nAngle != 90)
dNewZero *= -1;
for (int i = 0; i < nColorsLen - 1; i++)
{
arColorsNew.push_back(arColors.at(i));
double dPosNew = dNewZero * arPos.at(i) / 100000;
arPosNew.push_back((int)dPosNew);
}
arColorsNew.push_back(arColors.at(nColorsLen - 1));
arPosNew.push_back((int)dNewZero);
for (int i = nColorsLen - 2; i >= 0; i--)
{
arColorsNew.push_back(arColors.at(i));
double n1 = 1 - (double)arPos.at(i) / 100000;
double dPosNew = dNewZero * n1 + dNewZero;
arPosNew.push_back((int)dPosNew);
}
}
//nFocus == 0
else if ((nAngle != 90 && nFocus == 0) || (nAngle == 90 && nFocus == 1))
{
for (int i = 0; i < nColorsLen; i++)
{
arColorsNew.push_back(arColors.at(i));
arPosNew.push_back(arPos.at(i));
}
}
//nFocus == 1
else if ((nAngle != 90 && nFocus == 1) || (nAngle == 90 && nFocus == 0))
{
for (int i = nColorsLen - 1; i >= 0; i--)
{
arColorsNew.push_back(arColors.at(i));
arPosNew.push_back(arPos.at(nColorsLen - i - 1));
}
}
for (size_t i = 0; i < arColorsNew.size(); i++)
{
int pos = arPosNew.at(i);
std::wstring color = arColorsNew.at(i)->toXML();
std::wstring strPos = std::to_wstring(pos);
strRPr += L"<w14:gs w14:pos = \"" + strPos + L"\">";
strRPr += color;
strRPr += L"</w14:gs>";
}
std::wstring strAngle = std::to_wstring(nAngle * 60000);
strRPr += L"</w14:gsLst><w14:lin w14:ang=\"" + strAngle + L"\" w14:scaled=\"0\"/></w14:gradFill>";
}
else if (eFillType == etNoFill)
{
strRPr += L"<w14:noFill/>";
}
else
{
//does not exist in nature
}
strRPr += L"</w14:textFill>";
//textOutline
double m_dValuePt = 1;
if (oStrokeWeight.is_init())
{
m_dValuePt = oStrokeWeight->GetValue();
}
std::wstring strStrokeW = std::to_wstring((int)Pt_To_Emu(m_dValuePt));
strRPr += L"<w14:textOutline w14:w=\"" + strStrokeW + L"\">";
smart_ptr<PPTX::Logic::SolidFill> pSolid = new PPTX::Logic::SolidFill();
pSolid->m_namespace = L"a";
pSolid->Color.Color = new PPTX::Logic::SrgbClr();
ODRAW::CColor color;
bool bStroked = true;
if (sStroked.is_init())
{
if (*sStroked == L"false" || *sStroked == L"f")
{
strRPr += L"<w14:noFill/>";
bStroked = false;
}
}
if (sStrokeColor.is_init())
{
ODRAW::CColor color;
if (NS_DWC_Common::getColorFromString(*sStrokeColor, color))
{
pSolid->Color.Color->SetRGB(color.R, color.G, color.B);
}
}
else
pSolid->Color.Color->SetRGB(0x00, 0x00, 0x00);
if (bStroked)
{
strRPr += pSolid->toXML();
pPPTShape->m_bIsStroked = false;
}
strRPr += L"</w14:textOutline>";
for (size_t i = 0; i < wordArtString.size(); i++)
{
std::vector<std::wstring> arrPara;
boost::algorithm::split(arrPara, wordArtString[i], boost::algorithm::is_any_of(L"\n"), boost::algorithm::token_compress_off);
for (const auto& p : arrPara)
{
std::wstring sParaRun = L"<w:r><w:rPr>" + strRPr + L"</w:rPr>" + L"<w:t>" + XmlUtils::EncodeXmlString(p) + L"</w:t></w:r>";
sTxbxContent += L"<w:p><w:pPr>" + strPPr + L"<w:rPr>" + strRPr + L"</w:rPr></w:pPr>" + sParaRun + L"</w:p>";
}
}
sTxbxContent += L"</w:txbxContent>";
pShape->strTextBoxShape = sTxbxContent;
if (sStroked.is_init() == false && wordArtString.empty() == false)
{
bStroked = false;
}
}
// old wordArt has no padding
pShape->oTextBoxBodyPr->lIns = 0;
pShape->oTextBoxBodyPr->tIns = 0;
pShape->oTextBoxBodyPr->rIns = 0;
pShape->oTextBoxBodyPr->bIns = 0;
if (pPPTShape->m_textPath.bFitShape || pPPTShape->m_textPath.bFitPath)
pShape->oTextBoxBodyPr->Fit.type = PPTX::Logic::TextFit::FitNormAuto;
pShape->oTextBoxBodyPr->wrap = new PPTX::Limit::TextWrap(1);
pShape->oTextBoxBodyPr->fromWordArt = true;
if (!pPPTShape->m_textPath.bTrim)
{
// need to set top and bottom padding for this shape size
// top: Ascent - CapHeight
// bottom: Descent
}
}
void CDrawingConverter::ConvertGroup(PPTX::Logic::SpTreeElem *result, XmlUtils::CXmlNode& oNode, std::wstring* pMainProps, bool bIsTop)
{
if (!result) return;
PPTX::Logic::SpTree* pTree = new PPTX::Logic::SpTree(L"wp");
if (bIsTop) pTree->m_lGroupIndex = 0;
else pTree->m_lGroupIndex = 1;
std::vector<XmlUtils::CXmlNode> oNodes;
//shape type first
if (oNode.GetNodes(L"*", oNodes))
{
size_t nCount = oNodes.size();
for (int i = 0; i < nCount; ++i)
{
XmlUtils::CXmlNode& oNodeT = oNodes[i];
std::wstring strNameP = XmlUtils::GetNameNoNS(oNodeT.GetName());
if (L"shapetype" == strNameP)
{
AddShapeType(oNodeT);
}
}
}
std::wstring strStyle = oNode.GetAttribute(L"style");
PPTX::CCSS oCSSParser;
oCSSParser.LoadFromString2(strStyle);
CSpTreeElemProps oProps;
oProps.IsTop = bIsTop;
std::wstring strMainPos = GetDrawingMainProps(oNode, oCSSParser, oProps);
if (oNode.GetNodes(L"*", oNodes))
{
size_t nCount = oNodes.size();
for (int i = 0; i < nCount; ++i)
{
XmlUtils::CXmlNode & oNodeT = oNodes[i];
std::wstring strNameP = XmlUtils::GetNameNoNS(oNodeT.GetName());
if (L"shape" == strNameP ||
L"rect" == strNameP ||
L"oval" == strNameP ||
L"line" == strNameP ||
L"polyline" == strNameP ||
L"background" == strNameP ||
L"roundrect" == strNameP)
{
PPTX::Logic::SpTreeElem _el;
ConvertShape(&_el, oNodeT, pMainProps, false);
if (_el.is_init())
pTree->SpTreeElems.push_back(_el);
}
else if (L"binData" == strNameP)
{
AddBinData(oNodeT);
}
else if (L"group" == strNameP)
{
PPTX::Logic::SpTreeElem _el;
ConvertGroup(&_el, oNodeT, pMainProps, false);
if (_el.is_init())
pTree->SpTreeElems.push_back(_el);
}
else
continue;
}
}
LONG lCoordOriginX = 0;
LONG lCoordOriginY = 0;
LONG lCoordSizeW = oProps.Width;
LONG lCoordSizeH = oProps.Height;
std::wstring strCoordSize = oNode.GetAttributeOrValue(L"coordsize");
if (strCoordSize != L"")
{
std::vector<std::wstring> oArray;
boost::algorithm::split(oArray, strCoordSize, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
if (oArray.size() >= 2)
{
lCoordSizeW = XmlUtils::GetInteger(oArray[0]);
lCoordSizeH = XmlUtils::GetInteger(oArray[1]);
}
}
std::wstring strCoordOrigin = oNode.GetAttributeOrValue(L"coordorigin");
if (strCoordOrigin != L"")
{
std::vector<std::wstring> oArray;
boost::algorithm::split(oArray, strCoordOrigin, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
if (oArray.size() >= 2)
{
lCoordOriginX = XmlUtils::GetInteger(oArray[0]);
lCoordOriginY = XmlUtils::GetInteger(oArray[1]);
}
}
if (bIsTop)
{
SendMainProps(strMainPos, pMainProps);
if (m_oxfrm_override.IsInit())
{
pTree->grpSpPr.xfrm = m_oxfrm_override;
pTree->grpSpPr.xfrm->chOffX = lCoordOriginX;
pTree->grpSpPr.xfrm->chOffY = lCoordOriginY;
pTree->grpSpPr.xfrm->chExtX = lCoordSizeW;
pTree->grpSpPr.xfrm->chExtY = lCoordSizeH;
}
else
{
pTree->grpSpPr.xfrm = new PPTX::Logic::Xfrm();
pTree->grpSpPr.xfrm->offX = 0;
pTree->grpSpPr.xfrm->offY = 0;
pTree->grpSpPr.xfrm->extX = oProps.Width;
pTree->grpSpPr.xfrm->extY = oProps.Height;
pTree->grpSpPr.xfrm->chOffX = lCoordOriginX;
pTree->grpSpPr.xfrm->chOffY = lCoordOriginY;
pTree->grpSpPr.xfrm->chExtX = lCoordSizeW;
pTree->grpSpPr.xfrm->chExtY = lCoordSizeH;
}
std::map<std::wstring, std::wstring>::iterator pFind = oCSSParser.m_mapSettings.find(L"flip");
if (oCSSParser.m_mapSettings.end() != pFind)
{
if (pFind->second == L"x")
pTree->grpSpPr.xfrm->flipH = true;
else if (pFind->second == L"y")
pTree->grpSpPr.xfrm->flipV = true;
else if ((pFind->second == L"xy") || (pFind->second == L"yx") || (pFind->second == L"x y") || (pFind->second == L"y x")
|| (pFind->second == L"y,x") || (pFind->second == L"x,y"))
{
pTree->grpSpPr.xfrm->flipH = true;
pTree->grpSpPr.xfrm->flipV = true;
}
}
pFind = oCSSParser.m_mapSettings.find(L"rotation");
if (oCSSParser.m_mapSettings.end() != pFind)
{
pTree->grpSpPr.xfrm->rot = NS_DWC_Common::getRotateAngle(pFind->second, pTree->grpSpPr.xfrm->flipH, pTree->grpSpPr.xfrm->flipV);
}
}
else
{
if (m_oxfrm_override.IsInit())
{
pTree->grpSpPr.xfrm = m_oxfrm_override;
}
else
{
pTree->grpSpPr.xfrm = new PPTX::Logic::Xfrm();
pTree->grpSpPr.xfrm->offX = oProps.X;
pTree->grpSpPr.xfrm->offY = oProps.Y;
pTree->grpSpPr.xfrm->extX = oProps.Width;
pTree->grpSpPr.xfrm->extY = oProps.Height;
pTree->grpSpPr.xfrm->chOffX = lCoordOriginX;
pTree->grpSpPr.xfrm->chOffY = lCoordOriginY;
pTree->grpSpPr.xfrm->chExtX = lCoordSizeW;
pTree->grpSpPr.xfrm->chExtY = lCoordSizeH;
}
std::map<std::wstring, std::wstring>::iterator pFind = oCSSParser.m_mapSettings.find(L"flip");
if (oCSSParser.m_mapSettings.end() != pFind)
{
if (pFind->second == L"x")
pTree->grpSpPr.xfrm->flipH = true;
else if (pFind->second == L"y")
pTree->grpSpPr.xfrm->flipV = true;
else if ((pFind->second == L"xy") || (pFind->second == L"yx") || (pFind->second == L"x y") || (pFind->second == L"y x")
|| (pFind->second == L"y,x") || (pFind->second == L"x,y"))
{
pTree->grpSpPr.xfrm->flipH = true;
pTree->grpSpPr.xfrm->flipV = true;
}
}
pFind = oCSSParser.m_mapSettings.find(L"rotation");
if (oCSSParser.m_mapSettings.end() != pFind)
{
pTree->grpSpPr.xfrm->rot = NS_DWC_Common::getRotateAngle(pFind->second, pTree->grpSpPr.xfrm->flipH, pTree->grpSpPr.xfrm->flipV);
}
}
if (!bIsTop)
{
pTree->nvGrpSpPr.cNvPr.id = m_lNextId;
m_lNextId++;
}
else
{
pTree->nvGrpSpPr.cNvPr.id = -1;
}
result->InitElem(pTree);
}
void CDrawingConverter::LoadCoordPos(XmlUtils::CXmlNode& oNode, CShapePtr pShape)
{
if (!pShape) return;
pShape->m_dXLogic = 0;
pShape->m_dYLogic = 0;
XmlUtils::CXmlNode oNodeTemplate;
if (oNode.GetNode(L"coordorigin", oNodeTemplate))
{
std::wstring strCoordSize = oNodeTemplate.GetAttributeOrValue(L"val");
if (!strCoordSize.empty())
{
std::vector<std::wstring> oArray;
boost::algorithm::split(oArray, strCoordSize, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
if (oArray.size() >= 2)
{
pShape->m_dXLogic = XmlUtils::GetInteger(oArray[0]);
pShape->m_dYLogic = XmlUtils::GetInteger(oArray[1]);
}
}
}
else
{
std::wstring strCoordSize = oNode.GetAttributeOrValue(L"coordorigin");
if (!strCoordSize.empty())
{
std::vector<std::wstring> oArray;
boost::algorithm::split(oArray, strCoordSize, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
if (oArray.size() >= 2)
{
pShape->m_dXLogic = XmlUtils::GetInteger(oArray[0]);
pShape->m_dYLogic = XmlUtils::GetInteger(oArray[1]);
}
}
}
pShape->getBaseShape()->m_oPath.SetCoordpos((LONG)pShape->m_dXLogic, (LONG)pShape->m_dYLogic);
}
void CDrawingConverter::LoadCoordSize(XmlUtils::CXmlNode& oNode, CShapePtr pShape)
{
if (!pShape) return;
pShape->m_dWidthLogic = ShapeSizeVML;
pShape->m_dHeightLogic = ShapeSizeVML;
XmlUtils::CXmlNode oNodeTemplate;
if (oNode.GetNode(L"coordsize", oNodeTemplate))
{
std::wstring strCoordSize = oNodeTemplate.GetAttributeOrValue(L"val");
if (!strCoordSize.empty())
{
std::vector<std::wstring> oArray;
boost::algorithm::split(oArray, strCoordSize, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
if (oArray.size() >= 2)
{
pShape->m_dWidthLogic = (std::max)(XmlUtils::GetInteger(oArray[0]), 1);
pShape->m_dHeightLogic = (std::max)(XmlUtils::GetInteger(oArray[1]), 1);
}
}
}
else
{
std::wstring strCoordSize = oNode.GetAttributeOrValue(L"coordsize");
if (!strCoordSize.empty())
{
std::vector<std::wstring> oArray;
boost::algorithm::split(oArray, strCoordSize, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
if (oArray.size() >= 2)
{
pShape->m_dWidthLogic = (std::max)(XmlUtils::GetInteger(oArray[0]), 1);
pShape->m_dHeightLogic = (std::max)(XmlUtils::GetInteger(oArray[1]), 1);
}
}
}
pShape->getBaseShape()->m_oPath.SetCoordsize((LONG)pShape->m_dWidthLogic, (LONG)pShape->m_dHeightLogic);
}
std::wstring CDrawingConverter::GetDrawingMainProps(XmlUtils::CXmlNode& oNode, PPTX::CCSS& oCssStyles, CSpTreeElemProps& oProps)
{
std::map<std::wstring, std::wstring>::iterator pFind;
bool bIsInline = false;
bool bIsMargin = false;
bool bZIndex = false;
if (oCssStyles.m_mapSettings.end() != oCssStyles.m_mapSettings.find(L"z-index"))
bZIndex = true;
if (oProps.IsTop == true)
{
if ((oCssStyles.m_mapSettings.end() == oCssStyles.m_mapSettings.find(L"left")) &&
(oCssStyles.m_mapSettings.end() == oCssStyles.m_mapSettings.find(L"margin-left")) &&
(oCssStyles.m_mapSettings.end() == oCssStyles.m_mapSettings.find(L"top")) &&
(oCssStyles.m_mapSettings.end() == oCssStyles.m_mapSettings.find(L"margin-top")))
{
bIsInline = true;
}
if (((oCssStyles.m_mapSettings.end() != oCssStyles.m_mapSettings.find(L"margin-left")) &&
(oCssStyles.m_mapSettings.end() != oCssStyles.m_mapSettings.find(L"margin-top")))
||
((oCssStyles.m_mapSettings.end() != oCssStyles.m_mapSettings.find(L"left")) &&
(oCssStyles.m_mapSettings.end() != oCssStyles.m_mapSettings.find(L"top"))))
{
bIsMargin = true;
}
pFind = oCssStyles.m_mapSettings.find(L"mso-position-horizontal-relative");
if (oCssStyles.m_mapSettings.end() != pFind && ((pFind->second == L"text" && !bIsMargin) || pFind->second == L"char"))
{
pFind = oCssStyles.m_mapSettings.find(L"mso-position-vertical-relative");
if (oCssStyles.m_mapSettings.end() != pFind && ((pFind->second == L"text" && !bIsMargin) || pFind->second == L"line"))
{
if (!bZIndex || !bIsMargin) //Liturgie Homberg 2017 mit Abendmahlsteil.docx
bIsInline = true;
}
}
if (!bIsInline)
{
pFind = oCssStyles.m_mapSettings.find(L"position");
if (oCssStyles.m_mapSettings.end() != pFind && pFind->second == L"static")
{
bIsInline = true;
}
}
}
SimpleTypes::CPoint parserPoint;
double dKoef = 25.4 * 36000 / 72.0;
double dKoefSize = oProps.IsTop ? dKoef : 1;
LONG left = 0;
LONG top = 0;
LONG width = 0;
LONG height = 0;
if (!bIsInline)
{
pFind = oCssStyles.m_mapSettings.find(L"margin-left");
if (oCssStyles.m_mapSettings.end() == pFind)
pFind = oCssStyles.m_mapSettings.find(L"left");
if (oCssStyles.m_mapSettings.end() != pFind)
{
std::vector<std::wstring> oArray1;
boost::algorithm::split(oArray1, pFind->second, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
for (size_t i = 0; i < oArray1.size(); i++)
{
left += (LONG)(dKoefSize * parserPoint.FromString(oArray1[i]) + 0.5);
}
}
pFind = oCssStyles.m_mapSettings.find(L"margin-top");
if (oCssStyles.m_mapSettings.end() == pFind)
pFind = oCssStyles.m_mapSettings.find(L"top");
if (oCssStyles.m_mapSettings.end() != pFind)
{
std::vector<std::wstring> oArray1;
boost::algorithm::split(oArray1, pFind->second, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
for (size_t i = 0; i < oArray1.size(); i++)
{
top += (LONG)(dKoefSize * parserPoint.FromString(oArray1[i]) + 0.5);
}
}
}
pFind = oCssStyles.m_mapSettings.find(L"width");
if (oCssStyles.m_mapSettings.end() != pFind)
{
width = (LONG)(dKoefSize * parserPoint.FromString(pFind->second) + 0.5);
}
else
{
pFind = oCssStyles.m_mapSettings.find(L"margin-right");
if (oCssStyles.m_mapSettings.end() != oCssStyles.m_mapSettings.end())
width = (LONG)(dKoefSize * parserPoint.FromString(pFind->second) + 0.5) - left;
}
pFind = oCssStyles.m_mapSettings.find(L"height");
if (oCssStyles.m_mapSettings.end() != pFind)
{
height = (LONG)(dKoefSize * parserPoint.FromString(pFind->second) + 0.5);
}
else
{
pFind = oCssStyles.m_mapSettings.find(L"margin-bottom");
if (oCssStyles.m_mapSettings.end() != oCssStyles.m_mapSettings.end())
height = (LONG)(dKoefSize * parserPoint.FromString(pFind->second) + 0.5) - top;
}
unsigned long margL = (unsigned long)(9 * dKoef + 0.5);
unsigned long margT = 0;
unsigned long margR = (unsigned long)(9 * dKoef + 0.5);
unsigned long margB = 0;
pFind = oCssStyles.m_mapSettings.find(L"mso-wrap-distance-left");
if (oCssStyles.m_mapSettings.end() != pFind)
margL = (unsigned long)(dKoef * parserPoint.FromString(pFind->second) + 0.5);
pFind = oCssStyles.m_mapSettings.find(L"mso-wrap-distance-top");
if (oCssStyles.m_mapSettings.end() != pFind)
margT = (unsigned long)(dKoef * parserPoint.FromString(pFind->second) + 0.5);
pFind = oCssStyles.m_mapSettings.find(L"mso-wrap-distance-right");
if (oCssStyles.m_mapSettings.end() != pFind)
margR = (unsigned long)(dKoef * parserPoint.FromString(pFind->second) + 0.5);
pFind = oCssStyles.m_mapSettings.find(L"mso-wrap-distance-bottom");
if (oCssStyles.m_mapSettings.end() != pFind)
margB = (unsigned long)(dKoef * parserPoint.FromString(pFind->second) + 0.5);
nullable_double rel_width;
nullable_double rel_height;
nullable_double rel_top;
nullable_double rel_left;
pFind = oCssStyles.m_mapSettings.find(L"mso-width-percent");
if (oCssStyles.m_mapSettings.end() != pFind)
{
rel_width = parserPoint.FromString(pFind->second) / 1000.;
}
pFind = oCssStyles.m_mapSettings.find(L"mso-height-percent");
if (oCssStyles.m_mapSettings.end() != pFind)
{
rel_height = parserPoint.FromString(pFind->second) / 1000.;
}
pFind = oCssStyles.m_mapSettings.find(L"mso-top-percent");
if (oCssStyles.m_mapSettings.end() != pFind)
{
rel_top = parserPoint.FromString(pFind->second) / 1000.;
}
pFind = oCssStyles.m_mapSettings.find(L"mso-left-percent");
if (oCssStyles.m_mapSettings.end() != pFind)
{
rel_left = parserPoint.FromString(pFind->second) / 1000.;
}
oProps.X = left;
oProps.Y = top;
oProps.Width = width;
oProps.Height = height;
if (oProps.IsTop)
{
m_pBinaryWriter->SetCurShapeSize(width, height);
}
bool bExtendedSize = false;
XmlUtils::CXmlNode oNodeShadow = oNode.ReadNode(L"v:shadow");
std::wstring strShadow;
if (oNodeShadow.IsValid())
{
OOX::Vml::CShadow shadow; shadow.fromXML(oNodeShadow);
if (shadow.m_oOn.GetBool())
{
bExtendedSize = true;
}
}
std::wstring originalId = oNode.ReadAttribute(L"id");
if (bIsInline)
{
NSBinPptxRW::CXmlWriter oWriter;
oWriter.StartNode(L"wp:inline");
oWriter.StartAttributes();
oWriter.WriteAttribute(L"xmlns:wp", L"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing");
oWriter.WriteAttribute(L"distT", margT);
oWriter.WriteAttribute(L"distB", margB);
oWriter.WriteAttribute(L"distL", margL);
oWriter.WriteAttribute(L"distR", margR);
oWriter.EndAttributes();
oWriter.StartNode(L"wp:extent");
oWriter.StartAttributes();
oWriter.WriteAttribute(L"cx", width );
oWriter.WriteAttribute(L"cy", height );
oWriter.EndAttributes();
oWriter.EndNode(L"wp:extent");
oWriter.StartNode(L"wp:effectExtent");
oWriter.StartAttributes();
oWriter.WriteAttribute(L"l", bExtendedSize ? 10795 : 0);
oWriter.WriteAttribute(L"t", bExtendedSize ? 5080 : 0);
oWriter.WriteAttribute(L"r", bExtendedSize ? 28575 : 0);
oWriter.WriteAttribute(L"b", bExtendedSize ? 26670 : 0);
oWriter.EndAttributes();
oWriter.EndNode(L"wp:effectExtent");
if (rel_width.is_init())
{
oWriter.StartNode(L"wp14:sizeRelH");
oWriter.StartAttributes();
oWriter.WriteAttribute(L"relativeFrom", L"page");
oWriter.EndAttributes();
oWriter.StartNode(L"wp14:pctWidth");
oWriter.EndAttributes();
oWriter.WriteString(std::to_wstring((INT)(*rel_width * 100000)));
oWriter.EndNode(L"wp14:pctWidth");
oWriter.EndNode(L"wp14:sizeRelH");
}
if (rel_height.is_init())
{
oWriter.StartNode(L"wp14:sizeRelV");
oWriter.StartAttributes();
oWriter.WriteAttribute(L"relativeFrom", L"page");
oWriter.EndAttributes();
oWriter.StartNode(L"wp14:pctHeight");
oWriter.EndAttributes();
oWriter.WriteString(std::to_wstring((INT)(*rel_height * 100000)));
oWriter.EndNode(L"wp14:pctHeight");
oWriter.EndNode(L"wp14:sizeRelV");
}
std::wstring strId = L"<wp:docPr id=\"" + std::to_wstring(m_lNextId) + L"\" name=\"" + originalId + L"\"/>";
m_lNextId++;
oWriter.WriteString(strId);
oWriter.EndNode(L"wp:inline");
return oWriter.GetXmlString();
}
//------------------------------------------------------------------------------------
NSBinPptxRW::CXmlWriter oWriter;
oWriter.StartNode(L"wp:anchor");
oWriter.StartAttributes();
oWriter.WriteAttribute(L"xmlns:wp", L"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing");
oWriter.WriteAttribute(L"distT", margT);
oWriter.WriteAttribute(L"distB", margB);
oWriter.WriteAttribute(L"distL", margL);
oWriter.WriteAttribute(L"distR", margR);
pFind = oCssStyles.m_mapSettings.find(L"z-index");
nullable_int64 zIndex;
if (oCssStyles.m_mapSettings.end() != pFind)
{
zIndex = (__int64)parserPoint.FromString(pFind->second);
_INT64 zIndex_ = *zIndex;// >= 0 ? *zIndex : -*zIndex;
if (m_nDrawingMaxZIndex == 0 && ((zIndex_ < 0xF000000 && zIndex_ > 0x80000) ||
(zIndex_ > -0xF000000 && zIndex_ < -0x80000)))
{
zIndex_ = 0xF000000 - 0x80000 + zIndex_;
}
else
{
zIndex_ = abs(zIndex_);
}
oWriter.WriteAttribute(L"relativeHeight", std::to_wstring(zIndex_));
}
XmlUtils::CXmlNode oNodeWrap = oNode.ReadNode(L"w10:wrap");
std::wstring strWrapType;
if (oNodeWrap.IsValid())
{
strWrapType = oNodeWrap.GetAttribute(L"type");
/*
nullable_string sAnchorX;
oNodeWrap.ReadAttributeBase(L"anchorx", sAnchorX);
nullable_string sAnchorY;
oNodeWrap.ReadAttributeBase(L"anchory", sAnchorY);
if (sAnchorX.is_init())
oCssStyles.m_mapSettings.insert(std::pair<>(L"mso-position-horizontal-relative"), *sAnchorX);
if (sAnchorY.is_init())
oCssStyles.m_mapSettings.insert(std::pair<>(L"mso-position-vertical-relative"), *sAnchorY);
*/
}
nullable_bool isAllowInCell;
nullable_string sAllowInCell;
XmlMacroReadAttributeBase(oNode, L"o:allowincell", sAllowInCell);
if (sAllowInCell.is_init())
{
if ((L"f" == *sAllowInCell) || (L"false"== *sAllowInCell))
isAllowInCell = false;
if ((L"t" == *sAllowInCell) || (L"true"== *sAllowInCell))
isAllowInCell = true;
}
nullable_bool isAllowOverlap;
nullable_string sAllowOverlap;
XmlMacroReadAttributeBase(oNode, L"o:allowoverlap", sAllowOverlap);
if (sAllowOverlap.is_init())
{
if ((L"f" == *sAllowOverlap) || (L"false"== *sAllowOverlap))
isAllowOverlap = false;
if ((L"t" == *sAllowOverlap) || (L"true"== *sAllowOverlap))
isAllowOverlap = true;
}
std::wstring strWrapPoints = oNode.GetAttribute(L"wrapcoords");
std::wstring strWrapPointsResult;
if (!strWrapPoints.empty())
{
std::vector<std::wstring> arPoints;
boost::algorithm::split(arPoints, strWrapPoints, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
int nCountP = (int)arPoints.size();
if (nCountP > 1 && ((nCountP % 2) == 0))
{
strWrapPointsResult = L"<wp:wrapPolygon edited=\"1\">";
for (int i = 0; i < nCountP; i += 2)
{
if (i == 0)
{
strWrapPointsResult += (L"<wp:start x=\"" + arPoints[i] + L"\" y=\"" + arPoints[i + 1] + L"\"/>");
}
else
{
strWrapPointsResult += (L"<wp:lineTo x=\"" + arPoints[i] + L"\" y=\"" + arPoints[i + 1] + L"\"/>");
}
}
strWrapPointsResult += L"</wp:wrapPolygon>";
}
}
if (zIndex.is_init())
{
if (*zIndex > 0)
{
oWriter.WriteAttribute(L"behindDoc", L"0");
}
else if (*zIndex < 0)
{
oWriter.WriteAttribute(L"behindDoc", L"1");
}
}
if (isAllowOverlap.is_init())
{
if (*isAllowOverlap)
oWriter.WriteAttribute(L"allowOverlap", L"1");
else
oWriter.WriteAttribute(L"allowOverlap", L"0");
}
if (isAllowInCell.is_init())
{
if (*isAllowInCell)
oWriter.WriteAttribute(L"layoutInCell", L"1");
else
oWriter.WriteAttribute(L"layoutInCell", L"0");
}
oWriter.EndAttributes();
oWriter.StartNode(L"wp:positionH");
oWriter.StartAttributes();
pFind = oCssStyles.m_mapSettings.find(L"mso-position-horizontal-relative");
nullable_string sHRelativeFrom;
nullable_string sVRelativeFrom;
if (pFind != oCssStyles.m_mapSettings.end())
{
if (L"char" == pFind->second) sHRelativeFrom = L"character";
else if (L"page" == pFind->second) sHRelativeFrom = L"page";
else if (L"margin" == pFind->second) sHRelativeFrom = L"margin";
else if (L"left-margin-area" == pFind->second) sHRelativeFrom = L"leftMargin";
else if (L"right-margin-area" == pFind->second) sHRelativeFrom = L"rightMargin";
else if (L"inner-margin-area" == pFind->second) sHRelativeFrom = L"insideMargin";
else if (L"outer-margin-area" == pFind->second) sHRelativeFrom = L"outsideMargin";
else
sHRelativeFrom = L"column";
}
else
{
sHRelativeFrom = L"column";
}
oWriter.WriteAttribute(L"relativeFrom", *sHRelativeFrom);
oWriter.EndAttributes();
std::wstring strPosH = L"absolute";
pFind = oCssStyles.m_mapSettings.find(L"mso-position-horizontal");
if (oCssStyles.m_mapSettings.end() != pFind)
strPosH = pFind->second;
if (strPosH == L"absolute")
{
if (rel_left.is_init())
{
oWriter.WriteString(L"<wp14:pctPosHOffset>");
oWriter.WriteLONG((INT)(*rel_left * 100000));
oWriter.WriteString(L"</wp14:pctPosHOffset>");
}
else
{
oWriter.WriteString(L"<wp:posOffset>");
oWriter.WriteLONG(left);
oWriter.WriteString(L"</wp:posOffset>");
}
}
else
{
oWriter.WriteString(L"<wp:align>");
oWriter.WriteString(strPosH);
oWriter.WriteString(L"</wp:align>");
}
oWriter.EndNode(L"wp:positionH");
oWriter.StartNode(L"wp:positionV");
oWriter.StartAttributes();
pFind = oCssStyles.m_mapSettings.find(L"mso-position-vertical-relative");
if (pFind != oCssStyles.m_mapSettings.end())
{
if (L"margin" == pFind->second) sVRelativeFrom = L"margin";
else if (L"text" == pFind->second) sVRelativeFrom = L"paragraph";
else if (L"page" == pFind->second) sVRelativeFrom = L"page";
else if (L"top-margin-area" == pFind->second) sVRelativeFrom = L"topMargin";
else if (L"bottom-margin-area" == pFind->second) sVRelativeFrom = L"bottomMargin";
else if (L"inner-margin-area" == pFind->second) sVRelativeFrom = L"insideMargin";
else if (L"outer-margin-area" == pFind->second) sVRelativeFrom = L"outsideMargin";
else
sVRelativeFrom = L"line";
}
else
{
sVRelativeFrom = L"paragraph";
}
oWriter.WriteAttribute(L"relativeFrom", *sVRelativeFrom);
oWriter.EndAttributes();
std::wstring strPosV = L"absolute";
pFind = oCssStyles.m_mapSettings.find(L"mso-position-vertical");
if (oCssStyles.m_mapSettings.end() != pFind)
strPosV = pFind->second;
if (strPosV == L"absolute")
{
if (rel_top.is_init())
{
oWriter.WriteString(L"<wp14:pctPosVOffset>");
oWriter.WriteLONG((INT)(*rel_top * 100000));
oWriter.WriteString(L"</wp14:pctPosVOffset>");
}
else
{
oWriter.WriteString(L"<wp:posOffset>");
oWriter.WriteLONG(top);
oWriter.WriteString(L"</wp:posOffset>");
}
}
else
{
oWriter.WriteString(L"<wp:align>");
oWriter.WriteString(strPosV);
oWriter.WriteString(L"</wp:align>");
}
oWriter.EndNode(L"wp:positionV");
oWriter.StartNode(L"wp:extent");
oWriter.StartAttributes();
oWriter.WriteAttribute(L"cx", width );
oWriter.WriteAttribute(L"cy", height);
oWriter.EndAttributes();
oWriter.EndNode(L"wp:extent");
oWriter.StartNode(L"wp:effectExtent");
oWriter.StartAttributes();
oWriter.WriteAttribute(L"l", bExtendedSize ? 10795 : 0);
oWriter.WriteAttribute(L"t", bExtendedSize ? 5080 : 0);
oWriter.WriteAttribute(L"r", bExtendedSize ? 28575 : 0);
oWriter.WriteAttribute(L"b", bExtendedSize ? 26670 : 0);
oWriter.EndAttributes();
oWriter.EndNode(L"wp:effectExtent");
if (oNodeWrap.IsValid())
{
if (strWrapType == L"none" || strWrapType == L"")
oWriter.WriteString(L"<wp:wrapNone/>");
else if (strWrapType == L"square")
oWriter.WriteString(L"<wp:wrapSquare wrapText=\"bothSides\"/>");
else if (strWrapType == L"topAndBottom")
oWriter.WriteString(L"<wp:wrapTopAndBottom/>");
else if (strWrapType == L"tight")
{
if (strWrapPointsResult.empty())
{
oWriter.WriteString(L"<wp:wrapTight wrapText=\"bothSides\"/>");
}
else
{
oWriter.WriteString(L"<wp:wrapTight wrapText=\"bothSides\">");
oWriter.WriteString(strWrapPointsResult);
oWriter.WriteString(L"</wp:wrapTight>");
}
}
else if (strWrapType == L"through")
{
if (strWrapPointsResult.empty())
{
oWriter.WriteString(L"<wp:wrapThrough wrapText=\"bothSides\"/>");
}
else
{
oWriter.WriteString(L"<wp:wrapThrough wrapText=\"bothSides\">");
oWriter.WriteString(strWrapPointsResult);
oWriter.WriteString(L"</wp:wrapThrough>");
}
}
else
oWriter.WriteString(L"<wp:wrapSquare wrapText=\"bothSides\"/>");
}
else
{
oWriter.WriteString(L"<wp:wrapNone/>");
}
bool bHidden = false;
pFind = oCssStyles.m_mapSettings.find(L"visibility");
if (oCssStyles.m_mapSettings.end() != pFind)
{
if (L"hidden" == pFind->second)
bHidden = true;
}
if (rel_width.is_init())
{
oWriter.StartNode(L"wp14:sizeRelH");
oWriter.StartAttributes();
oWriter.WriteAttribute(L"relativeFrom", *sHRelativeFrom);
oWriter.EndAttributes();
oWriter.StartNode(L"wp14:pctWidth");
oWriter.EndAttributes();
oWriter.WriteString(std::to_wstring((INT)(*rel_width * 100000)));
oWriter.EndNode(L"wp14:pctWidth");
oWriter.EndNode(L"wp14:sizeRelH");
}
if (rel_height.is_init())
{
oWriter.StartNode(L"wp14:sizeRelV");
oWriter.StartAttributes();
oWriter.WriteAttribute(L"relativeFrom", *sVRelativeFrom);
oWriter.EndAttributes();
oWriter.StartNode(L"wp14:pctHeight");
oWriter.EndAttributes();
oWriter.WriteString(std::to_wstring((INT)(*rel_height * 100000)));
oWriter.EndNode(L"wp14:pctHeight");
oWriter.EndNode(L"wp14:sizeRelV");
}
nullable_string alt_content;
XmlMacroReadAttributeBase(oNode, L"alt", alt_content);
std::wstring strId = L"<wp:docPr id=\"" + std::to_wstring(m_lNextId) +
L"\" name=\"" + originalId + L"\"" +
(alt_content.IsInit() ? L" descr=\"" + *alt_content + L"\"" : L"") +
(bHidden ? L" hidden=\"true\"" : L"") + L"/>";
m_lNextId++;
oWriter.WriteString(strId);
oWriter.EndNode(L"wp:anchor");
return oWriter.GetXmlString();
}
void CDrawingConverter::SendMainProps(const std::wstring& strMainProps, std::wstring* pMainProps)
{
if (pMainProps && ((m_pBinaryWriter) && (m_pBinaryWriter->m_pDocxSerializer)) || !m_pBinaryWriter)
{
*pMainProps = strMainProps;
}
}
void CDrawingConverter::CheckEffectShape(PPTX::Logic::SpTreeElem* oElem, XmlUtils::CXmlNode& oNode, CPPTShape* pPPTShape)
{
if (!oElem) return;
PPTX::Logic::Shape* pShape = dynamic_cast<PPTX::Logic::Shape*> (oElem->GetElem().operator ->());
PPTX::Logic::Pic* pPicture = dynamic_cast<PPTX::Logic::Pic*> (oElem->GetElem().operator ->());
PPTX::Logic::SpPr* pSpPr = NULL;
if (pShape) pSpPr = &pShape->spPr;
if (pPicture) pSpPr = &pPicture->spPr;
if (!pSpPr) return;
XmlUtils::CXmlNode oNodeShadow = oNode.ReadNode(L"v:shadow");
SimpleTypes::CTrueFalse bShadowEnabled = SimpleTypes::booleanFalse;
if (oNodeShadow.IsValid())
{
XmlMacroReadAttributeBase(oNodeShadow, L"on", bShadowEnabled);
}
if (bShadowEnabled.GetBool())
{
nullable<SimpleTypes::CColorType> oColor;
nullable<SimpleTypes::CColorType> oColor2;
nullable_string oId;
nullable<SimpleTypes::Vml::CVml_Matrix> oMatrix;
nullable<SimpleTypes::CTrueFalse> oObscured;
nullable<SimpleTypes::Vml::CVml_Vector2D_Units_Or_Percentage> oOffset;
nullable<SimpleTypes::Vml::CVml_Vector2D_Units_Or_Percentage> oOffset2;
nullable<SimpleTypes::Vml::CVml_1_65536> oOpacity;
nullable<SimpleTypes::Vml::CVml_Vector2D_Percentage> oOrigin;
SimpleTypes::CShadowType oType;
XmlMacroReadAttributeBase(oNodeShadow, L"id", oId);
XmlMacroReadAttributeBase(oNodeShadow, L"type", oType);
XmlMacroReadAttributeBase(oNodeShadow, L"color", oColor);
XmlMacroReadAttributeBase(oNodeShadow, L"opacity", oOpacity);
XmlMacroReadAttributeBase(oNodeShadow, L"offset", oOffset);
XmlMacroReadAttributeBase(oNodeShadow, L"origin", oOrigin);
XmlMacroReadAttributeBase(oNodeShadow, L"obscured", oObscured);
XmlMacroReadAttributeBase(oNodeShadow, L"color2", oColor2);
XmlMacroReadAttributeBase(oNodeShadow, L"offset2", oOffset2);
XmlMacroReadAttributeBase(oNodeShadow, L"matrix", oMatrix);
if (false == pSpPr->EffectList.is_init())
pSpPr->EffectList.List = new PPTX::Logic::EffectLst();
PPTX::Logic::EffectLst* pEffectLst = dynamic_cast<PPTX::Logic::EffectLst*>(pSpPr->EffectList.List.GetPointer());
pEffectLst->outerShdw.Init();
pEffectLst->outerShdw->Color.Color = new PPTX::Logic::SrgbClr();
if (oColor.IsInit())
pEffectLst->outerShdw->Color.Color->SetRGB(oColor->Get_R(), oColor->Get_G(), oColor->Get_B());
else
pEffectLst->outerShdw->Color.Color->SetRGB(0x80, 0x80, 0x80);
if (oOpacity.is_init())
{
BYTE lAlpha = oOpacity->GetValue() * 255;
PPTX::Logic::ColorModifier oMod;
oMod.name = L"alpha";
int nA = (int)(lAlpha * 100000.0 / 255.0);
oMod.val = nA;
pEffectLst->outerShdw->Color.Color->Modifiers.push_back(oMod);
}
if (oOffset.IsInit())
{
double offsetX = oOffset->IsXinPoints() ? oOffset->GetX() : 0;
double offsetY = oOffset->IsYinPoints() ? oOffset->GetY() : 0;
double dist = sqrt(offsetX * offsetX + offsetY * offsetY);
double dir = ((offsetX != 0) ? atan(offsetY / offsetX) : 1) * 180. / 3.1415926;
if (offsetX < 0) dir += 180;
if (dir < 0) dir += 360;
pEffectLst->outerShdw->dist = dist * (635 * 20);
pEffectLst->outerShdw->dir = (int)(dir * 60000);
}
pEffectLst->outerShdw->rotWithShape = false;
if (oMatrix.IsInit())
{
if (oMatrix->m_dSxx > 1.001 || oMatrix->m_dSxx < 0.999)
pEffectLst->outerShdw->sx = (int)(oMatrix->m_dSxx / 65535. * 100000);
if (oMatrix->m_dSyy > 1.001 || oMatrix->m_dSyy < 0.999)
pEffectLst->outerShdw->sy = (int)(oMatrix->m_dSyy / 65535. * 100000);
if (oMatrix->m_dSxy > 0.001 || oMatrix->m_dSxy < 0)
pEffectLst->outerShdw->ky = (int)(oMatrix->m_dSxy / 65535. * 100000);
if (oMatrix->m_dSyx > 0.001 || oMatrix->m_dSyx < 0)
pEffectLst->outerShdw->kx = (int)(oMatrix->m_dSyx / 65535. * 100000);
}
}
}
void CDrawingConverter::CheckBorderShape(PPTX::Logic::SpTreeElem* oElem, XmlUtils::CXmlNode& oNode, CPPTShape* pPPTShape)
{
if (!oElem) return;
PPTX::Logic::Shape* pShape = dynamic_cast<PPTX::Logic::Shape*> (oElem->GetElem().operator ->());
PPTX::Logic::Pic* pPicture = dynamic_cast<PPTX::Logic::Pic*> (oElem->GetElem().operator ->());
PPTX::Logic::SpPr *pSpPr = NULL;
if (pShape) pSpPr = &pShape->spPr;
if (pPicture) pSpPr = &pPicture->spPr;
if (!pSpPr) return;
if ( (pSpPr->ln.IsInit()) && (pSpPr->ln->Fill.m_type != PPTX::Logic::UniFill::noFill) )
return; //duplication with line framing
nullable_string sColorBorder;
XmlMacroReadAttributeBase(oNode, L"o:borderleftcolor", sColorBorder);
XmlUtils::CXmlNode oNodeBorder = oNode.ReadNode(L"w10:borderleft");
if (oNodeBorder.IsValid())
{
nullable_string sTypeBorder;
XmlMacroReadAttributeBase(oNodeBorder, L"type", sTypeBorder);
SimpleTypes::CBorderType borderType;
if (sTypeBorder.IsInit())
{
borderType.FromString(sTypeBorder.get());
}
if (borderType.GetValue() != SimpleTypes::bordertypeNone)
{
pSpPr->ln.Init();
nullable_int nWidthBorder;
XmlMacroReadAttributeBase(oNodeBorder, L"width", nWidthBorder);
if (borderType.GetValue() > 0 &&
borderType.GetValue() < 6)
{
pSpPr->ln->prstDash.Init();
pSpPr->ln->prstDash->val = new PPTX::Limit::PrstDashVal();
switch(borderType.GetValue())
{
case SimpleTypes::bordertypeDash: pSpPr->ln->prstDash->val->SetBYTECode(3); break;
case SimpleTypes::bordertypeDashDotDot: pSpPr->ln->prstDash->val->SetBYTECode(5); break;
case SimpleTypes::bordertypeDashDotStroked: pSpPr->ln->prstDash->val->SetBYTECode(1); break;
case SimpleTypes::bordertypeDashedSmall: pSpPr->ln->prstDash->val->SetBYTECode(0); break;
case SimpleTypes::bordertypeDot: pSpPr->ln->prstDash->val->SetBYTECode(2); break;
case SimpleTypes::bordertypeDotDash: pSpPr->ln->prstDash->val->SetBYTECode(1); break;
}
}
if (nWidthBorder.IsInit())
{
pSpPr->ln->w = (int)(*nWidthBorder * g_emu_koef);//pt to emu
}
if (sColorBorder.IsInit())
{
PPTX::Logic::SolidFill* pSolid = new PPTX::Logic::SolidFill();
pSolid->m_namespace = L"a";
pSolid->Color.Color = new PPTX::Logic::SrgbClr();
if (std::wstring::npos != sColorBorder->find(L"#"))
{
pSolid->Color.Color->SetHexString(sColorBorder->substr(1));
}
else
{
//"red", L"black" , .. to color
}
pSpPr->ln->Fill.m_type = PPTX::Logic::UniFill::solidFill;
pSpPr->ln->Fill.Fill = pSolid;
}
}
}
}
void CDrawingConverter::ConvertColor(PPTX::Logic::UniColor & uniColor, nullable_string & sColor, nullable_string& sOpacity)
{
int R = uniColor.is_init() ? uniColor.Color->red : 255;
int G = uniColor.is_init() ? uniColor.Color->green : 255;
int B = uniColor.is_init() ? uniColor.Color->blue : 255;
uniColor.Color = new PPTX::Logic::SrgbClr();
if (sColor.is_init())
{
ODRAW::CColor color;
if (sColor.is_init() && (std::wstring::npos != sColor->find(L"fill")))
{
std::wstring sColorEffect = *sColor;
if (sColorEffect.length() > 5)
sColorEffect = sColorEffect.substr(5);
int resR, resG, resB;
GetColorWithEffect(sColorEffect, R, G, B, resR, resG, resB);
R = resR;
G = resG;
B = resB;
}
else
{
if (NS_DWC_Common::getColorFromString(*sColor, color))
{
R = color.R;
G = color.G;
B = color.B;
}
}
}
uniColor.Color->SetRGB(R, G, B);
if (sOpacity.is_init())
{
BYTE lAlpha = NS_DWC_Common::getOpacityFromString(*sOpacity);
PPTX::Logic::ColorModifier oMod;
oMod.name = L"alpha";
int nA = (int)(lAlpha * 100000.0 / 255.0);
oMod.val = nA;
uniColor.Color->Modifiers.push_back(oMod);
}
}
void CDrawingConverter::CheckBrushShape(PPTX::Logic::SpTreeElem* oElem, XmlUtils::CXmlNode& oNode, CPPTShape* pPPTShape)
{
if (!oElem) return;
PPTX::Logic::Shape* pShape = dynamic_cast<PPTX::Logic::Shape*> (oElem->GetElem().operator ->());
PPTX::Logic::Pic* pPicture = dynamic_cast<PPTX::Logic::Pic*> (oElem->GetElem().operator ->());
PPTX::Logic::SpPr* pSpPr = NULL;
if (pShape) pSpPr = &pShape->spPr;
if (pPicture) pSpPr = &pPicture->spPr;
if (!pSpPr) return;
int R = 255;
int G = 255;
int B = 255;
nullable_string sFillColor;
XmlMacroReadAttributeBase(oNode, L"fillcolor", sFillColor);
if (sFillColor.is_init() && !pPPTShape->IsWordArt())
{
ODRAW::CColor color;
if (NS_DWC_Common::getColorFromString(*sFillColor, color))
{
PPTX::Logic::SolidFill* pSolid = new PPTX::Logic::SolidFill();
pSolid->m_namespace = L"a";
pSolid->Color.Color = new PPTX::Logic::SrgbClr();
pSolid->Color.Color->SetRGB(color.R, color.G, color.B);
pSpPr->Fill.m_type = PPTX::Logic::UniFill::solidFill;
pSpPr->Fill.Fill = pSolid;
}
}
else if (!pPPTShape->IsWordArt())
{
// default fillcolor in vml = white
PPTX::Logic::SolidFill* pSolid = new PPTX::Logic::SolidFill();
pSolid->m_namespace = L"a";
pSolid->Color.Color = new PPTX::Logic::SrgbClr();
pSolid->Color.Color->SetRGB(R, G, B);
pSpPr->Fill.m_type = PPTX::Logic::UniFill::solidFill;
pSpPr->Fill.Fill = pSolid;
}
nullable_string sFilled;
XmlMacroReadAttributeBase(oNode, L"filled", sFilled);
if (sFilled.is_init())
{
if (*sFilled == L"false" || *sFilled == L"f")
{
PPTX::Logic::NoFill* pNoFill = new PPTX::Logic::NoFill();
pNoFill->m_namespace = L"a";
pSpPr->Fill.m_type = PPTX::Logic::UniFill::noFill;
pSpPr->Fill.Fill = pNoFill;
pPPTShape->m_bIsFilled = false;
}
else
pPPTShape->m_bIsFilled = true; // change parent ShapeType
}
else if (!pPPTShape->m_bIsFilled) // from parent ShapeType
{
PPTX::Logic::NoFill* pNoFill = new PPTX::Logic::NoFill();
pNoFill->m_namespace = L"a";
pSpPr->Fill.m_type = PPTX::Logic::UniFill::noFill;
pSpPr->Fill.Fill = pNoFill;
}
nullable_string sColor = sFillColor;
nullable_string sOpacity;
XmlMacroReadAttributeBase(oNode, L"opacity", sOpacity);
if (sOpacity.is_init())
{
BYTE lAlpha = NS_DWC_Common::getOpacityFromString(*sOpacity);
if (pSpPr->Fill.is<PPTX::Logic::SolidFill>())
{
PPTX::Logic::ColorModifier oMod;
oMod.name = L"alpha";
int nA = (int)(lAlpha * 100000.0 / 255.0);
oMod.val = nA;
pSpPr->Fill.as<PPTX::Logic::SolidFill>().Color.Color->Modifiers.push_back(oMod);
}
}
XmlUtils::CXmlNode oNodeFill = oNode.ReadNode(L"v:fill");
if (pPPTShape->m_bIsFilled && oNodeFill.IsValid() && !pPPTShape->IsWordArt())
{
nullable_string sOpacity2;
nullable_string sColor2;
nullable < SimpleTypes::CFillType> oType;
nullable<SimpleTypes::CFixedPercentage> oFocus;
nullable<SimpleTypes::Vml::CVml_Vector2D_Percentage> oFocusSize;
nullable<SimpleTypes::Vml::CVml_Vector2D_Percentage> oFocusPosition;
nullable<SimpleTypes::CDecimalNumber> oAngle;
nullable_string sColors;
nullable_string sRotate;
XmlMacroReadAttributeBase(oNodeFill, L"rotate", sRotate);
XmlMacroReadAttributeBase(oNodeFill, L"opacity", sOpacity);
XmlMacroReadAttributeBase(oNodeFill, L"opacity2", sOpacity2);
XmlMacroReadAttributeBase(oNodeFill, L"color", sColor);
XmlMacroReadAttributeBase(oNodeFill, L"color2", sColor2);
XmlMacroReadAttributeBase(oNodeFill, L"type", oType);
XmlMacroReadAttributeBase(oNodeFill, L"focus", oFocus);
XmlMacroReadAttributeBase(oNodeFill, L"focussize", oFocusSize);
XmlMacroReadAttributeBase(oNodeFill, L"angle", oAngle);
XmlMacroReadAttributeBase(oNodeFill, L"colors", sColors);
XmlMacroReadAttributeBase(oNodeFill, L"focusposition", oFocusPosition);
if (sColor.IsInit() || sOpacity.IsInit())
{//reset exactly
PPTX::Logic::SolidFill* pSolid = new PPTX::Logic::SolidFill();
pSolid->m_namespace = L"a";
ConvertColor(pSolid->Color, sColor, sOpacity);
pSpPr->Fill.m_type = PPTX::Logic::UniFill::solidFill;
pSpPr->Fill.Fill = pSolid;
if (!sFillColor.is_init())
sFillColor = sColor;
}
nullable_string sRid;
XmlMacroReadAttributeBase(oNodeFill, L"o:relid", sRid);
if (false == sRid.IsInit())
{
XmlMacroReadAttributeBase(oNodeFill, L"relationships:id", sRid);
}
if (false == sRid.IsInit())
{
XmlMacroReadAttributeBase(oNodeFill, L"o:relid", sRid);
}
if (sRid.is_init())
{
PPTX::Logic::BlipFill* pBlipFill = NULL;
if (pPicture)
{
pBlipFill = &pPicture->blipFill;
}
else
{
pBlipFill = new PPTX::Logic::BlipFill();
pSpPr->Fill.m_type = PPTX::Logic::UniFill::blipFill;
pSpPr->Fill.Fill = pBlipFill;
}
pBlipFill->m_namespace = L"a";
pBlipFill->blip = new PPTX::Logic::Blip();
pBlipFill->blip->embed = new OOX::RId(*sRid);
if (oType.is_init() && ((oType->GetValue() == SimpleTypes::filltypeTile) || (oType->GetValue() == SimpleTypes::filltypePattern)))
{
pBlipFill->tile = new PPTX::Logic::Tile();
if (oType->GetValue() == SimpleTypes::filltypePattern)
{
PPTX::Logic::Duotone* pDuotone = new PPTX::Logic::Duotone();
PPTX::Logic::UniColor bgClr;
ConvertColor(bgClr, sColor2, sOpacity2);
pDuotone->Colors.push_back(bgClr);
PPTX::Logic::UniColor fgClr;
ConvertColor(fgClr, sColor, sOpacity);
pDuotone->Colors.push_back(fgClr);
PPTX::Logic::UniEffect effect;
effect.InitPointer(pDuotone);
pBlipFill->blip->Effects.push_back(effect);
}
}
else
{
pBlipFill->stretch = new PPTX::Logic::Stretch();
}
}
if ((oType.is_init() && (oType->GetValue() == SimpleTypes::filltypeGradient ||
oType->GetValue() == SimpleTypes::filltypeGradientRadial ||
oType->GetValue() == SimpleTypes::filltypeGradientCenter)) ||
(oFocus.is_init() || sColors.is_init() || oAngle.is_init() || oFocusSize.is_init() || oFocusPosition.is_init()))
{
PPTX::Logic::GradFill* pGradFill = new PPTX::Logic::GradFill();
pGradFill->m_namespace = L"a";
pGradFill->rotWithShape = false;
int nAngle = oAngle.is_init() ? (oAngle->GetValue() < -90 ? oAngle->GetValue() + 180 : oAngle->GetValue() + 90) : 90;
if (sColors.is_init())
{
std::vector<std::wstring> arSplit;
boost::algorithm::split(arSplit, sColors.get(), boost::algorithm::is_any_of(L";"), boost::algorithm::token_compress_on);
for (size_t i = 0; i < arSplit.size(); i++)
{
size_t p = arSplit[i].find(L" ");
if (p == std::wstring::npos)
continue;
std::wstring strPos = arSplit[i].substr(0, p);
std::wstring strColor = arSplit[i].substr(p + 1);
double pos = XmlUtils::GetDouble(strPos);
PPTX::Logic::Gs Gs_;
ODRAW::CColor color;
if (NS_DWC_Common::getColorFromString(strColor, color))
{
Gs_.color.Color = new PPTX::Logic::SrgbClr();
Gs_.color.Color->SetRGB(color.R, color.G, color.B);
if (pos <= 1)
pos = 100000 * pos;
else
pos = pos / 65536 * 100000;
Gs_.pos = pos;
pGradFill->GsLst.push_back(Gs_);
}
}
}
else
{
PPTX::Logic::Gs Gs_1;
ConvertColor(Gs_1.color, sColor, sOpacity);
PPTX::Logic::Gs Gs_2 = Gs_1;
ConvertColor(Gs_2.color, sColor2, sOpacity2);
double focusPoint = oFocus.IsInit() ? abs(oFocus->GetValue()) : 0;
bool bColorsInvert = ((oFocus.IsInit() && oFocus->GetValue() > 0 && nAngle == 0) ||
((oFocus.IsInit() && oFocus->GetValue() < 0) && false == oAngle.is_init()));
if (focusPoint > 0 && focusPoint < 100)
{
PPTX::Logic::Gs Gs_3;
Gs_1.pos = 0;
Gs_3.pos = focusPoint * 1000;
Gs_2.pos = 100 * 1000;
if (bColorsInvert)
{
Gs_3.color = Gs_1.color;
Gs_1.color = Gs_2.color;
}
else
{
Gs_3.color = Gs_2.color;
Gs_2.color = Gs_1.color;
}
pGradFill->GsLst.push_back(Gs_3);
}
else
{
Gs_2.pos = focusPoint * 1000;
Gs_1.pos = (100 - focusPoint) * 1000;
}
pGradFill->GsLst.push_back(Gs_1);
pGradFill->GsLst.push_back(Gs_2);
}
//if (pGradFill->GsLst.size() == 1) //Sindicatum.docx
//{
// PPTX::Logic::Gs Gs_;
// Gs_.pos = pGradFill->GsLst[0].pos == 0 ? 100 * 1000 : 0;
// Gs_.color.Color = new PPTX::Logic::SrgbClr(); Gs_.color.Color->SetRGB(0xff, 0xff, 0xff);
//
// pGradFill->GsLst.push_back( Gs_ );
//}
//todooo method
if (oType.IsInit() && oType->GetValue() == SimpleTypes::filltypeGradientRadial)
{
double x = 0, y = 0;
if (oFocusPosition.is_init())
{
x = oFocusPosition->GetX();
y = oFocusPosition->GetY();
}
pGradFill->path.Init();
pGradFill->path->path = 2;
pGradFill->path->rect.Init();
pGradFill->path->rect->m_name = L"a:fillToRect";
pGradFill->path->rect->b = XmlUtils::ToString(100 - int(y * 100)) + L"%";
pGradFill->path->rect->r = XmlUtils::ToString(100 - int(x * 100)) + L"%";
pGradFill->path->rect->t = XmlUtils::ToString(int(y * 100)) + L"%";
pGradFill->path->rect->l = XmlUtils::ToString(int(x * 100)) + L"%";
pGradFill->tileRect.Init();
pGradFill->tileRect->m_name = L"a:tileRect";
}
else
{
pGradFill->lin = new PPTX::Logic::Lin();
pGradFill->lin->scaled = 1;
if (nAngle != 0)
{
pGradFill->lin->ang = (nAngle >= 0 ? nAngle : (360 + nAngle)) * 60000;
}
else if (sRotate.is_init())
{
pGradFill->lin = new PPTX::Logic::Lin();
pGradFill->lin->scaled = 1;
if (*sRotate == L"l") pGradFill->lin->ang = 0 * 60000;
if (*sRotate == L"t") pGradFill->lin->ang = 90 * 60000;
if (*sRotate == L"b") pGradFill->lin->ang = 270 * 60000;
if (*sRotate == L"r") pGradFill->lin->ang = 180 * 60000;
}
}
pSpPr->Fill.m_type = PPTX::Logic::UniFill::gradFill;
pSpPr->Fill.Fill = pGradFill;
}
if ((oType.IsInit() && oType->GetValue() == SimpleTypes::filltypePattern) && pSpPr->Fill.m_type != PPTX::Logic::UniFill::blipFill)
{
PPTX::Logic::PattFill* pPattFill = new PPTX::Logic::PattFill();
pPattFill->m_namespace = L"a";
ConvertColor(pPattFill->fgClr, sColor, sOpacity);
ConvertColor(pPattFill->bgClr, sColor2, sOpacity2);
pSpPr->Fill.m_type = PPTX::Logic::UniFill::pattFill;
pSpPr->Fill.Fill = pPattFill;
}
if (sOpacity.is_init() && pSpPr->Fill.is<PPTX::Logic::BlipFill>())
{
BYTE lAlpha = NS_DWC_Common::getOpacityFromString(*sOpacity);
PPTX::Logic::AlphaModFix* pAlphaMod = new PPTX::Logic::AlphaModFix();
int nA = (int)(lAlpha * 100000.0 / 255.0);
pAlphaMod->amt = nA;
PPTX::Logic::UniEffect oEff;
oEff.InitPointer(pAlphaMod);
pSpPr->Fill.as<PPTX::Logic::BlipFill>().blip->Effects.push_back(oEff);
}
}
if (pPPTShape->m_bIsFilled || pPPTShape->m_eType == PPTShapes::sptCFrame)
{
XmlUtils::CXmlNode oNodeFillID = oNode.ReadNode(L"v:imagedata");
if (oNodeFillID.IsValid())
{
nullable_string sSrc;
XmlMacroReadAttributeBase(oNodeFillID, L"src", sSrc);
if (sSrc.IsInit())
{
std::map<std::wstring, nullable<OOX::Logic::CBinData>>::iterator pFind = m_mapBinDatas.find(*sSrc);
if (pFind != m_mapBinDatas.end())
{
oElem->m_binaryData = pFind->second;
}
}
nullable_string sTitle;
XmlMacroReadAttributeBase(oNodeFillID, L"o:title", sTitle);
nullable_string sRid;
XmlMacroReadAttributeBase(oNodeFillID, L"r:id", sRid);
nullable_string sRelid;
XmlMacroReadAttributeBase(oNodeFillID, L"o:relid", sRelid);
nullable_string sPictId;
XmlMacroReadAttributeBase(oNodeFillID, L"r:pict", sPictId);
if (sRid.is_init() || sRelid.is_init() || sPictId.is_init() || oElem->m_binaryData.IsInit() || (sTitle.IsInit() && !sTitle->empty()))
{
nullable_string sType;
XmlMacroReadAttributeBase(oNodeFillID, L"type", sType);
PPTX::Logic::BlipFill* pBlipFill = NULL;
if (pPicture)
{
pPicture->nvPicPr.cNvPr.descr = sTitle;
pBlipFill = &pPicture->blipFill;
}
else
{
pBlipFill = new PPTX::Logic::BlipFill();
pSpPr->Fill.m_type = PPTX::Logic::UniFill::blipFill;
pSpPr->Fill.Fill = pBlipFill;
}
pBlipFill->m_namespace = L"a";
pBlipFill->blip = new PPTX::Logic::Blip();
if (oElem->m_binaryData.IsInit() && oElem->m_binaryData->m_sData.IsInit())
{
pBlipFill->blip->dataFilepathImageA = "data:base64," + *oElem->m_binaryData->m_sData;
}
else
{
std::wstring sId = sRid.IsInit() ? *sRid : (sRelid.IsInit() ? *sRelid : (sPictId.IsInit() ? *sPictId : L""));
pBlipFill->blip->embed = new OOX::RId(sId);
}
if (sType.is_init() && *sType == L"tile")
{
pBlipFill->tile = new PPTX::Logic::Tile();
}
else
{
//stretch ??? bug 28238
pBlipFill->stretch.Init();
pBlipFill->stretch->fillRect.Init();
}
std::wstring strCropT = oNodeFillID.GetAttribute(L"croptop");
std::wstring strCropL = oNodeFillID.GetAttribute(L"cropleft");
std::wstring strCropR = oNodeFillID.GetAttribute(L"cropright");
std::wstring strCropB = oNodeFillID.GetAttribute(L"cropbottom");
NS_DWC_Common::CorrentCropString(strCropL);
NS_DWC_Common::CorrentCropString(strCropT);
NS_DWC_Common::CorrentCropString(strCropR);
NS_DWC_Common::CorrentCropString(strCropB);
if (L"" != strCropL || L"" != strCropT || L"" != strCropR || L"" != strCropB)
{
pBlipFill->srcRect = new PPTX::Logic::Rect();
std::wstring str0 = L"0";
if (L"" != strCropL)
pBlipFill->srcRect->l = strCropL;
else
pBlipFill->srcRect->l = str0;
if (L"" != strCropT)
pBlipFill->srcRect->t = strCropT;
else
pBlipFill->srcRect->t = str0;
if (L"" != strCropR)
pBlipFill->srcRect->r = strCropR;
else
pBlipFill->srcRect->r = str0;
if (L"" != strCropB)
pBlipFill->srcRect->b = strCropB;
else
pBlipFill->srcRect->b = str0;
}
}
}
}
if (pPicture)
{
pSpPr->Fill.m_type = PPTX::Logic::UniFill::notInit;
if (false == pPicture->blipFill.blip.is_init())
{
oElem->InitElem(NULL); //MSF_Lec3-4.docx
}
}
else // Shape, ..
{
// default params for fill shape
if (!pSpPr->Fill.Fill.is_init())
{
if (pPPTShape->IsWordArt())
{
PPTX::Logic::NoFill* pNoFill = new PPTX::Logic::NoFill();
pNoFill->m_namespace = L"a";
pSpPr->Fill.m_type = PPTX::Logic::UniFill::noFill;
pSpPr->Fill.Fill = pNoFill;
}
else
{
PPTX::Logic::SolidFill* pSolid = new PPTX::Logic::SolidFill();
pSolid->m_namespace = L"a";
pSolid->Color.Color = new PPTX::Logic::SrgbClr();
pSolid->Color.Color->SetRGB(0xFF, 0xFF, 0xFF);
pSpPr->Fill.m_type = PPTX::Logic::UniFill::solidFill;
pSpPr->Fill.Fill = pSolid;
if (sOpacity.is_init())
{
BYTE lAlpha = NS_DWC_Common::getOpacityFromString(*sOpacity);
PPTX::Logic::ColorModifier oMod;
oMod.name = L"alpha";
int nA = (int)(lAlpha * 100000.0 / 255.0);
oMod.val = nA;
pSolid->Color.Color->Modifiers.push_back(oMod);
}
}
}
}
}
void CDrawingConverter::CheckPenShape(PPTX::Logic::SpTreeElem* oElem, XmlUtils::CXmlNode& oNode, CPPTShape* pPPTShape)
{
if (!oElem)return;
PPTX::Logic::Shape* pShape = dynamic_cast<PPTX::Logic::Shape*> (oElem->GetElem().operator ->());
PPTX::Logic::Pic* pPicture = dynamic_cast<PPTX::Logic::Pic*> (oElem->GetElem().operator ->());
PPTX::Logic::SpPr *pSpPr = NULL;
if (pShape) pSpPr = &pShape->spPr;
if (pPicture) pSpPr = &pPicture->spPr;
if (!pSpPr) return;
if (!pPPTShape->m_bIsStroked)
{
if (!pSpPr->ln.IsInit())
pSpPr->ln.Init();
pSpPr->ln->Fill.m_type = PPTX::Logic::UniFill::noFill;
pSpPr->ln->Fill.Fill = new PPTX::Logic::NoFill();
}
if (pPPTShape->IsWordArt())
return;
nullable_string sStrokeColor, sStrokeOpacity;
XmlMacroReadAttributeBase(oNode, L"strokecolor", sStrokeColor);
if (sStrokeColor.is_init())
{
if (!pSpPr->ln.IsInit())
pSpPr->ln.Init();
pPPTShape->m_bIsStroked = true;
PPTX::Logic::SolidFill* pSolid = new PPTX::Logic::SolidFill();
pSolid->m_namespace = L"a";
ConvertColor(pSolid->Color, sStrokeColor, sStrokeOpacity);
pSpPr->ln->Fill.m_type = PPTX::Logic::UniFill::solidFill;
pSpPr->ln->Fill.Fill = pSolid;
}
nullable<SimpleTypes::CEmu> oStrokeWeight;
XmlMacroReadAttributeBase(oNode, L"strokeweight", oStrokeWeight);
if (oStrokeWeight.is_init())
{
pPPTShape->m_bIsStroked = true;
if (!pSpPr->ln.is_init())
pSpPr->ln = new PPTX::Logic::Ln();
int size = oStrokeWeight->ToEmu();
pSpPr->ln->w = size;
pPPTShape->m_bIsStroked = true;
}
XmlUtils::CXmlNode oNodeStroke = oNode.ReadNode(L"v:stroke");
if (oNodeStroke.IsValid())
{
sStrokeColor.reset();
XmlMacroReadAttributeBase(oNodeStroke, L"strokecolor", sStrokeColor);
if (sStrokeColor.is_init())
{
pPPTShape->m_bIsStroked = true;
ODRAW::CColor color;
if (NS_DWC_Common::getColorFromString(*sStrokeColor, color))
{
if (!pSpPr->ln.is_init())
pSpPr->ln = new PPTX::Logic::Ln();
PPTX::Logic::SolidFill* pSolid = new PPTX::Logic::SolidFill();
pSolid->m_namespace = L"a";
pSolid->Color.Color = new PPTX::Logic::SrgbClr();
pSolid->Color.Color->SetRGB(color.R, color.G, color.B);
pSpPr->ln->Fill.m_type = PPTX::Logic::UniFill::solidFill;
pSpPr->ln->Fill.Fill = pSolid;
}
}
nullable_string sStrokeDashStyle;
XmlMacroReadAttributeBase(oNodeStroke, L"dashstyle", sStrokeDashStyle);
if (sStrokeDashStyle.is_init())
{
pPPTShape->m_bIsStroked = true;
if (!pSpPr->ln.is_init())
pSpPr->ln = new PPTX::Logic::Ln();
pSpPr->ln->prstDash = new PPTX::Logic::PrstDash();
if (*sStrokeDashStyle == L"solid") pSpPr->ln->prstDash->val = L"solid";
else if (*sStrokeDashStyle == L"shortdash") pSpPr->ln->prstDash->val = L"sysDash";
else if (*sStrokeDashStyle == L"shortdot") pSpPr->ln->prstDash->val = L"sysDot";
else if (*sStrokeDashStyle == L"shortdashdot") pSpPr->ln->prstDash->val = L"sysDashDot";
else if (*sStrokeDashStyle == L"shortdashdotdot")pSpPr->ln->prstDash->val = L"sysDashDotDot";
else if (*sStrokeDashStyle == L"dot") pSpPr->ln->prstDash->val = L"dot";
else if (*sStrokeDashStyle == L"dash") pSpPr->ln->prstDash->val = L"dash";
else if (*sStrokeDashStyle == L"longdash") pSpPr->ln->prstDash->val = L"lgDash";
else if (*sStrokeDashStyle == L"dashdot") pSpPr->ln->prstDash->val = L"dashDot";
else if (*sStrokeDashStyle == L"longdashdot") pSpPr->ln->prstDash->val = L"lgDashDot";
else if (*sStrokeDashStyle == L"longdashdotdot")pSpPr->ln->prstDash->val = L"lgDashDotDot";
else pSpPr->ln->prstDash->val = L"solid";
}
nullable_string sEndArraw;
XmlMacroReadAttributeBase(oNodeStroke, L"endarrow", sEndArraw);
if (sEndArraw.is_init())
{
if (!pSpPr->ln.is_init())
pSpPr->ln = new PPTX::Logic::Ln();
pSpPr->ln->tailEnd = new PPTX::Logic::LineEnd();
if (*sEndArraw == L"none") pSpPr->ln->tailEnd->type = L"none";
else if (*sEndArraw == L"block") pSpPr->ln->tailEnd->type = L"triangle";
else if (*sEndArraw == L"classic") pSpPr->ln->tailEnd->type = L"stealth";
else if (*sEndArraw == L"diamond") pSpPr->ln->tailEnd->type = L"diamond";
else if (*sEndArraw == L"oval") pSpPr->ln->tailEnd->type = L"oval";
else if (*sEndArraw == L"open") pSpPr->ln->tailEnd->type = L"arrow";
else pSpPr->ln->tailEnd->type = L"none";
}
nullable_string sEndArrawLen;
XmlMacroReadAttributeBase(oNodeStroke, L"endarrowlength", sEndArrawLen);
if (sEndArrawLen.is_init())
{
if (!pSpPr->ln.is_init())
pSpPr->ln = new PPTX::Logic::Ln();
if (!pSpPr->ln->tailEnd.is_init())
pSpPr->ln->tailEnd = new PPTX::Logic::LineEnd();
if (*sEndArrawLen == L"short") pSpPr->ln->tailEnd->len = L"sm";
else if (*sEndArrawLen == L"medium") pSpPr->ln->tailEnd->len = L"med";
else if (*sEndArrawLen == L"long") pSpPr->ln->tailEnd->len = L"lg";
else pSpPr->ln->tailEnd->len = L"med";
}
nullable_string sEndArrawWidth;
XmlMacroReadAttributeBase(oNodeStroke, L"endarrowwidth", sEndArrawWidth);
if (sEndArrawWidth.is_init())
{
if (!pSpPr->ln.is_init())
pSpPr->ln = new PPTX::Logic::Ln();
if (!pSpPr->ln->tailEnd.is_init())
pSpPr->ln->tailEnd = new PPTX::Logic::LineEnd();
if (*sEndArrawWidth == L"narrow") pSpPr->ln->tailEnd->w = L"sm";
else if (*sEndArrawWidth == L"medium") pSpPr->ln->tailEnd->w = L"med";
else if (*sEndArrawWidth == L"wide") pSpPr->ln->tailEnd->w = L"lg";
else pSpPr->ln->tailEnd->w = L"med";
}
nullable_string sStartArraw;
XmlMacroReadAttributeBase(oNodeStroke, L"startarrow", sStartArraw);
if (sStartArraw.is_init())
{
if (!pSpPr->ln.is_init())
pSpPr->ln = new PPTX::Logic::Ln();
pSpPr->ln->headEnd = new PPTX::Logic::LineEnd();
if (*sStartArraw == L"none") pSpPr->ln->headEnd->type = L"none";
else if (*sStartArraw == L"block") pSpPr->ln->headEnd->type = L"triangle";
else if (*sStartArraw == L"classic")pSpPr->ln->headEnd->type = L"stealth";
else if (*sStartArraw == L"diamond")pSpPr->ln->headEnd->type = L"diamond";
else if (*sStartArraw == L"oval") pSpPr->ln->headEnd->type = L"oval";
else if (*sStartArraw == L"open") pSpPr->ln->headEnd->type = L"arrow";
else pSpPr->ln->headEnd->type = L"none";
}
nullable_string sStartArrawLen;
XmlMacroReadAttributeBase(oNodeStroke, L"startarrowlength", sStartArrawLen);
if (sStartArrawLen.is_init())
{
if (!pSpPr->ln.is_init())
pSpPr->ln = new PPTX::Logic::Ln();
if (!pSpPr->ln->headEnd.is_init())
pSpPr->ln->headEnd = new PPTX::Logic::LineEnd();
if (*sStartArrawLen == L"short") pSpPr->ln->headEnd->len = L"sm";
else if (*sStartArrawLen == L"medium") pSpPr->ln->headEnd->len = L"med";
else if (*sStartArrawLen == L"long") pSpPr->ln->headEnd->len = L"lg";
else pSpPr->ln->headEnd->len = L"med";
}
nullable_string sStartArrawWidth;
XmlMacroReadAttributeBase(oNodeStroke, L"startarrowwidth", sStartArrawWidth);
if (sStartArrawWidth.is_init())
{
if (!pSpPr->ln.is_init())
pSpPr->ln = new PPTX::Logic::Ln();
if (!pSpPr->ln->headEnd.is_init())
pSpPr->ln->headEnd = new PPTX::Logic::LineEnd();
if (*sStartArrawWidth == L"narrow") pSpPr->ln->headEnd->w = L"sm";
else if (*sStartArrawWidth == L"medium") pSpPr->ln->headEnd->w = L"med";
else if (*sStartArrawWidth == L"wide") pSpPr->ln->headEnd->w = L"lg";
else pSpPr->ln->headEnd->w = L"med";
}
nullable_string sEndCap;
XmlMacroReadAttributeBase(oNodeStroke, L"endcap", sEndCap);
if (sEndCap.is_init())
{
if (!pSpPr->ln.is_init())
pSpPr->ln = new PPTX::Logic::Ln();
if (*sEndCap == L"flat") pSpPr->ln->cap = L"flat";
else if (*sEndCap == L"round") pSpPr->ln->cap = L"rnd";
else if (*sEndCap == L"square") pSpPr->ln->cap = L"sq";
}
nullable_string sLineJoin;
XmlMacroReadAttributeBase(oNodeStroke, L"joinstyle", sLineJoin);
if (sLineJoin.is_init())
{
if (!pSpPr->ln.is_init())
pSpPr->ln = new PPTX::Logic::Ln();
pSpPr->ln->join.Init();
if (*sLineJoin == L"bevel") pSpPr->ln->join->type = PPTX::Logic::JoinBevel;
else if (*sLineJoin == L"miter") pSpPr->ln->join->type = PPTX::Logic::JoinMiter;
else if (*sLineJoin == L"round") pSpPr->ln->join->type = PPTX::Logic::JoinRound;
}
}
nullable_string sStroked;
XmlMacroReadAttributeBase(oNode, L"stroked", sStroked);
if (oNodeStroke.IsValid())
{
nullable_string sStrokeOn;
XmlMacroReadAttributeBase(oNodeStroke, L"on", sStrokeOn);
if (sStrokeOn.is_init())
{
sStroked.reset();
sStroked = sStrokeOn;
}
}
if (sStroked.is_init())
{
if (*sStroked == L"false" || *sStroked == L"f")
{
if (!pSpPr->ln.is_init())
pSpPr->ln = new PPTX::Logic::Ln();
pSpPr->ln->Fill.m_type = PPTX::Logic::UniFill::noFill;
pSpPr->ln->Fill.Fill = new PPTX::Logic::NoFill();
pPPTShape->m_bIsStroked = false;
}
}
// default params
if (pShape) // not Picture
{
if (!pSpPr->ln.is_init())
pSpPr->ln = new PPTX::Logic::Ln();
if (!pSpPr->ln->Fill.Fill.is_init())
{
PPTX::Logic::SolidFill* pSolid = new PPTX::Logic::SolidFill();
pSolid->m_namespace = L"a";
pSolid->Color.Color = new PPTX::Logic::SrgbClr();
pSolid->Color.Color->SetRGB(0, 0, 0);
pSpPr->ln->Fill.m_type = PPTX::Logic::UniFill::solidFill;
pSpPr->ln->Fill.Fill = pSolid;
}
}
else
{
nullable_string sStrokeColor, sStrokeOpacity;
XmlMacroReadAttributeBase(oNode, L"o:bordertopcolor", sStrokeColor);
XmlUtils::CXmlNode oNodeStroke = oNode.ReadNode(L"w10:bordertop");
if (oNodeStroke.IsValid() && sStrokeColor.is_init())
{
if (!pSpPr->ln.IsInit())
pSpPr->ln.Init();
pPPTShape->m_bIsStroked = true;
PPTX::Logic::SolidFill* pSolid = new PPTX::Logic::SolidFill();
pSolid->m_namespace = L"a";
ConvertColor(pSolid->Color, sStrokeColor, sStrokeOpacity);
pSpPr->ln->Fill.m_type = PPTX::Logic::UniFill::solidFill;
pSpPr->ln->Fill.Fill = pSolid;
}
}
}
HRESULT CDrawingConverter::LoadClrMap(const std::wstring& bsXml)
{
smart_ptr<PPTX::Logic::ClrMap> pClrMap = new PPTX::Logic::ClrMap();
std::wstring strXml = L"<main xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\">" + bsXml + L"</main>";
XmlUtils::CXmlNode oNode;
oNode.FromXmlString(strXml);
if (oNode.IsValid())
{
XmlUtils::CXmlNode nodeMap = oNode.ReadNode(L"w:clrSchemeMapping");
pClrMap->fromXML(nodeMap);
}
*m_pClrMap = pClrMap;
return S_OK;
}
void CDrawingConverter::SaveObject(LONG lStart, LONG lLength, const std::wstring& bsMainProps, std::wstring & sXml)
{
bool bIsInline = false;
std::wstring strMainProps = bsMainProps;
std::wstring strMainPropsTail;
int nIndexF = (int)strMainProps.find(L"</wp:inline>");
if (-1 != nIndexF)
{
bIsInline = true;
strMainProps = strMainProps.substr(0, nIndexF);
}
else
{
nIndexF = (int)strMainProps.find(L"</wp:anchor>");
strMainProps = strMainProps.substr(0, nIndexF);
}
if (-1 == nIndexF)
return;
int nIndexTail = (int)strMainProps.find(L"<wp14:sizeRel");
if(-1 != nIndexTail)
{
strMainPropsTail = strMainProps.substr( nIndexTail );
strMainProps = strMainProps.substr(0, nIndexTail);
}
/*
std::wstring strId = L"");
strId.Format(L"<wp:docPr id=\"%d\" name=\"\"/>"), m_pBinaryReader->GenerateNextId());
strMainProps += strId;
*/
//strMainProps += L"<wp:cNvGraphicFramePr/>");
m_pBinaryReader->Seek(lStart);
++m_nCurrentIndexObject;
BYTE typeRec1 = m_pBinaryReader->GetUChar(); // must be 0;
LONG szRec1 = m_pBinaryReader->GetRecordSize();
LONG _e = m_pBinaryReader->GetPos() + szRec1 + 4;
if (typeRec1 == 0 && szRec1 > 0)
{
BYTE typeRec2 = m_pBinaryReader->GetUChar(); // must be 1;
LONG szRec2 = m_pBinaryReader->GetLong();
if (typeRec2 == 1 && szRec2 > 0)
{
PPTX::Logic::SpTreeElem oElem;
if (m_pBinaryReader->m_nDocumentType == 0)
m_pBinaryReader->m_nDocumentType = XMLWRITER_DOC_TYPE_DOCX;
oElem.fromPPTY(m_pBinaryReader);
bool bOle = false;
if (oElem.is<PPTX::Logic::Pic>())
{
PPTX::Logic::Pic& oPic = oElem.as<PPTX::Logic::Pic>();
if (oPic.oleObject.IsInit())
{
bOle = oPic.oleObject->isValid();
if (oPic.oleObject->m_oDxaOrig.IsInit() == false)
{
oPic.oleObject->m_oDxaOrig = 0;
}
if (oPic.oleObject->m_oDyaOrig.IsInit() == false)
{
oPic.oleObject->m_oDyaOrig = 0;
}
}
}
bool bSignatureLine = false;
if (oElem.is<PPTX::Logic::Shape>())
{
PPTX::Logic::Shape& oShape = oElem.as<PPTX::Logic::Shape>();
if (oShape.signatureLine.IsInit())
{
bSignatureLine = true;
}
}
bool bHorizontalRule = false;
if (oElem.is<PPTX::Logic::Shape>())
{
PPTX::Logic::Shape& oShape = oElem.as<PPTX::Logic::Shape>();
if (oShape.spPr.Geometry.hr.IsInit())
{
bHorizontalRule = true;
}
}
NSBinPptxRW::CXmlWriter oXmlWriter(m_pBinaryReader->m_nDocumentType);
oXmlWriter.m_lObjectIdVML = m_pXmlWriter->m_lObjectIdVML;
oXmlWriter.m_lObjectIdOle = m_pXmlWriter->m_lObjectIdOle;
oXmlWriter.m_bIsUseOffice2007 = m_bIsUseConvertion2007;
oXmlWriter.m_bIsTop = (1 == m_nCurrentIndexObject) ? true : false;
if (NULL == m_pOOXToVMLRenderer)
m_pOOXToVMLRenderer = new COOXToVMLGeometry();
oXmlWriter.m_pOOXToVMLRenderer = m_pOOXToVMLRenderer;
if (bOle)
{
ConvertPicVML(oElem, bsMainProps, oXmlWriter);
}
else if (bSignatureLine)
{
oXmlWriter.WriteString(L"<w:pict>");
ConvertShapeVML(oElem, bsMainProps, oXmlWriter, true);
oXmlWriter.WriteString(L"</w:pict>");
}
else if (bHorizontalRule)
{
oXmlWriter.WriteString(L"<w:pict>");
ConvertShapeVML(oElem, bsMainProps, oXmlWriter);
oXmlWriter.WriteString(L"</w:pict>");
}
else
{
bool bIsNeedConvert2007 = false;
if (m_bIsUseConvertion2007)
{
if (oElem.is<PPTX::Logic::SpTree>() ||
oElem.is<PPTX::Logic::Shape>() ||
oElem.is<PPTX::Logic::Pic>())
{
oXmlWriter.WriteString(L"<mc:AlternateContent><mc:Choice Requires=\"wpg\">");
bIsNeedConvert2007 = true;
}
}
oXmlWriter.WriteString(L"<w:drawing>");
oXmlWriter.WriteString(strMainProps);
bool bAddGraphicData = false;
if (oElem.is<PPTX::Logic::LockedCanvas>())
{
bAddGraphicData = true;
oXmlWriter.WriteString(L"<a:graphic xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\">\
<a:graphicData uri=\"http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas\">");
}
else if (oElem.is<PPTX::Logic::SpTree>())
{
bAddGraphicData = true;
oXmlWriter.WriteString(L"<a:graphic xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\">\
<a:graphicData uri=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\">");
}
else if (oElem.is<PPTX::Logic::Pic>())
{
bAddGraphicData = true;
oXmlWriter.WriteString(L"<a:graphic xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\">\
<a:graphicData uri=\"http://schemas.openxmlformats.org/drawingml/2006/picture\">");
}
else if (oElem.is<PPTX::Logic::Shape>())
{
bAddGraphicData = true;
oXmlWriter.WriteString(L"<a:graphic xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\">\
<a:graphicData uri=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\">");
}
if (m_pBinaryReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX)
{
PPTX::Logic::Xfrm *pXfrm = NULL;
if (oElem.getType() == OOX::et_pic)
{
PPTX::Logic::Pic& s = oElem.as<PPTX::Logic::Pic>();
if (s.spPr.xfrm.IsInit() == false)
{
//s.spPr.xfrm.Init(); pXfrm = s.spPr.xfrm.GetPointer();
}
}
else if (oElem.getType() == OOX::et_graphicFrame)
{
PPTX::Logic::GraphicFrame& s = oElem.as<PPTX::Logic::GraphicFrame>();
if (s.xfrm.IsInit() == false)
{
s.xfrm.Init(); pXfrm = s.xfrm.GetPointer();
}
}
else if (oElem.getType() == OOX::et_p_ShapeTree)
{
PPTX::Logic::SpTree& s = oElem.as<PPTX::Logic::SpTree>();
if (s.grpSpPr.xfrm.IsInit() == false)
{
s.grpSpPr.xfrm.Init(); pXfrm = s.grpSpPr.xfrm.GetPointer();
}
}
else if (oElem.getType() == OOX::et_a_Shape)
{
PPTX::Logic::Shape& s = oElem.as<PPTX::Logic::Shape>();
if (s.spPr.xfrm.IsInit() == false)
{
s.spPr.xfrm.Init(); pXfrm = s.spPr.xfrm.GetPointer();
}
}
else if (oElem.getType() == OOX::et_cxnSp)
{
PPTX::Logic::CxnSp& s = oElem.as<PPTX::Logic::CxnSp>();
if (s.spPr.xfrm.IsInit() == false)
{
s.spPr.xfrm.Init(); pXfrm = s.spPr.xfrm.GetPointer();
}
}
if (pXfrm)
{
pXfrm->extX = 0;
pXfrm->extY = 0;
pXfrm->offX = 0;
pXfrm->offY = 0;
}
}
oElem.toXmlWriter(&oXmlWriter);
if (bAddGraphicData)
oXmlWriter.WriteString(L"</a:graphicData></a:graphic>");
oXmlWriter.WriteString(strMainPropsTail);
oXmlWriter.WriteString(bIsInline ? L"</wp:inline>" : L"</wp:anchor>");
oXmlWriter.WriteString(L"</w:drawing>");
if (bIsNeedConvert2007)
{
oXmlWriter.WriteString(L"</mc:Choice><mc:Fallback>");
oXmlWriter.WriteString(L"<w:pict>");
if (oElem.is<PPTX::Logic::SpTree>())
{
ConvertGroupVML(oElem, bsMainProps, oXmlWriter);
}
else if (oElem.is<PPTX::Logic::Shape>())
{
ConvertShapeVML(oElem, bsMainProps, oXmlWriter);
}
else if (oElem.is<PPTX::Logic::Pic>())
{
ConvertPicVML(oElem, bsMainProps, oXmlWriter);
}
oXmlWriter.WriteString(L"</w:pict>");
oXmlWriter.WriteString(L"</mc:Fallback></mc:AlternateContent>");
}
}
--m_nCurrentIndexObject;
m_pXmlWriter->m_lObjectIdVML = oXmlWriter.m_lObjectIdVML;
m_pXmlWriter->m_lObjectIdOle = oXmlWriter.m_lObjectIdOle;
sXml = oXmlWriter.GetXmlString();
}
}
m_pBinaryReader->Seek(_e);
}
void CDrawingConverter::SaveObjectExWriterInit(NSBinPptxRW::CXmlWriter& oXmlWriter, int nDocType)
{
oXmlWriter.m_lObjectIdVML = m_pXmlWriter->m_lObjectIdVML;
oXmlWriter.m_lObjectIdOle = m_pXmlWriter->m_lObjectIdOle;
oXmlWriter.m_lDocType = (BYTE)nDocType;
oXmlWriter.m_bIsUseOffice2007 = false;
oXmlWriter.m_bIsTop = (1 == m_nCurrentIndexObject) ;
if (NULL == m_pOOXToVMLRenderer)
m_pOOXToVMLRenderer = new COOXToVMLGeometry();
oXmlWriter.m_pOOXToVMLRenderer = m_pOOXToVMLRenderer;
}
void CDrawingConverter::SaveObjectExWriterRelease(NSBinPptxRW::CXmlWriter& oXmlWriter)
{
m_pXmlWriter->m_lObjectIdVML = oXmlWriter.m_lObjectIdVML;
m_pXmlWriter->m_lObjectIdOle = oXmlWriter.m_lObjectIdOle;
}
void CDrawingConverter::SaveObjectEx(long lStart, long lLength, const std::wstring& sMainProps, int nDocType, std::wstring& sXml)
{
m_pImageManager->m_nDocumentType = nDocType;
if (XMLWRITER_DOC_TYPE_DOCX == nDocType ||
XMLWRITER_DOC_TYPE_DOCX_GLOSSARY == nDocType) //docx
{
m_pBinaryReader->m_nDocumentType = nDocType;
return SaveObject(lStart, lLength, sMainProps, sXml);
}
else
{
PPTX::Logic::SpTreeElem oElem;
m_pBinaryReader->Seek(lStart);
m_pBinaryReader->m_nDocumentType = nDocType;
++m_nCurrentIndexObject;
BYTE typeRec1 = m_pBinaryReader->GetUChar(); // must be 0;
LONG _e = m_pBinaryReader->GetPos() + m_pBinaryReader->GetLong() + 4;
try
{
m_pBinaryReader->Skip(5); // type record (must be 1) + 4 byte - len record
oElem.fromPPTY(m_pBinaryReader);
}
catch(...)
{
//todooo
}
bool bOle = false;
if (oElem.is<PPTX::Logic::Pic>())
{
PPTX::Logic::Pic& oPic = oElem.as<PPTX::Logic::Pic>();
if(oPic.oleObject.IsInit())
{
bOle = oPic.oleObject->isValid();
}
}
m_pBinaryReader->m_nDocumentType = XMLWRITER_DOC_TYPE_PPTX;
NSBinPptxRW::CXmlWriter oXmlWriter;
SaveObjectExWriterInit(oXmlWriter, nDocType);
if(bOle)
{
ConvertPicVML(oElem, sMainProps, oXmlWriter);
}
else
{
oElem.toXmlWriter(&oXmlWriter);
}
--m_nCurrentIndexObject;
SaveObjectExWriterRelease(oXmlWriter);
sXml = oXmlWriter.GetXmlString();
m_pBinaryReader->Seek(_e);
}
}
std::wstring CDrawingConverter::SaveObjectBackground(LONG lStart, LONG lLength)
{
if (lLength < 1) return L"";
m_pBinaryReader->Seek(lStart);
++m_nCurrentIndexObject;
BYTE typeRec1 = m_pBinaryReader->GetUChar(); // must be 0;
LONG _e = m_pBinaryReader->GetPos() + m_pBinaryReader->GetRecordSize() + 4;
PPTX::Logic::SpTreeElem oElem;
try
{
m_pBinaryReader->Skip(5); // type record (must be 1) + 4 byte - len record
oElem.fromPPTY(m_pBinaryReader);
}
catch(...)
{
//todooo
}
NSBinPptxRW::CXmlWriter oXmlWriter;
SaveObjectExWriterInit(oXmlWriter, m_pBinaryReader->m_nDocumentType);
m_pBinaryReader->m_nDocumentType = XMLWRITER_DOC_TYPE_PPTX;
if (oElem.is<PPTX::Logic::Shape>())
{
oXmlWriter.m_bIsTop = true; // don't forget to reset in the shape itself
PPTX::Logic::Shape& oShape = oElem.as<PPTX::Logic::Shape>();
OOX::IFileContainer* rels = GetRelsPtr();
oShape.toXmlWriterVMLBackground(&oXmlWriter, *m_pTheme, *m_pClrMap, rels);
}
--m_nCurrentIndexObject;
SaveObjectExWriterRelease(oXmlWriter);
m_pBinaryReader->Seek(_e);
return oXmlWriter.GetXmlString();
}
void CDrawingConverter::ConvertPicVML(PPTX::Logic::SpTreeElem& oElem, const std::wstring& bsMainProps, NSBinPptxRW::CXmlWriter& oWriter)
{
ConvertMainPropsToVML(bsMainProps, oWriter, oElem);
oWriter.m_bIsTop = true; // don't forget to reset in the shape itself
PPTX::Logic::Pic& oPic = oElem.as<PPTX::Logic::Pic>();
oPic.toXmlWriterVML(&oWriter, *m_pTheme, *m_pClrMap);
}
void CDrawingConverter::ConvertShapeVML(PPTX::Logic::SpTreeElem& oElem, const std::wstring& bsMainProps, NSBinPptxRW::CXmlWriter& oWriter, bool bSignature)
{
ConvertMainPropsToVML(bsMainProps, oWriter, oElem);
if (oElem.is<PPTX::Logic::Shape>())
{
oWriter.m_bIsTop = true; // don't forget to reset in the shape itself
PPTX::Logic::Shape& oShape = oElem.as<PPTX::Logic::Shape>();
OOX::IFileContainer* rels = GetRelsPtr();
oShape.toXmlWriterVML(&oWriter, *m_pTheme, *m_pClrMap, rels, false, bSignature);
}
}
void CDrawingConverter::ConvertGroupVML(PPTX::Logic::SpTreeElem& oElem, const std::wstring& bsMainProps, NSBinPptxRW::CXmlWriter& oWriter)
{
ConvertMainPropsToVML(bsMainProps, oWriter, oElem);
if (oElem.is<PPTX::Logic::SpTree>())
{
oWriter.m_bIsTop = true; // don't forget to reset in the shape itself (along with other parameters)
PPTX::Logic::SpTree& oGroup = oElem.as<PPTX::Logic::SpTree>();
OOX::IFileContainer* rels = GetRelsPtr();
oGroup.toXmlWriterVML(&oWriter, *m_pTheme, *m_pClrMap, rels);
}
}
void CDrawingConverter::ConvertParaVML(XmlUtils::CXmlNode& node, PPTX::Logic::Paragraph *p)
{
if (!p) return;
std::wstring strStyle = node.GetAttribute(L"style");
PPTX::CCSS oCSSParser;
oCSSParser.LoadFromString2(strStyle);
//todooo oCSSParser->pPr
std::vector<XmlUtils::CXmlNode> nodesDiv1 = node.GetNodes(L"*");
for (auto node1 : nodesDiv1)
{
if (node1.IsValid())
{
PPTX::Logic::Run* run = new PPTX::Logic::Run();
std::wstring name = node1.GetName();
if (name == L"p" || name == L"div")
{
ConvertParaVML(node1, p);
}
else if (name == L"font")
{
run->rPr = new PPTX::Logic::RunProperties();
std::wstring text = node1.GetText();
if (true == text.empty())
{
std::vector<XmlUtils::CXmlNode> nodesDiv2 = node1.GetNodes(L"*");
for (auto node2 : nodesDiv2)
{
name = node2.GetName();
std::wstring text2 = node2.GetText();
if (name == L"b")
run->rPr->b = true;
else if (name == L"i")
run->rPr->i = true;
if (false == text2.empty())
{
text += text2;
}
std::vector<XmlUtils::CXmlNode> nodesDiv3 = node2.GetNodes(L"*");
for (auto node3 : nodesDiv3)
{
name = node3.GetName();
if (name == L"b")
run->rPr->b = true;
else if (name == L"i")
run->rPr->i = true;
text += node3.GetText();
}
}
}
run->SetText(text);
std::vector<std::wstring > attNames, attValues;
node1.GetAllAttributes(attNames, attValues);
if (attNames.size() > 0)
{
for (size_t r = 0; r < attNames.size(); r++)
{
if (attNames[r] == L"color" && attValues[r].length() == 7)
{
XmlUtils::replace_all(attValues[r], L"#", L"");
PPTX::Logic::SolidFill* fill = new PPTX::Logic::SolidFill();
PPTX::Logic::SrgbClr* color = new PPTX::Logic::SrgbClr();
color->SetHexString(attValues[r]);
fill->Color.Color = color;
run->rPr->Fill.Fill = fill;
run->rPr->Fill.m_type = PPTX::Logic::UniFill::solidFill;
}
else if (attNames[r] == L"size")
{
run->rPr->sz = XmlUtils::GetInteger(attValues[r]) * 5;
}
else if (attNames[r] == L"face")
{
run->rPr->latin = new PPTX::Logic::TextFont();
run->rPr->latin->typeface = attValues[r];
run->rPr->latin->m_name = L"a:latin";
}
}
}
PPTX::Logic::RunElem elm;
p->RunElems.push_back(elm);
p->RunElems.back().InitRun(run);
}
}
}
}
void CDrawingConverter::ConvertTextVML(XmlUtils::CXmlNode &nodeTextBox, PPTX::Logic::Shape* pShape)
{
if (pShape->txBody.IsInit() == false)
pShape->txBody = new PPTX::Logic::TxBody();
if (pShape->txBody.IsInit() == false) return;
std::vector<XmlUtils::CXmlNode> nodes = nodeTextBox.GetNodes(L"*");
for (size_t i = 0 ; i < nodes.size(); i++)
{
XmlUtils::CXmlNode & node = nodes[i];
if (node.IsValid())
{
std::wstring name = node.GetName();
if (name == L"div")
{
PPTX::Logic::Paragraph p;
ConvertParaVML(node, &p);
pShape->txBody->Paragrs.push_back(p);
}
}
}
}
void CDrawingConverter::ConvertMainPropsToVML(const std::wstring& bsMainProps, NSBinPptxRW::CXmlWriter& outWriter, PPTX::Logic::SpTreeElem& oElem)
{
if (bsMainProps.empty())
return;
XmlUtils::CXmlNode oNode;
if (!oNode.FromXmlString(bsMainProps))
return;
NSBinPptxRW::CXmlWriter oWriter;
nullable_int margT; XmlMacroReadAttributeBase(oNode, L"distT", margT);
nullable_int margB; XmlMacroReadAttributeBase(oNode, L"distB", margB);
nullable_int margL; XmlMacroReadAttributeBase(oNode, L"distL", margL);
nullable_int margR; XmlMacroReadAttributeBase(oNode, L"distR", margR);
double dKoef = 72.0 / (36000 * 25.4);
if (margL.is_init())
oWriter.WriteAttributeCSS_double1_pt(L"mso-wrap-distance-left", dKoef * (*margL));
if (margT.is_init())
oWriter.WriteAttributeCSS_double1_pt(L"mso-wrap-distance-top", dKoef * (*margT));
if (margR.is_init())
oWriter.WriteAttributeCSS_double1_pt(L"mso-wrap-distance-right", dKoef * (*margR));
if (margB.is_init())
oWriter.WriteAttributeCSS_double1_pt(L"mso-wrap-distance-bottom", dKoef * (*margB));
outWriter.m_strStyleWrap = oWriter.GetXmlString();
oWriter.ClearNoAttack();
if (L"wp:inline" == oNode.GetName())
{
XmlUtils::CXmlNode oNodeS;
if (oNode.GetNode(L"wp:extent", oNodeS))
{
int _width = oNodeS.ReadAttributeInt(L"cx");
int _height = oNodeS.ReadAttributeInt(L"cy");
oWriter.WriteAttributeCSS_double1_pt(L"width", dKoef * _width);
oWriter.WriteAttributeCSS_double1_pt(L"height", dKoef * _height);
}
}
else
{
oWriter.WriteAttributeCSS(L"position", L"absolute");
nullable_bool behindDoc; XmlMacroReadAttributeBase(oNode, L"behindDoc", behindDoc);
nullable_bool allowOverlap; XmlMacroReadAttributeBase(oNode, L"allowOverlap", allowOverlap);
nullable_bool layoutInCell; XmlMacroReadAttributeBase(oNode, L"layoutInCell", layoutInCell);
XmlMacroReadAttributeBase(oNode, L"relativeHeight", outWriter.m_zIndex);
if (outWriter.m_zIndex.is_init())
{
_INT64 z_index = *outWriter.m_zIndex;
if ((behindDoc.IsInit()) && (*behindDoc == true))
{
outWriter.m_zIndex = -z_index;
}
oWriter.WriteAttributeCSS(L"z-index", std::to_wstring(*outWriter.m_zIndex));
}
if (allowOverlap.is_init())
{
oWriter.WriteAttributeCSS(L"o:allowoverlap", *allowOverlap ? L"true" : L"false");
}
if (layoutInCell.is_init())
{
oWriter.WriteAttributeCSS(L"o:allowincell", *layoutInCell ? L"true" : L"false");
}
XmlUtils::CXmlNode oNodeHorP;
if (oNode.GetNode(L"wp:positionH", oNodeHorP))
{
std::wstring strWriteRelFrom = oNodeHorP.GetAttribute(L"relativeFrom", L"column");
if (strWriteRelFrom == L"character")
oWriter.WriteAttributeCSS(L"mso-position-horizontal-relative", L"char");
else if (strWriteRelFrom == L"page")
oWriter.WriteAttributeCSS(L"mso-position-horizontal-relative", L"page");
else if (strWriteRelFrom == L"margin")
oWriter.WriteAttributeCSS(L"mso-position-horizontal-relative", L"margin");
else if (strWriteRelFrom == L"leftMargin")
oWriter.WriteAttributeCSS(L"mso-position-horizontal-relative", L"left-margin-area");
else if (strWriteRelFrom == L"rightMargin")
oWriter.WriteAttributeCSS(L"mso-position-horizontal-relative", L"right-margin-area");
else if (strWriteRelFrom == L"insideMargin")
oWriter.WriteAttributeCSS(L"mso-position-horizontal-relative", L"inner-margin-area");
else if (strWriteRelFrom == L"outsideMargin")
oWriter.WriteAttributeCSS(L"mso-position-horizontal-relative", L"outer-margin-area");
else if (strWriteRelFrom == L"column")
oWriter.WriteAttributeCSS(L"mso-position-horizontal-relative", L"text");
XmlUtils::CXmlNode oNodeO;
if (oNodeHorP.GetNode(L"wp:posOffset", oNodeO))
{
int nPos = oNodeHorP.ReadValueInt(L"wp:posOffset");
outWriter.m_dX = dKoef * nPos;
oWriter.WriteAttributeCSS_double1_pt(L"margin-left", outWriter.m_dX);
oWriter.WriteAttributeCSS(L"mso-position-horizontal", L"absolute");
}
else
{
std::wstring sA = oNodeHorP.ReadValueString(L"wp:align");
if (L"" != sA)
{
oWriter.WriteAttributeCSS(L"mso-position-horizontal", sA);
}
}
}
XmlUtils::CXmlNode oNodeVerP;
if (oNode.GetNode(L"wp:positionV", oNodeVerP))
{
std::wstring strWriteRelFrom = oNodeVerP.GetAttribute(L"relativeFrom", L"paragraph");
if (strWriteRelFrom == L"margin")
oWriter.WriteAttributeCSS(L"mso-position-vertical-relative", L"margin");
else if (strWriteRelFrom == L"paragraph")
oWriter.WriteAttributeCSS(L"mso-position-vertical-relative", L"text");
else if (strWriteRelFrom == L"page")
oWriter.WriteAttributeCSS(L"mso-position-vertical-relative", L"page");
else if (strWriteRelFrom == L"topMargin")
oWriter.WriteAttributeCSS(L"mso-position-vertical-relative", L"top-margin-area");
else if (strWriteRelFrom == L"bottomMargin")
oWriter.WriteAttributeCSS(L"mso-position-vertical-relative", L"bottom-margin-area");
else if (strWriteRelFrom == L"insideMargin")
oWriter.WriteAttributeCSS(L"mso-position-vertical-relative", L"inner-margin-area");
else if (strWriteRelFrom == L"outsideMargin")
oWriter.WriteAttributeCSS(L"mso-position-vertical-relative", L"outer-margin-area");
else if (strWriteRelFrom == L"line")
oWriter.WriteAttributeCSS(L"mso-position-vertical-relative", L"line");
XmlUtils::CXmlNode oNodeO;
if (oNodeVerP.GetNode(L"wp:posOffset", oNodeO))
{
int nPos = oNodeVerP.ReadValueInt(L"wp:posOffset");
outWriter.m_dY = dKoef * nPos;
oWriter.WriteAttributeCSS_double1_pt(L"margin-top", outWriter.m_dY);
oWriter.WriteAttributeCSS(L"mso-position-vertical", L"absolute");
}
else
{
std::wstring sA = oNodeVerP.ReadValueString(L"wp:align");
if (L"" != sA)
{
oWriter.WriteAttributeCSS(L"mso-position-vertical", sA);
}
}
}
XmlUtils::CXmlNode oNodeS;
if (oNode.GetNode(L"wp:extent", oNodeS))
{
int _width = oNodeS.ReadAttributeInt(L"cx");
int _height = oNodeS.ReadAttributeInt(L"cy");
outWriter.m_dWidth = dKoef * _width;
outWriter.m_dHeight = dKoef * _height;
oWriter.WriteAttributeCSS_double1_pt(L"width", outWriter.m_dWidth);
oWriter.WriteAttributeCSS_double1_pt(L"height", outWriter.m_dHeight);
}
XmlUtils::CXmlNode oNodeWrap = oNode.ReadNode(L"<wp:wrapNone/>");
XmlUtils::CXmlNode oNodeWrapPoints;
if (oNodeWrap.IsValid())
{
// ok
}
else
{
oNodeWrap = oNode.ReadNode(L"wp:wrapSquare");
if (oNodeWrap.IsValid())
{
outWriter.m_strNodes += L"<w10:wrap type=\"square\"/>";
}
else
{
oNodeWrap = oNode.ReadNode(L"wp:wrapTopAndBottom");
if (oNodeWrap.IsValid())
{
outWriter.m_strNodes += L"<w10:wrap type=\"topAndBottom\"/>";
}
else
{
oNodeWrap = oNode.ReadNode(L"wp:wrapTight");
if (oNodeWrap.IsValid())
{
outWriter.m_strNodes += L"<w10:wrap type=\"tight\"/>";
oNodeWrap.GetNode(L"wp:wrapPolygon", oNodeWrapPoints);
}
else
{
oNodeWrap = oNode.ReadNode(L"wp:wrapThrough");
if (oNodeWrap.IsValid())
{
outWriter.m_strNodes += L"<w10:wrap type=\"through\"/>";
oNodeWrap.GetNode(L"wp:wrapPolygon", oNodeWrapPoints);
}
}
}
}
}
if (oNodeWrapPoints.IsValid())
{
double dKoefX = 100000.0 / 21600;
double dKoefY = dKoefX;
if (oElem.is<PPTX::Logic::SpTree>())
{
PPTX::Logic::SpTree& oSpTr = oElem.as<PPTX::Logic::SpTree>();
if (oSpTr.grpSpPr.xfrm.is_init())
{
int nW = oSpTr.grpSpPr.xfrm->chExtX.get_value_or(21600);
int nH = oSpTr.grpSpPr.xfrm->chExtY.get_value_or(21600);
//dKoefX = ((double)(nW)) / 21600.0;
//dKoefY = ((double)(nH)) / 21600.0;
dKoefX = 1.0;
dKoefY = 1.0;
}
}
std::wstring strAttr = L" wrapcoords=\"";
std::vector<XmlUtils::CXmlNode> oNodesP;
if (oNodeWrapPoints.GetNodes(L"*", oNodesP))
{
size_t nCountP = oNodesP.size();
for (size_t i = 0; i < nCountP; ++i)
{
XmlUtils::CXmlNode & oNodeT = oNodesP[i];
int nX = oNodeT.ReadAttributeInt(L"x");
int nY = oNodeT.ReadAttributeInt(L"y");
nX = (int)(dKoefX * nX + 0.5);
nY = (int)(dKoefY * nY + 0.5);
std::wstring strFP = std::to_wstring(nX) + L" " + std::to_wstring(nY);
strAttr += strFP;
if (i < (nCountP - 1))
strAttr += L" ";
}
}
strAttr += L"\"";
outWriter.m_strAttributesMain += strAttr;
}
}
XmlUtils::CXmlNode oNodeDocPr;
if (oNode.GetNode(L"wp:docPr", oNodeDocPr))
{
std::wstring strName = oNodeDocPr.GetAttribute(L"name");
if (false == strName.empty())
{
std::wstring test = XmlUtils::GetLower(strName);
if (std::wstring::npos != test.find(L"watermark"))
outWriter.m_strId = strName;
}
}
outWriter.m_strStyleMain = oWriter.GetXmlString();
}
void CDrawingConverter::SetFontDir(const std::wstring& bsFontDir)
{
m_strFontDirectory = bsFontDir;
}
void CDrawingConverter::SetDstContentRels()
{
m_pBinaryReader->SetDstContentRels();
}
void CDrawingConverter::SaveDstContentRels(const std::wstring& bsRelsPath)
{
m_pBinaryReader->SaveDstContentRels(bsRelsPath);
}
void CDrawingConverter::WriteRels (const std::wstring& bsType, const std::wstring& bsTarget, const std::wstring& bsTargetMode, unsigned int* lId)
{
if (NULL == lId) return;
if (NULL == m_pBinaryReader) return;
if (NULL == m_pBinaryReader->m_pRels) return;
*lId = m_pBinaryReader->m_pRels->WriteRels(bsType, bsTarget, bsTargetMode);
}
void CDrawingConverter::Registration (const std::wstring& sType, const std::wstring& oDirectory, const std::wstring& oFilename)
{
if (!m_pImageManager) return;
if (!m_pImageManager->m_pContentTypes) return;
m_pImageManager->m_pContentTypes->Registration(sType, OOX::CPath(oDirectory), OOX::CPath(oFilename));
}
void CDrawingConverter::SetFontPicker(COfficeFontPicker* pFontPicker)
{
m_pBinaryWriter->m_pCommon->CreateFontPicker(pFontPicker);
}
void CDrawingConverter::SetAdditionalParam(const std::wstring& ParamName, BYTE *pArray, size_t szCount)
{
std::wstring name = ParamName;
if (name == L"xfrm_override" && pArray)
{
PPTX::Logic::Xfrm *pXfrm = (PPTX::Logic::Xfrm*)pArray;
m_oxfrm_override = new PPTX::Logic::Xfrm(*pXfrm);
}
}
OOX::CContentTypes* CDrawingConverter::GetContentTypes()
{
return m_pImageManager->m_pContentTypes;
}
void CDrawingConverter::SetRelsPtr(OOX::IFileContainer *container)
{
m_pBinaryWriter->SetRelsPtr(container);
}
OOX::IFileContainer* CDrawingConverter::GetRelsPtr()
{
return m_pBinaryWriter->GetRelsPtr();
}
void CDrawingConverter::SetFontManager(NSFonts::IFontManager* pFontManager)
{
if(NULL != m_pBinaryWriter && NULL != m_pBinaryWriter->m_pCommon && NULL != m_pBinaryWriter->m_pCommon->m_pMediaManager)
{
m_pBinaryWriter->m_pCommon->m_pMediaManager->SetFontManager(pFontManager);
}
}
}
Reference in New Issue View Git Blame Copy Permalink