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

7004 lines
241 KiB
C++
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* (c) Copyright Ascensio System SIA 2010-2023
*
* This program is a free software product. You can redistribute it and/or
* modify it under the terms of the GNU Affero General Public License (AGPL)
* version 3 as published by the Free Software Foundation. In accordance with
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
* that Ascensio System SIA expressly excludes the warranty of non-infringement
* of any third-party rights.
*
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
*
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
* street, Riga, Latvia, EU, LV-1050.
*
* The interactive user interfaces in modified source and object code versions
* of the Program must display Appropriate Legal Notices, as required under
* Section 5 of the GNU AGPL version 3.
*
* Pursuant to Section 7(b) of the License you must retain the original Product
* logo when distributing the program. Pursuant to Section 7(e) we decline to
* grant you any rights under trademark law for use of our trademarks.
*
* All the Product's GUI elements, including illustrations and icon sets, as
* well as technical writing content are licensed under the terms of the
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
*
*/
#include "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)
{
// здесь не будем плодить тормозов - напишем без всяких Mid, Find, чтобы был только один проход
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();
// здесь не будем плодить тормозов - напишем без всяких Mid, Find, чтобы был только один проход
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;
// пропускаем пробелы
while ((nPosition < nCount) && ((wchar_t(' ') == *pDataMem) || (wchar_t('{') == *pDataMem)))
{
++nPosition;
++pDataMem;
}
int nPosOld = nPosition;
// ищем имя настройки
while ((nPosition < nCount) && (wchar_t(':') != *pDataMem))
{
++nPosition;
++pDataMem;
}
if (nPosOld == nPosition)
{
// нету ни одной настройки
break;
}
std::wstring strName = strParams.substr(nPosOld, nPosition - nPosOld);
// убираем ':'
++nPosition;
++pDataMem;
// пропускаем пробелы настройки
while ((nPosition < nCount) && (wchar_t(' ') == *pDataMem))
{
++nPosition;
++pDataMem;
}
nPosOld = nPosition;
// пропускаем пробелы настройки
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();
// здесь не будем плодить тормозов - напишем без всяких Mid, Find, чтобы был только один проход
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)
{
// пропускаем пробелы
while ((nPosition < nCount) && ((wchar_t(' ') == *pDataMem) || (wchar_t('{') == *pDataMem) || (wchar_t(';') == *pDataMem)))
{
++nPosition;
++pDataMem;
}
int nPosOld = nPosition;
// ищем имя настройки
while ((nPosition < nCount) && (wchar_t(':') != *pDataMem))
{
++nPosition;
++pDataMem;
}
if (nPosOld == nPosition)
{
// нету ни одной настройки
break;
}
std::wstring strName = strParams.substr(nPosOld, nPosition - nPosOld);
// убираем ':'
++nPosition;
++pDataMem;
// пропускаем пробелы настройки
while ((nPosition < nCount) && (wchar_t(' ') == *pDataMem))
{
++nPosition;
++pDataMem;
}
nPosOld = nPosition;
// пропускаем пробелы настройки
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_bNeedMainProps = false;
m_pBinaryWriter = new NSBinPptxRW::CBinaryFileWriter();
m_pReader = 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_pReader);
RELEASEOBJECT(m_pImageManager);
RELEASEOBJECT(m_pXmlWriter);
RELEASEOBJECT(m_pTheme);
RELEASEOBJECT(m_pClrMap);
}
void CDrawingConverter::SetMainDocument(BinDocxRW::CDocxSerializer* pDocument)
{
m_pBinaryWriter->ClearNoAttack();
m_pBinaryWriter->m_pCommon->m_pMediaManager->Clear();
m_pBinaryWriter->SetMainDocument(pDocument);
m_pReader->SetMainDocument(pDocument);
m_lNextId = 1;
m_pImageManager->m_nDocumentType = m_pReader->m_nDocumentType = XMLWRITER_DOC_TYPE_DOCX;
}
void CDrawingConverter::SetSrcPath(const std::wstring& sPath, int nDocType)
{
OOX::CPath path(sPath);
m_pReader->m_pRels->m_pManager = m_pImageManager;
m_pReader->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())//?? с затиранием ???
{
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));
}
}
HRESULT 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);
}
return S_OK;
}
PPTX::Logic::SpTreeElem CDrawingConverter::ObjectFromXml(const std::wstring& sXml, std::wstring** ppMainProps)
{
PPTX::Logic::SpTreeElem oElem;
std::wstring sBegin(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\">");
std::wstring sEnd(L"</main>");
std::wstring strXml = sBegin + sXml + sEnd;
XmlUtils::CXmlNode oMainNode;
if (!oMainNode.FromXmlString(strXml))
return oElem;
std::vector<XmlUtils::CXmlNode> oNodes;
if (!oMainNode.GetNodes(L"*", oNodes))
return oElem;
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"drawing")
{
ConvertDrawing(&oElem, oParseNode, ppMainProps, true);
break;
}
else if (strName == L"background")
{
ConvertShape(&oElem, oParseNode, ppMainProps, false);
break;
}
else if (strName == L"pict" || strName == L"object")
{
//сначала shape type
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 (size_t k = 0; k < oChilds.size(); 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"polyline" == strNameP)
{
if(NULL == pElem)
{
pElem = new PPTX::Logic::SpTreeElem;
ConvertShape(pElem, oNodeP, ppMainProps, true);
#ifdef AVS_OFFICE_DRAWING_DUMP_XML_TEST
NSBinPptxRW::CXmlWriter oXmlW(m_pReader->m_nDocumentType);
pElem->toXmlWriter(&oXmlW);
std::wstring strXmlTemp = oXmlW.GetXmlString();
#endif
}
}
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, ppMainProps, true);
#ifdef AVS_OFFICE_DRAWING_DUMP_XML_TEST
NSBinPptxRW::CXmlWriter oXmlW(m_pReader->m_nDocumentType);
pElem->toXmlWriter(&oXmlW);
std::wstring strXmlTemp = oXmlW.GetXmlString();
#endif
}
}
else if (L"drawing" == strNameP)
{
ConvertDrawing(pElem, oNodeP, ppMainProps, true);
}
else
{
continue;
}
if (bIsFound)
break;
}
if(NULL != pElem)
{
if(NULL != pOle && pOle->m_sProgId.IsInit() && (pOle->m_oId.IsInit() || pOle->m_OleObjectFile.IsInit()))
{
PPTX::Logic::Shape* pShape = dynamic_cast<PPTX::Logic::Shape*>(pElem->GetElem().operator ->());
if(NULL != pShape && pShape->spPr.Fill.Fill.IsInit())
{
bool bImageOle = false;
if (pShape->spPr.Fill.m_type == PPTX::Logic::UniFill::blipFill) bImageOle = true;
PPTX::Logic::BlipFill oBlipFillNew;
if (!bImageOle)
oBlipFillNew.blip = new PPTX::Logic::Blip();
const PPTX::Logic::BlipFill& oBlipFill = bImageOle ? pShape->spPr.Fill.Fill.as<PPTX::Logic::BlipFill>() : oBlipFillNew;
if(oBlipFill.blip.IsInit())
{
if (pOle->m_OleObjectFile.IsInit())
{
oBlipFill.blip->oleFilepathBin = pOle->m_OleObjectFile->filename().GetPath();
}
else if (pOle->m_oId.IsInit())
{
oBlipFill.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;
}
}
PPTX::Logic::Pic *newElem = new PPTX::Logic::Pic();
newElem->blipFill = oBlipFill;
newElem->spPr = pShape->spPr;
newElem->style = pShape->style;
newElem->oleObject.reset(pOle);
pOle = NULL;
pElem->InitElem(newElem);
}
}
}
m_pBinaryWriter->WriteRecord1(1, *pElem);
}
RELEASEOBJECT(pElem)
RELEASEOBJECT(pOle)
}
break;
}
else if (strName == L"oleObj")
{
nullable<PPTX::Logic::Pic> pic = oParseNode.ReadNode(_T("p:pic"));
if (pic.is_init())
{
pic->fromXMLOle(oParseNode); // todooo сделать норальный объект
m_pBinaryWriter->WriteRecord2(1, pic);
}
break;
}
else if (strName == L"AlternateContent")
{
XmlUtils::CXmlNode oNodeDr;
if (oParseNode.GetNode(L"w:drawing", oNodeDr))
{
strName = L"drawing";
oParseNode = oNodeDr;
continue;
}
if (oParseNode.GetNode(L"mc:Choice", oNodeDr))
{
oParseNode = oNodeDr;
continue;
}
if (oParseNode.GetNode(L"w:pict", oNodeDr))
{
strName = L"pict";
oParseNode = oNodeDr;
continue;
}
if (oParseNode.GetNode(L"w:object", oNodeDr))
{
strName = L"object";
oParseNode = oNodeDr;
continue;
}
if (oParseNode.GetNode(L"xdr:sp", oNodeDr))
{
strName = L"sp";
oParseNode = oNodeDr;
continue;
}
if (oParseNode.GetNode(L"mc:Fallback", oNodeDr))
{
oParseNode = oNodeDr;
continue;
}
break;
}
else
{
oElem = oParseNode;
break;
}
}
}
return oElem;
}
std::wstring CDrawingConverter::ObjectToDrawingML(const std::wstring& sXml, int nDocType)
{
std::wstring *pMainProps = new std::wstring();
PPTX::Logic::SpTreeElem oElem = ObjectFromXml(sXml, &pMainProps);
if (oElem.is_init() == false) return L"";
NSBinPptxRW::CXmlWriter oXmlWriter(nDocType);
oXmlWriter.m_bIsUseOffice2007 = false;
oXmlWriter.m_bIsTop = true;
oXmlWriter.WriteString(L"<w:drawing>");
bool bIsInline = false;
std::wstring strMainProps = *pMainProps;
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)
{
oElem.toXmlWriter(&oXmlWriter);
return oXmlWriter.GetXmlString();
}
int nIndexTail = (int)strMainProps.find(L"<wp14:sizeRel");
if(-1 != nIndexTail)
{
strMainPropsTail = strMainProps.substr( nIndexTail );
strMainProps = strMainProps.substr(0, nIndexTail);
}
oXmlWriter.WriteString(strMainProps);
if (oElem.is<PPTX::Logic::SpTree>())
{
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>())
{
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
{
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\">");
}
oElem.toXmlWriter(&oXmlWriter);
oXmlWriter.WriteString(L"</a:graphicData></a:graphic>");
oXmlWriter.WriteString(strMainPropsTail);
oXmlWriter.WriteString(bIsInline ? L"</wp:inline>" : L"</wp:anchor>");
oXmlWriter.WriteString(L"</w:drawing>");
delete pMainProps;
return oXmlWriter.GetXmlString();
}
std::wstring CDrawingConverter::ObjectToVML (const std::wstring& sXml)
{
std::wstring *pMainProps = new std::wstring();
PPTX::Logic::SpTreeElem oElem = ObjectFromXml(sXml, &pMainProps);
if (oElem.is_init() == false) return L"";
NSBinPptxRW::CXmlWriter oXmlWriter(m_pReader->m_nDocumentType);
oXmlWriter.m_bIsUseOffice2007 = true;
oXmlWriter.m_bIsTop = true;
if (NULL == m_pOOXToVMLRenderer)
m_pOOXToVMLRenderer = new COOXToVMLGeometry();
oXmlWriter.m_pOOXToVMLRenderer = m_pOOXToVMLRenderer;
oXmlWriter.WriteString(L"<w:pict>");
if (oElem.is<PPTX::Logic::SpTree>())
{
ConvertGroupVML(oElem, *pMainProps, oXmlWriter);
}
else if (oElem.is<PPTX::Logic::Shape>())
{
ConvertShapeVML(oElem, *pMainProps, oXmlWriter);
}
oXmlWriter.WriteString(L"</w:pict>");
delete pMainProps;
return oXmlWriter.GetXmlString();
}
HRESULT 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 ? S_OK : S_FALSE;
}
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* mainProps = NULL;
std::wstring** ppMainProps = &mainProps;
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, ppMainProps, false);
elements.push_back(elem);
break;
}
else if (strName == L"pict" || strName == L"object")
{
//сначала shape type
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, ppMainProps, 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, ppMainProps, true);
}
}
else if (L"drawing" == strNameP)
{
if (false == pElem.IsInit())
{
pElem = new PPTX::Logic::SpTreeElem;
ConvertDrawing(pElem.GetPointer(), oNodeP, ppMainProps, 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 (mainProps)
{
strXml = _start_xml_object + *mainProps + _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(mainProps);
}
}
bool CDrawingConverter::ParceObject(const std::wstring& strXml, std::wstring** pMainProps)
{
XmlUtils::CXmlNode oMainNode;
if (!oMainNode.FromXmlString(strXml))
return NULL;
std::vector<XmlUtils::CXmlNode> oNodes;
if (!oMainNode.GetNodes(L"*", oNodes))
return NULL;
m_pBinaryWriter->StartRecord(0);
m_pBinaryWriter->ClearCurShapePositionAndSizes();
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
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 (pPicture->spPr.xfrm.IsInit())
{// for bad replacemant image for ole
m_pBinaryWriter->m_dCxCurShape = pPicture->spPr.xfrm->extX.get_value_or(0);
m_pBinaryWriter->m_dCyCurShape = pPicture->spPr.xfrm->extY.get_value_or(0);
}
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::ConvertDiagram(PPTX::Logic::SpTreeElem *result, XmlUtils::CXmlNode& oNode, std::wstring**& pMainProps, bool bIsTop)
{
if (!result) return;
nullable<OOX::RId> id_data;
nullable<OOX::RId> id_drawing;
smart_ptr<OOX::File> oFileData;
smart_ptr<OOX::File> oFileDrawing;
OOX::CDiagramData* pDiagramData = NULL;
OOX::CDiagramDrawing* pDiagramDrawing = NULL;
XmlMacroReadAttributeBase(oNode, L"r:dm", id_data);
if (id_data.IsInit())
{
oFileData = m_pBinaryWriter->GetRels()->Find(*id_data);
if (oFileData.is_init())
{
pDiagramData = dynamic_cast<OOX::CDiagramData*>(oFileData.GetPointer());
if ((pDiagramData) && (pDiagramData->m_oDataModel.IsInit()))
{
for (size_t i = 0; (pDiagramData->m_oDataModel->m_oExtLst.IsInit()) && i < pDiagramData->m_oDataModel->m_oExtLst->m_arrExt.size(); i++)
{
if (pDiagramData->m_oDataModel->m_oExtLst->m_arrExt[i]->m_oDataModelExt.IsInit())
{
id_drawing = pDiagramData->m_oDataModel->m_oExtLst->m_arrExt[i]->m_oDataModelExt->m_oRelId;
break;
}
}
}
}
if (id_drawing.is_init())
{
oFileDrawing = m_pBinaryWriter->GetRels()->Find(*id_drawing);
pDiagramDrawing = dynamic_cast<OOX::CDiagramDrawing*>(oFileDrawing.GetPointer());
}
if (!pDiagramDrawing && pDiagramData)
{
OOX::CPath pathDiagramData = pDiagramData->m_strFilename;
int a1 = (int)pathDiagramData.GetFilename().find(L".");
std::wstring strId = pathDiagramData.GetFilename().substr(4, pathDiagramData.GetFilename().length() - 8);
OOX::CPath pathDiagramDrawing = pathDiagramData.GetDirectory() + FILE_SEPARATOR_STR + L"drawing" + strId + L".xml";
if (NSFile::CFileBinary::Exists(pathDiagramDrawing.GetPath()))
{
oFileDrawing = smart_ptr<OOX::File>(dynamic_cast<OOX::File*>(new OOX::CDiagramDrawing(NULL, pathDiagramDrawing)));
if (oFileDrawing.IsInit())
pDiagramDrawing = dynamic_cast<OOX::CDiagramDrawing*>(oFileDrawing.GetPointer());
}
}
}
if ((pDiagramDrawing) && (pDiagramDrawing->m_oShapeTree.IsInit()))
{
result->InitElem(new PPTX::Logic::SpTree(*pDiagramDrawing->m_oShapeTree));
//to correct write blipFill rId to binary
SetRels(pDiagramDrawing);
}
else
{//BG-FSC1.docx
//parse pDiagramData !!
}
if (result->is<PPTX::Logic::SpTree>())
{
PPTX::Logic::SpTree& _pElem = result->as<PPTX::Logic::SpTree>();
if (!_pElem.grpSpPr.xfrm.is_init())
{
_pElem.grpSpPr.xfrm = new PPTX::Logic::Xfrm();
_pElem.grpSpPr.xfrm->offX = m_pBinaryWriter->m_dXCurShape;
_pElem.grpSpPr.xfrm->offY = m_pBinaryWriter->m_dYCurShape;
_pElem.grpSpPr.xfrm->extX = m_pBinaryWriter->m_dCxCurShape;
_pElem.grpSpPr.xfrm->extY = m_pBinaryWriter->m_dCyCurShape;
_pElem.grpSpPr.xfrm->chOffX = (int)0;
_pElem.grpSpPr.xfrm->chOffY = (int)0;
_pElem.grpSpPr.xfrm->chExtX = m_pBinaryWriter->m_dCxCurShape;
_pElem.grpSpPr.xfrm->chExtY = m_pBinaryWriter->m_dCyCurShape;
}
else
{
if (!_pElem.grpSpPr.xfrm->offX.is_init()) _pElem.grpSpPr.xfrm->offX = m_pBinaryWriter->m_dXCurShape;
if (!_pElem.grpSpPr.xfrm->offY.is_init()) _pElem.grpSpPr.xfrm->offY = m_pBinaryWriter->m_dYCurShape;
if (!_pElem.grpSpPr.xfrm->extX.is_init()) _pElem.grpSpPr.xfrm->extX = m_pBinaryWriter->m_dCxCurShape;
if (!_pElem.grpSpPr.xfrm->extY.is_init()) _pElem.grpSpPr.xfrm->extY = m_pBinaryWriter->m_dCyCurShape;
if (!_pElem.grpSpPr.xfrm->chOffX.is_init()) _pElem.grpSpPr.xfrm->chOffX = (int)0;
if (!_pElem.grpSpPr.xfrm->chOffY.is_init()) _pElem.grpSpPr.xfrm->chOffY = (int)0;
if (!_pElem.grpSpPr.xfrm->chExtX.is_init()) _pElem.grpSpPr.xfrm->chExtX = m_pBinaryWriter->m_dCxCurShape;
if (!_pElem.grpSpPr.xfrm->chExtY.is_init()) _pElem.grpSpPr.xfrm->chExtY = m_pBinaryWriter->m_dCyCurShape;
}
}
}
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;
m_pBinaryWriter->m_dXCurShape = 0;
m_pBinaryWriter->m_dYCurShape = 0;
if (oNodeAnchorInline.GetNode(L"wp:extent", oNodeExt))
{
m_pBinaryWriter->m_dCxCurShape = oNodeExt.ReadAttributeInt(L"cx");
m_pBinaryWriter->m_dCyCurShape = oNodeExt.ReadAttributeInt(L"cy");
}
XmlUtils::CXmlNode oNodeDocPr;
if (oNodeAnchorInline.GetNode(L"wp:docPr", oNodeDocPr))
{//vml shapes without id .. reset all id
oNodeDocPr.SetAttributeInt(L"id", m_lNextId++);
}
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"dgm:relIds" == oNodeContent.GetName() && m_pBinaryWriter->m_pCurrentContainer->is_init())
{
ConvertDiagram(elem, oNodeContent, pMainProps, true);
}
else */if (L"wpc:wpc" == oNodeContent.GetName())
{
PPTX::Logic::SpTree* pTree = new PPTX::Logic::SpTree();
pTree->grpSpPr.xfrm = new PPTX::Logic::Xfrm();
pTree->grpSpPr.xfrm->offX = m_pBinaryWriter->m_dXCurShape;
pTree->grpSpPr.xfrm->offY = m_pBinaryWriter->m_dYCurShape;
pTree->grpSpPr.xfrm->extX = m_pBinaryWriter->m_dCxCurShape;
pTree->grpSpPr.xfrm->extY = m_pBinaryWriter->m_dCyCurShape;
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]));
}
}
// теперь определяем 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);
// иначе сохранится рект
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);
// иначе сохранится рект
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);
// в старых шейпах текст крутится отдельно
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 эту хрень делает
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 прописать все остальное
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; //для docx, xlsx
if (pShape->txBody.IsInit() == false) //для 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) //для pptx /// todooo схлопнуть
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) //для 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); //для docx, xlsx
pShape->oTextBoxBodyPr->Fit.type = PPTX::Logic::TextFit::FitNormAuto;
if (pShape->txBody.IsInit() == false) //для 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->GetRels().IsInit())
{
OOX::RId rId(sId);
smart_ptr<PPTX::LegacyDiagramText> pExt = m_pBinaryWriter->GetRels()->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;
}
}
//-------------------------------------------------------------------------------------------------------------------
XmlUtils::CXmlNode oNodeG;
oNodeG.FromXmlString(strXmlPPTX);
pSpPr->Geometry = oNodeG;
std::wstring strStyle = oNodeShape.GetAttribute(L"style") + strStyleAdvenced;
PPTX::CCSS oCSSParser;
oCSSParser.LoadFromString2(strStyle);
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();
if (*pMainProps)
{//oProps.X выставлять не надо, они учтены в pMainProps
pSpPr->xfrm->offX = 0;
pSpPr->xfrm->offY = 0;
}
else
{
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
{
m_pBinaryWriter->m_dXCurShape = 0;
m_pBinaryWriter->m_dYCurShape = 0;
m_pBinaryWriter->m_dCxCurShape = 0;
m_pBinaryWriter->m_dCyCurShape = 0;
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(); //для обхода &#xA пишется дубль в контент
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
{
//дублирование
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\"/>";
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
{
//не существует в природе
}
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::wstring sParaRun = L"<w:r><w:rPr>" + strRPr + L"</w:rPr>" + L"<w:t>" + wordArtString[i] + 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;
}
}
// у старого wordArt никаких отступов
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)
{
// нужно для данного размера шейпа выставить отступы сверху и снизу
// 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
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);
}
}
}
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;
}
}
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);
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;
pFind = oCssStyles.m_mapSettings.find(L"polyline_correct");
bool bIsPolyCorrect = (oCssStyles.m_mapSettings.end() != pFind) ? true : false;
if (bIsPolyCorrect)
dKoefSize = 1;
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;
m_pBinaryWriter->m_dXCurShape = left;
m_pBinaryWriter->m_dYCurShape = top;
m_pBinaryWriter->m_dCxCurShape = width;
m_pBinaryWriter->m_dCyCurShape = 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();
}
std::wstring CDrawingConverter::GetVMLShapeXml(PPTX::Logic::SpTreeElem& oElem)
{
CPPTXShape* pShapePPTX = NULL;
if (oElem.is<PPTX::Logic::Shape>())
{
const PPTX::Logic::Shape& lpOriginShape = oElem.as<PPTX::Logic::Shape>();
if (lpOriginShape.spPr.Geometry.is<PPTX::Logic::PrstGeom>())
{
const PPTX::Logic::PrstGeom lpGeom = lpOriginShape.spPr.Geometry.as<PPTX::Logic::PrstGeom>();
OOXMLShapes::ShapeType _lspt = PPTX2EditorAdvanced::GetShapeTypeFromStr(lpGeom.prst.get());
if(_lspt != OOXMLShapes::sptNil)
{
pShapePPTX = new CPPTXShape();
pShapePPTX->SetType(NSBaseShape::pptx, _lspt);
std::wstring strAdjustValues = lpGeom.GetODString();
pShapePPTX->LoadAdjustValuesList(strAdjustValues);
}
}
else if(lpOriginShape.spPr.Geometry.is<PPTX::Logic::CustGeom>())
{
const PPTX::Logic::CustGeom lpGeom = lpOriginShape.spPr.Geometry.as<PPTX::Logic::CustGeom>();
std::wstring strShape = lpGeom.GetODString();
pShapePPTX = new CPPTXShape();
pShapePPTX->LoadFromXML(strShape);
}
else
{
pShapePPTX = new CPPTXShape();
pShapePPTX->SetType(NSBaseShape::pptx, (int)OOXMLShapes::sptCRect);
}
}
if (NULL != pShapePPTX)
{
NSGuidesVML::CConverterPPTXPPT oConverterPPTX_2_PPT;
oConverterPPTX_2_PPT.Convert(pShapePPTX);
std::wstring sDumpXml = GetVMLShapeXml(oConverterPPTX_2_PPT.GetConvertedShape());
return sDumpXml;
}
return L"";
}
std::wstring CDrawingConverter::GetVMLShapeXml(CPPTShape* pPPTShape)
{
NSBinPptxRW::CXmlWriter oXmlWriter;
oXmlWriter.StartNode(L"v:shape");
oXmlWriter.StartAttributes();
std::wstring strCoordSize;
LONG lCoordW = 21600;
LONG lCoordH = 21600;
if (0 < pPPTShape->m_oPath.m_arParts.size())
{
lCoordW = pPPTShape->m_oPath.m_arParts[0].width;
lCoordH = pPPTShape->m_oPath.m_arParts[0].height;
}
strCoordSize = std::to_wstring(lCoordW) + L"," + std::to_wstring(lCoordH);
oXmlWriter.WriteAttribute(L"coordsize", strCoordSize);
int nAdjCount = (int)pPPTShape->m_arAdjustments.size();
if (nAdjCount > 0)
{
oXmlWriter.WriteString(L" adj=\"");
for (int i = 0; i < nAdjCount; ++i)
{
if (0 != i)
{
std::wstring s = L"," + std::to_wstring(pPPTShape->m_arAdjustments[i]);
oXmlWriter.WriteString(s);
}
else
{
oXmlWriter.WriteString(std::to_wstring(pPPTShape->m_arAdjustments[i]));
}
}
oXmlWriter.WriteString(L"\"");
}
oXmlWriter.WriteAttribute(L"path", pPPTShape->m_strPath);
oXmlWriter.EndAttributes();
std::vector<CFormula>& arGuides = pPPTShape->m_oManager.m_arFormulas;
int nGuides = (int)arGuides.size();
if (nGuides != 0)
{
oXmlWriter.StartNode(L"v:formulas");
oXmlWriter.StartAttributes();
oXmlWriter.EndAttributes();
for (int i = 0; i < nGuides; ++i)
{
CFormula& oGuide = arGuides[i];
if ((int)oGuide.m_eFormulaType >= VML_GUIDE_COUNT)
break;
oXmlWriter.WriteString(L"<v:f eqn=\"");
oXmlWriter.WriteString(VML_GUIDE_TYPE[(int)oGuide.m_eFormulaType]);
BYTE nParams = VML_GUIDE_PARAM_COUNT[(int)oGuide.m_eFormulaType];
if (nParams > 0)
{
std::wstring str;
if (oGuide.m_eType1 == ptAdjust)
{
str = L" #";
}
else if (oGuide.m_eType1 == ptFormula)
{
str = L" @";
}
else
{
str = L" ";
}
str += std::to_wstring(oGuide.m_lParam1);
oXmlWriter.WriteString(str);
}
if (nParams > 1)
{
std::wstring str;
if (oGuide.m_eType2 == ptAdjust)
{
str = L" #";
}
else if (oGuide.m_eType2 == ptFormula)
{
str = L" @";
}
else
{
str = L" ";
}
str += std::to_wstring(oGuide.m_lParam2);
oXmlWriter.WriteString(str);
}
if (nParams > 2)
{
std::wstring str ;
if (oGuide.m_eType3 == ptAdjust)
{
str = L" #";
}
else if (oGuide.m_eType3 == ptFormula)
{
str = L" @";
}
else
{
str = L" ";
}
str += std::to_wstring(oGuide.m_lParam3);
oXmlWriter.WriteString(str);
}
oXmlWriter.WriteString(L"\"/>");
}
oXmlWriter.EndNode(L"v:formulas");
size_t nTextRectCount = pPPTShape->m_arStringTextRects.size();
if (0 < nTextRectCount)
{
oXmlWriter.WriteString(L"<v:path textboxrect=\"");
for (size_t i = 0; i < nTextRectCount; ++i)
{
if (0 != i)
oXmlWriter.WriteString(L",");
oXmlWriter.WriteString(pPPTShape->m_arStringTextRects[i]);
}
oXmlWriter.WriteString(L"\"/>");
}
int nHandles = (int)pPPTShape->m_arHandles.size();
if (0 < nHandles)
{
oXmlWriter.StartNode(L"v:handles");
oXmlWriter.StartAttributes();
oXmlWriter.EndAttributes();
for (int i = 0; i < nHandles; ++i)
{
oXmlWriter.StartNode(L"v:h");
CHandle_& oH = pPPTShape->m_arHandles[i];
if (oH.position != L"")
oXmlWriter.WriteAttribute(L"position", oH.position);
if (oH.xrange != L"")
oXmlWriter.WriteAttribute(L"xrange", oH.xrange);
if (oH.yrange != L"")
oXmlWriter.WriteAttribute(L"yrange", oH.yrange);
if (oH.polar != L"")
oXmlWriter.WriteAttribute(L"polar", oH.polar);
if (oH.radiusrange != L"")
oXmlWriter.WriteAttribute(L"radiusrange", oH.radiusrange);
if (oH.switchHandle != L"")
oXmlWriter.WriteAttribute(L"switch", oH.switchHandle);
oXmlWriter.WriteString(L"/>");
}
oXmlWriter.EndNode(L"v:handles");
}
}
oXmlWriter.EndNode(L"v:shape");
return oXmlWriter.GetXmlString();
}
void CDrawingConverter::SendMainProps(const std::wstring& strMainProps, std::wstring**& pMainProps)
{
if (((m_pBinaryWriter) && (m_pBinaryWriter->m_pMainDocument)) || !m_pBinaryWriter || m_bNeedMainProps)
{
*pMainProps = new std::wstring();
**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; //дублирование обрамлением линией
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;
}
HRESULT 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 S_FALSE;
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_pReader->GenerateNextId());
strMainProps += strId;
*/
//strMainProps += L"<wp:cNvGraphicFramePr/>");
m_pReader->Seek(lStart);
++m_nCurrentIndexObject;
BYTE typeRec1 = m_pReader->GetUChar(); // must be 0;
LONG szRec1 = m_pReader->GetRecordSize();
LONG _e = m_pReader->GetPos() + szRec1 + 4;
if (typeRec1 == 0 && szRec1 > 0)
{
BYTE typeRec2 = m_pReader->GetUChar(); // must be 1;
LONG szRec2 = m_pReader->GetLong();
if (typeRec2 == 1 && szRec2 > 0)
{
PPTX::Logic::SpTreeElem oElem;
if (m_pReader->m_nDocumentType == 0)
m_pReader->m_nDocumentType = XMLWRITER_DOC_TYPE_DOCX;
oElem.fromPPTY(m_pReader);
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;
}
}
NSBinPptxRW::CXmlWriter oXmlWriter(m_pReader->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
{
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_pReader->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_pReader->Seek(_e);
return S_OK;
}
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;
}
HRESULT CDrawingConverter::SaveObjectEx(LONG lStart, LONG lLength, const std::wstring& bsMainProps, int nDocType, std::wstring & sXml)
{
m_pImageManager->m_nDocumentType = nDocType;
if (XMLWRITER_DOC_TYPE_DOCX == nDocType ||
XMLWRITER_DOC_TYPE_DOCX_GLOSSARY == nDocType) //docx
{
m_pReader->m_nDocumentType = nDocType;
return SaveObject(lStart, lLength, bsMainProps, sXml);
}
else
{
PPTX::Logic::SpTreeElem oElem;
m_pReader->Seek(lStart);
m_pReader->m_nDocumentType = nDocType;
++m_nCurrentIndexObject;
BYTE typeRec1 = m_pReader->GetUChar(); // must be 0;
LONG _e = m_pReader->GetPos() + m_pReader->GetLong() + 4;
try
{
m_pReader->Skip(5); // type record (must be 1) + 4 byte - len record
oElem.fromPPTY(m_pReader);
}
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_pReader->m_nDocumentType = XMLWRITER_DOC_TYPE_PPTX;
NSBinPptxRW::CXmlWriter oXmlWriter;
SaveObjectExWriterInit(oXmlWriter, nDocType);
if(bOle)
{
ConvertPicVML(oElem, bsMainProps, oXmlWriter);
}
else
{
oElem.toXmlWriter(&oXmlWriter);
}
--m_nCurrentIndexObject;
SaveObjectExWriterRelease(oXmlWriter);
sXml = oXmlWriter.GetXmlString();
m_pReader->Seek(_e);
}
return S_OK;
}
std::wstring CDrawingConverter::SaveObjectBackground(LONG lStart, LONG lLength)
{
if (lLength < 1) return L"";
m_pReader->Seek(lStart);
++m_nCurrentIndexObject;
BYTE typeRec1 = m_pReader->GetUChar(); // must be 0;
LONG _e = m_pReader->GetPos() + m_pReader->GetRecordSize() + 4;
PPTX::Logic::SpTreeElem oElem;
try
{
m_pReader->Skip(5); // type record (must be 1) + 4 byte - len record
oElem.fromPPTY(m_pReader);
}
catch(...)
{
//todooo
}
NSBinPptxRW::CXmlWriter oXmlWriter;
SaveObjectExWriterInit(oXmlWriter, m_pReader->m_nDocumentType);
m_pReader->m_nDocumentType = XMLWRITER_DOC_TYPE_PPTX;
if (oElem.is<PPTX::Logic::Shape>())
{
oXmlWriter.m_bIsTop = true; // не забыть скинуть в самом шейпе
PPTX::Logic::Shape& oShape = oElem.as<PPTX::Logic::Shape>();
smart_ptr<OOX::IFileContainer> rels = GetRels();
oShape.toXmlWriterVMLBackground(&oXmlWriter, *m_pTheme, *m_pClrMap, rels);
}
--m_nCurrentIndexObject;
SaveObjectExWriterRelease(oXmlWriter);
m_pReader->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; // не забыть скинуть в самом шейпе
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; // не забыть скинуть в самом шейпе
PPTX::Logic::Shape& oShape = oElem.as<PPTX::Logic::Shape>();
smart_ptr<OOX::IFileContainer> rels = GetRels();
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; // не забыть скинуть в самом шейпе (вместе с остальными параметрами)
PPTX::Logic::SpTree& oGroup = oElem.as<PPTX::Logic::SpTree>();
smart_ptr<OOX::IFileContainer> rels = GetRels();
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();
}
//HRESULT CDrawingConverter::GetTxBodyBinary(const std::wstring& bsXml)
//{
// XmlUtils::CXmlNode oNode;
// if (!oNode.FromXmlString((std::wstring)bsXml))
// return S_FALSE;
//
// PPTX::Logic::TxBody oTxBody(oNode);
//
// //m_pBinaryWriter->ClearNoAttack();
// //ULONG lOldPos = m_pBinaryWriter->GetPosition();
// m_pBinaryWriter->m_pCommon->CheckFontPicker();
// //m_pBinaryWriter->m_pCommon->m_pNativePicker->Init(m_strFontDirectory);
//
// m_pBinaryWriter->WriteRecord1(0, oTxBody);
//
// //m_pBinaryWriter->SetPosition(lOldPos);
//
// //m_pBinaryWriter->ClearNoAttack();
// return S_OK;
//}
//HRESULT CDrawingConverter::GetTxBodyXml(LONG lStart, std::wstring& sXml)
//{
// m_pReader->Seek(lStart);
//
// BYTE type = m_pReader->GetUChar();
// if (0 != type)
// return S_FALSE;
//
// PPTX::Logic::TxBody oTxBody;
// oTxBody.fromPPTY(m_pReader);
//
// NSBinPptxRW::CXmlWriter oWriter;
// oTxBody.toXmlWriterExcel(&oWriter);
//
// sXml = oWriter.GetXmlString();
//
// return S_OK;
//}
HRESULT CDrawingConverter::SetFontDir(const std::wstring& bsFontDir)
{
m_strFontDirectory = bsFontDir;
return S_OK;
}
HRESULT CDrawingConverter::GetRecordBinary(LONG lRecordType, const std::wstring& sXml)
{
if (sXml.empty())
return S_FALSE;
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\" \
xmlns:xdr=\"http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing\" \
xmlns:c=\"http://schemas.openxmlformats.org/drawingml/2006/chart\"";
strXml += L">";
strXml += sXml;
strXml += L"</main>";
XmlUtils::CXmlNode oNodeMain;
if (!oNodeMain.FromXmlString(strXml))
return S_FALSE;
std::vector<XmlUtils::CXmlNode> oNodes;
if (!oNodeMain.GetNodes(L"*", oNodes))
return S_FALSE;
if (1 != oNodes.size())
return S_FALSE;
XmlUtils::CXmlNode & oNode = oNodes[0];
PPTX::WrapperWritingElement* pWritingElem = NULL;
switch (lRecordType)
{
case XMLWRITER_RECORD_TYPE_SPPR:
{
PPTX::Logic::SpPr* pSpPr = new PPTX::Logic::SpPr();
*pSpPr = oNode;
pWritingElem = (PPTX::WrapperWritingElement*)pSpPr;
break;
}
case XMLWRITER_RECORD_TYPE_CLRMAPOVR:
{
PPTX::Logic::ClrMap* pClrMap = new PPTX::Logic::ClrMap();
*pClrMap = oNode;
pWritingElem = (PPTX::WrapperWritingElement*)pClrMap;
break;
}
case XMLWRITER_RECORD_TYPE_TEXT_OUTLINE:
{
PPTX::Logic::Ln* pLn = new PPTX::Logic::Ln();
*pLn = oNode;
pWritingElem = (PPTX::WrapperWritingElement*)pLn;
break;
}
case XMLWRITER_RECORD_TYPE_TEXT_FILL:
{
PPTX::Logic::UniFill* pUniFill = new PPTX::Logic::UniFill();
pUniFill->GetFillFrom(oNode);
pWritingElem = (PPTX::WrapperWritingElement*)pUniFill;
break;
}
default:
break;
}
if (NULL == pWritingElem)
return S_FALSE;
//m_pBinaryWriter->ClearNoAttack();
m_pBinaryWriter->m_pCommon->CheckFontPicker();
//ULONG lOldPos = m_pBinaryWriter->GetPosition();
m_pBinaryWriter->WriteRecord1(0, *pWritingElem);
RELEASEOBJECT(pWritingElem);
//m_pBinaryWriter->SetPosition(lOldPos);
return S_OK;
}
HRESULT CDrawingConverter::GetRecordXml(LONG lStart, LONG lLength, LONG lRecType, int nDocType, std::wstring & sXml)
{
if (NULL == m_pReader)
return S_FALSE;
m_pReader->m_pRels->m_pManager->m_nDocumentType = nDocType;
m_pReader->Seek(lStart);
BYTE typeRec1 = m_pReader->GetUChar();
PPTX::WrapperWritingElement* pWritingElem = NULL;
switch (lRecType)
{
case XMLWRITER_RECORD_TYPE_SPPR:
{
pWritingElem = (PPTX::WrapperWritingElement*)(new PPTX::Logic::SpPr());
pWritingElem->fromPPTY(m_pReader);
break;
}
case XMLWRITER_RECORD_TYPE_CLRMAPOVR:
{
PPTX::Logic::ClrMap* pClrMap = new PPTX::Logic::ClrMap();
pClrMap->m_name = L"a:clrMapOvr";
pWritingElem = (PPTX::WrapperWritingElement*)(pClrMap);
pWritingElem->fromPPTY(m_pReader);
break;
}
case XMLWRITER_RECORD_TYPE_TEXT_OUTLINE:
{
PPTX::Logic::Ln* pLn = new PPTX::Logic::Ln();
pWritingElem = (PPTX::WrapperWritingElement*)(pLn);
pWritingElem->fromPPTY(m_pReader);
break;
}
case XMLWRITER_RECORD_TYPE_TEXT_FILL:
{
PPTX::Logic::UniFill* pUniFill = new PPTX::Logic::UniFill();
pWritingElem = (PPTX::WrapperWritingElement*)(pUniFill);
pWritingElem->fromPPTY(m_pReader);
break;
}
default:
break;
}
if (NULL == pWritingElem)
return S_FALSE;
NSBinPptxRW::CXmlWriter oXmlWriter;
oXmlWriter.m_lDocType = (BYTE)nDocType;
oXmlWriter.m_bIsUseOffice2007 = false;
oXmlWriter.m_bIsTop = true;
pWritingElem->toXmlWriter(&oXmlWriter);
sXml = oXmlWriter.GetXmlString();
RELEASEOBJECT(pWritingElem);
return S_OK;
}
void CDrawingConverter::SetDstContentRels()
{
m_pReader->SetDstContentRels();
}
void CDrawingConverter::SaveDstContentRels(const std::wstring& bsRelsPath)
{
m_pReader->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_pReader) return;
if (NULL == m_pReader->m_pRels) return;
*lId = m_pReader->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));
}
HRESULT CDrawingConverter::SetFontPicker(COfficeFontPicker* pFontPicker)
{
m_pBinaryWriter->m_pCommon->CreateFontPicker(pFontPicker);
return S_OK;
}
HRESULT 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);
}
return S_OK;
}
HRESULT CDrawingConverter::GetAdditionalParam(const std::wstring& ParamName, BYTE **pArray, size_t& szCount)
{
//std::wstring name = ParamName;
//if (name == L"SerializeImageManager")
//{
// NSBinPptxRW::CBinaryFileWriter oWriter;
// return oWriter.Serialize(m_pBinaryWriter->m_pCommon->m_pImageManager, pArray, szCount) ? S_OK : S_FALSE;
//}
//else if (name == L"SerializeImageManager2")
//{
// NSBinPptxRW::CBinaryFileWriter oWriter;
// return oWriter.Serialize(m_pImageManager, pArray, szCount) ? S_OK : S_FALSE;
//}
return S_OK;
}
OOX::CContentTypes* CDrawingConverter::GetContentTypes()
{
return m_pImageManager->m_pContentTypes;
}
void CDrawingConverter::SetRels(smart_ptr<OOX::IFileContainer> container)
{
m_pBinaryWriter->SetRels(container);
}
void CDrawingConverter::SetRels(OOX::IFileContainer *container)
{
m_pBinaryWriter->SetRels(container);
}
smart_ptr<OOX::IFileContainer> CDrawingConverter::GetRels()
{
return m_pBinaryWriter->GetRels();
}
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