mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-04-07 13:55:33 +08:00
1237 lines
34 KiB
C++
1237 lines
34 KiB
C++
#include "stdafx.h"
|
||
|
||
#include "../Common/FormatUtils.h"
|
||
|
||
#include "OfficeArt/OfficeArtFOPTE.h"
|
||
#include "OfficeArt/OfficeArtFOPTEOPID.h"
|
||
#include "OfficeArt/OfficeArtFOPTE.h"
|
||
#include "OfficeArt/Common.h"
|
||
|
||
#include "ShapeSettings.h"
|
||
|
||
namespace AVSDocFileFormat
|
||
{
|
||
CStyle::CStyle()
|
||
{
|
||
|
||
}
|
||
|
||
void CStyle::AppendEntry (int nID, int nValue, bool bBid, bool bComplex)
|
||
{
|
||
OfficeArtFOPTEOPID id (nID, bBid, bComplex);
|
||
OfficeArtFOPTE oStyle (id, nValue);
|
||
|
||
m_arTable.push_back(ComplexOfficeArtProperty(oStyle));
|
||
}
|
||
void CStyle::AppendEntry2 (int nID, int nValue, bool bBid, bool bComplex)
|
||
{
|
||
OfficeArtFOPTEOPID id (nID, bBid, bComplex);
|
||
OfficeArtFOPTE oStyle (id, nValue);
|
||
|
||
m_arTable2.push_back(ComplexOfficeArtProperty(oStyle));
|
||
}
|
||
|
||
template<class T> void CStyle::AppenComplexEntry (int nID, bool bBid, T& oArray)
|
||
{
|
||
OfficeArtFOPTEOPID id (nID, bBid, true);
|
||
OfficeArtFOPTE oStyle (id, oArray.GetSize());
|
||
|
||
//if(oArray.GetSize())
|
||
m_arTable.push_back (ComplexOfficeArtProperty(oStyle, oArray.Get()));
|
||
//else
|
||
// m_arTable.push_back(ComplexOfficeArtProperty(oStyle));
|
||
}
|
||
}
|
||
|
||
namespace AVSDocFileFormat
|
||
{
|
||
CGroupShapeStyle::CGroupShapeStyle()
|
||
{
|
||
m_posh = Enumerations::msophAbs;
|
||
m_posv = Enumerations::msopvAbs;
|
||
m_posrelh = Enumerations::msoprhText;
|
||
m_posrelv = Enumerations::msoprvText;
|
||
|
||
m_pctHoriz = 0;
|
||
m_pctVert = 0;
|
||
m_sizerelh = 0;
|
||
m_sizerelv = 0;
|
||
}
|
||
|
||
BOOL CGroupShapeStyle::SetVisible (const std::string& strVisible)
|
||
{
|
||
if (std::string("hidden") == strVisible)
|
||
{
|
||
m_groupShapeBooleanProperties.fHidden = true;
|
||
m_groupShapeBooleanProperties.fUsefHidden = true;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
void CGroupShapeStyle::SetUseBehind (bool bUse)
|
||
{
|
||
m_groupShapeBooleanProperties.fBehindDocument = bUse;
|
||
m_groupShapeBooleanProperties.fUsefBehindDocument = bUse;
|
||
}
|
||
|
||
void CGroupShapeStyle::SetPositioning (const std::string& posh, const std::string& posrelh, const std::string& posv, const std::string& posrelv)
|
||
{
|
||
if (std::string("center") == posh)
|
||
m_posh = Enumerations::msophCenter;
|
||
else if (std::string("inside") == posh)
|
||
m_posh = Enumerations::msophInside;
|
||
else if (std::string("left") == posh)
|
||
m_posh = Enumerations::msophLeft;
|
||
else if (std::string("right") == posh)
|
||
m_posh = Enumerations::msophRight;
|
||
else if (std::string("outside") == posh)
|
||
m_posh = Enumerations::msophOutside;
|
||
|
||
if (std::string("center") == posv)
|
||
m_posv = Enumerations::msopvCenter;
|
||
else if (std::string("inside") == posv)
|
||
m_posv = Enumerations::msopvInside;
|
||
else if (std::string("top") == posv)
|
||
m_posv = Enumerations::msopvTop;
|
||
else if (std::string("bottom") == posv)
|
||
m_posv = Enumerations::msopvBottom;
|
||
else if (std::string("outside") == posv)
|
||
m_posv = Enumerations::msopvOutside;
|
||
|
||
if (std::string("margin") == posrelh)
|
||
m_posrelh = Enumerations::msoprhMargin - 1;
|
||
else if (std::string("page") == posrelh)
|
||
m_posrelh = Enumerations::msoprhPage - 1;
|
||
else if (std::string("text") == posrelh)
|
||
m_posrelh = Enumerations::msoprhText - 1;
|
||
else if (std::string("character") == posrelh)
|
||
m_posrelh = Enumerations::msoprhChar - 1;
|
||
|
||
if (std::string("margin") == posrelv)
|
||
m_posrelv = Enumerations::msoprhMargin - 1;
|
||
else if (std::string("page") == posrelv)
|
||
m_posrelv = Enumerations::msoprhPage - 1;
|
||
else if (std::string("text") == posrelv)
|
||
m_posrelv = Enumerations::msoprvText - 1;
|
||
else if (std::string("line") == posrelv)
|
||
m_posrelv = Enumerations::msoprvLine - 1;
|
||
|
||
|
||
//if (std::string("margin") == posrelh)
|
||
// m_posrelh = Enumerations::msoprhMargin;
|
||
//else if (std::string("page") == posrelh)
|
||
// m_posrelh = Enumerations::msoprhPage;
|
||
//else if (std::string("character") == posrelh)
|
||
// m_posrelh = Enumerations::msoprhChar;
|
||
//else if (std::string("column") == posrelh)
|
||
// m_posrelh = Enumerations::msoprhText;
|
||
//else if (std::string("leftMargin") == posrelh || std::string("left-margin-area") == posrelh)
|
||
// m_posrelh = 4;
|
||
//else if (std::string("rightMargin") == posrelh || std::string("right-margin-area") == posrelh)
|
||
// m_posrelh = 5;
|
||
//else if (std::string("insideMargin") == posrelh || std::string("inside-margin-area") == posrelh)
|
||
// m_posrelh = 6;
|
||
//else if (std::string("outsideMargin") == posrelh || std::string("outside-margin-area") == posrelh)
|
||
// m_posrelh = 7;
|
||
|
||
//if ( std::string("margin") == posrelv)
|
||
// m_posrelv = Enumerations::msoprhMargin;
|
||
//else if (std::string("page") == posrelv)
|
||
// m_posrelv = Enumerations::msoprhPage;
|
||
//else if (std::string("paragraph") == posrelv)
|
||
// m_posrelv = Enumerations::msoprvText;
|
||
//else if (std::string("line") == posrelv)
|
||
// m_posrelv = Enumerations::msoprvLine;
|
||
//else if (std::string("topMargin") == posrelv || std::string("top-margin-area") == posrelv)
|
||
// m_posrelv = 4;
|
||
//else if (std::string("bottomMargin") == posrelv || std::string("bottom-margin-area") == posrelv)
|
||
// m_posrelv = 5;
|
||
//else if (std::string("insideMargin") == posrelv || std::string("inside-margin-area") == posrelv)
|
||
// m_posrelv = 6;
|
||
//else if (std::string("outsideMargin") == posrelv || std::string("outside-margin-area") == posrelv)
|
||
// m_posrelv = 7;
|
||
}
|
||
|
||
void CGroupShapeStyle::SetPercentageSettings (const std::string& strPctHoriz, const std::string& strPctVert, const std::string& strSizeRelh, const std::string& strSizeRelv)
|
||
{
|
||
if (strPctHoriz.length())
|
||
{
|
||
m_pctHoriz = (unsigned int)atof(strPctHoriz.c_str());
|
||
if (m_pctHoriz)
|
||
{
|
||
if (std::string("margin") == strSizeRelh)
|
||
m_sizerelh = 0;
|
||
else if (std::string("page") == strSizeRelh)
|
||
m_sizerelh = 1;
|
||
else if (std::string("leftMargin") == strSizeRelh || std::string("left-margin-area") == strSizeRelh)
|
||
m_sizerelh = 2;
|
||
else if (std::string("rightMargin") == strSizeRelh || std::string("right-margin-area") == strSizeRelh)
|
||
m_sizerelh = 3;
|
||
else if (std::string("insideMargin") == strSizeRelh || std::string("inside-margin-area") == strSizeRelh)
|
||
m_sizerelh = 4;
|
||
else if (std::string("outsideMargin") == strSizeRelh || std::string("outside-margin-area") == strSizeRelh)
|
||
m_sizerelh = 5;
|
||
}
|
||
}
|
||
|
||
if (strPctVert.length())
|
||
{
|
||
m_pctVert = (unsigned int)atof(strPctVert.c_str());
|
||
if (m_pctVert)
|
||
{
|
||
if (std::string("margin") == strSizeRelv)
|
||
m_sizerelv = 0;
|
||
else if (std::string("page") == strSizeRelv)
|
||
m_sizerelv = 1;
|
||
else if (std::string("topMargin") == strSizeRelv || std::string("top-margin-area") == strSizeRelv)
|
||
m_sizerelv = 2;
|
||
else if (std::string("bottomMargin") == strSizeRelv || std::string("bottom-margin-area") == strSizeRelv)
|
||
m_sizerelv = 3;
|
||
else if (std::string("insideMargin") == strSizeRelv || std::string("inside-margin-area") == strSizeRelv)
|
||
m_sizerelv = 4;
|
||
else if (std::string("outsideMargin") == strSizeRelv || std::string("outside-margin-area") == strSizeRelv)
|
||
m_sizerelv = 5;
|
||
}
|
||
}
|
||
}
|
||
|
||
BOOL CGroupShapeStyle::Append(OfficeArtRGFOPTE& oTable, BOOL bLayout)
|
||
{
|
||
m_arTable.clear();
|
||
|
||
if (m_posh)
|
||
AppendEntry(Enumerations::posh, m_posh);
|
||
if (m_posrelh)
|
||
AppendEntry(Enumerations::posrelh, m_posrelh);
|
||
if (m_posv)
|
||
AppendEntry(Enumerations::posv, m_posv);
|
||
if (m_posrelv)
|
||
AppendEntry(Enumerations::posrelv, m_posrelv);
|
||
|
||
AppendEntry (OfficeArt::Enumerations::groupShapeBooleanProperties, m_groupShapeBooleanProperties.Get());
|
||
|
||
//AppendEntry (OfficeArt::Enumerations::diagramBooleans, 0x00010000);
|
||
|
||
//if (m_pctHoriz)
|
||
// AppendEntry (Enumerations::pctHoriz, m_pctHoriz);
|
||
//if (m_pctVert)
|
||
// AppendEntry (Enumerations::pctVert, m_pctVert);
|
||
|
||
// POS...
|
||
|
||
//if (m_sizerelh)
|
||
// AppendEntry (Enumerations::sizerelh, m_sizerelh);
|
||
//if (m_sizerelv)
|
||
// AppendEntry (Enumerations::sizerelv, m_sizerelv);
|
||
|
||
if (m_arTable.size())
|
||
{
|
||
for (size_t i = 0; i < m_arTable.size(); ++i)
|
||
oTable.PushComplexProperty(m_arTable[i]);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
namespace AVSDocFileFormat
|
||
{
|
||
CGeometryStyle::CGeometryStyle()
|
||
{
|
||
m_oGeometryBooleans.fLineOK = true;
|
||
m_oGeometryBooleans.fUsefLineOK = true;
|
||
|
||
m_oGeometryBooleans.fFillOK = true;
|
||
m_oGeometryBooleans.fUsefFillOK = true;
|
||
|
||
m_nGeoLeft = 0;
|
||
m_nGeoTop = 0;
|
||
m_nGeoRight = 21600;
|
||
m_nGeoBottom = 21600;
|
||
|
||
m_bAdjustArc = false;
|
||
}
|
||
|
||
BOOL CGeometryStyle::Read()
|
||
{
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL CGeometryStyle::SetPath(const std::string& strPath, const std::string& strAdj, const std::string& strFormulas)
|
||
{
|
||
return m_oShapePath.Build (strPath, strAdj, strFormulas);
|
||
}
|
||
|
||
BOOL CGeometryStyle::SetRightBottom(const std::string& strCoordSize)
|
||
{
|
||
DOCX::CFPoint oFPoint (strCoordSize, 21600, 21600);
|
||
|
||
m_nGeoRight = (int)oFPoint.X();
|
||
m_nGeoBottom = (int)oFPoint.Y();
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL CGeometryStyle::SetConnection(const std::string& strType)
|
||
{
|
||
if (std::string("custom") == strType)
|
||
m_nCxk = Enumerations::msocxkCustom;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL CGeometryStyle::SetSites(const std::string& strSites)
|
||
{
|
||
m_oConnectionSites.Add (CMSOArray<CPoint32>::GetPoints(strSites));
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL CGeometryStyle::SetSitesDir(const std::string& strSitesDir)
|
||
{
|
||
m_oConnectionSitesDir.Add(CMSOArray<unsigned int>::GetValues(strSitesDir));
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL CGeometryStyle::SetAdjustValues(const std::string& strAdjust, bool bAdjustArc)
|
||
{
|
||
m_arAdjustValues.clear();
|
||
|
||
if (bAdjustArc)
|
||
{
|
||
m_bAdjustArc = true;
|
||
m_arAdjustValues.push_back(DOCXDOCUTILS::GetArcValue(strAdjust));
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
m_arAdjustValues = DOCXDOCUTILS::GetValues (strAdjust);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL CGeometryStyle::SetInscribe(const std::string& inscribe)
|
||
{
|
||
m_pInscribe.Add(CMSOArray<OfficeArt::RECT>::GetRectangles(inscribe));
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL CGeometryStyle::Append(OfficeArtRGFOPTE& oTable)
|
||
{
|
||
if (m_oShapePath.IsValid())
|
||
{
|
||
AppendEntry (Enumerations::geoTop, m_nGeoTop);
|
||
AppendEntry (Enumerations::geoLeft, m_nGeoLeft);
|
||
AppendEntry (Enumerations::geoRight, m_nGeoRight);
|
||
AppendEntry (Enumerations::geoBottom, m_nGeoBottom);
|
||
|
||
AppendEntry (Enumerations::shapePath, 1);
|
||
|
||
AppenComplexEntry (Enumerations::pVertices, true, m_oShapePath.GetPoints());
|
||
AppenComplexEntry (Enumerations::pSegmentInfo, true, m_oShapePath.GetSegments());
|
||
|
||
if (m_pInscribe.GetSize())
|
||
{
|
||
AppenComplexEntry (Enumerations::pInscribe, true, m_pInscribe);
|
||
}
|
||
|
||
if (Enumerations::msocxkCustom == m_nCxk)
|
||
{
|
||
//AppenComplexEntry (Enumerations::pAdjustHandles, true, m_oAdjustHandles);
|
||
//AppenComplexEntry (Enumerations::pGuides, true, m_oGuides);
|
||
|
||
//AppenComplexEntry (Enumerations::pConnectionSites, true, m_oConnectionSites);
|
||
//AppenComplexEntry (Enumerations::pConnectionSitesDir, true, m_oConnectionSitesDir);
|
||
|
||
//AppendEntry (Enumerations::cxk, m_nCxk);
|
||
}
|
||
}
|
||
|
||
if (m_bAdjustArc)
|
||
{
|
||
if (m_arAdjustValues.size())
|
||
{
|
||
AppendEntry (Enumerations::adjustValue, m_arAdjustValues[0]);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (m_arAdjustValues.size())
|
||
{
|
||
for (size_t i = 0; i < m_arAdjustValues.size(); ++i)
|
||
{
|
||
if (m_arAdjustValues[i])
|
||
AppendEntry (Enumerations::adjustValue + i, m_arAdjustValues[i]);
|
||
}
|
||
}
|
||
}
|
||
|
||
AppendEntry (Enumerations::geometryBooleanProperties, m_oGeometryBooleans.Get());
|
||
|
||
if (m_arTable.size())
|
||
{
|
||
for (size_t i = 0; i < m_arTable.size(); ++i)
|
||
oTable.PushComplexProperty(m_arTable[i]);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
namespace AVSDocFileFormat
|
||
{
|
||
CFillStyle::CFillStyle ()
|
||
{
|
||
m_nType = 0;
|
||
m_nColor = 0x00FFFFFF;
|
||
m_nOpacity = 0x00010000;
|
||
m_nBlip = 0;
|
||
}
|
||
|
||
BOOL CFillStyle::Read (const OOX::Logic::FillStyle& oXml)
|
||
{
|
||
m_arTable.clear();
|
||
m_arTable2.clear();
|
||
|
||
if (oXml.fillcolor.is_init())
|
||
{
|
||
DOCX::CSColor color;
|
||
if (color.Init(oXml.fillcolor))
|
||
{
|
||
m_nColor = color.Color();
|
||
}
|
||
}
|
||
|
||
if (oXml.opacity.is_init())
|
||
{
|
||
m_nOpacity = DOCXDOCUTILS::GetFixePointValue(oXml.opacity);
|
||
}
|
||
|
||
if (oXml.filled.is_init())
|
||
{
|
||
if (std::string ("f") == oXml.filled)
|
||
{
|
||
m_oFillBooleans.fFilled = false;
|
||
m_oFillBooleans.fUsefFilled = true;
|
||
}
|
||
}
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> ( <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ID )
|
||
|
||
if (0 != m_nType)
|
||
AppendEntry(Enumerations::fillType, m_nType);
|
||
|
||
if (0x00FFFFFF != m_nColor)
|
||
AppendEntry(Enumerations::fillColor, m_nColor);
|
||
|
||
if (0x10000 != m_nOpacity)
|
||
AppendEntry(Enumerations::fillOpacity, m_nOpacity);
|
||
|
||
if (0 != m_nBlip)
|
||
AppendEntry(Enumerations::fillBlip, m_nBlip, true, false);
|
||
|
||
AppendEntry2(Enumerations::fillStyleBooleanProperties, 0x00600000);//m_oFillBooleans.Get());
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL CFillStyle::SetType(int nType)
|
||
{
|
||
m_nType = nType;
|
||
|
||
return Rebuild();
|
||
}
|
||
|
||
BOOL CFillStyle::SetBlip(int nBlip)
|
||
{
|
||
m_nBlip = nBlip;
|
||
|
||
return Rebuild();
|
||
}
|
||
|
||
BOOL CFillStyle::SetUseShapeAnchor(bool value)
|
||
{
|
||
m_oFillBooleans.fUsefUseShapeAnchor = value;
|
||
|
||
return Rebuild();
|
||
}
|
||
|
||
BOOL CFillStyle::Append (OfficeArtRGFOPTE& oTable)
|
||
{
|
||
if (m_arTable.size())
|
||
{
|
||
for (size_t i = 0; i < m_arTable.size(); ++i)
|
||
oTable.PushComplexProperty(m_arTable[i]);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL CFillStyle::Append2(OfficeArtRGFOPTE& oTable)
|
||
{
|
||
if (m_arTable2.size())
|
||
{
|
||
for (size_t i = 0; i < m_arTable2.size(); ++i)
|
||
oTable.PushComplexProperty(m_arTable2[i]);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL CFillStyle::Rebuild()
|
||
{
|
||
m_arTable.clear();
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> ( <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ID )
|
||
|
||
if (0 != m_nType)
|
||
AppendEntry (Enumerations::fillType, m_nType);
|
||
|
||
if (0x00FFFFFF != m_nColor)
|
||
AppendEntry (Enumerations::fillColor, m_nColor);
|
||
|
||
if (0x10000 != m_nOpacity)
|
||
AppendEntry (Enumerations::fillOpacity, m_nOpacity);
|
||
|
||
if (0 != m_nBlip)
|
||
AppendEntry (Enumerations::fillBlip, m_nBlip, true, false);
|
||
|
||
AppendEntry (Enumerations::fillStyleBooleanProperties, m_oFillBooleans.Get());
|
||
|
||
return TRUE;
|
||
}
|
||
}
|
||
|
||
namespace AVSDocFileFormat
|
||
{
|
||
CLineStyle::CLineStyle ()
|
||
{
|
||
m_nColor = 0x00000000;
|
||
m_nOpacity = 0x00010000;
|
||
m_nType = 0;
|
||
m_nWidth = 0x00002535;
|
||
m_nStyle = 0;
|
||
m_nDashing = 0;
|
||
m_nStartArrow = Enumerations::msolineNoEnd;
|
||
m_nEndArrow = Enumerations::msolineNoEnd;
|
||
m_nStartArrowWidth = Enumerations::msolineMediumWidthArrow;
|
||
m_nStartArrowLength = Enumerations::msolineMediumLenArrow;
|
||
m_nEndArrowWidth = Enumerations::msolineMediumWidthArrow;
|
||
m_nEndArrowLength = Enumerations::msolineMediumLenArrow;
|
||
m_nEndCapStyle = Enumerations::msolineEndCapFlat;
|
||
}
|
||
|
||
BOOL CLineStyle::Read (const OOX::Logic::LineStyle& oXml)
|
||
{
|
||
m_arTable.clear();
|
||
|
||
if (oXml.strokeColor.is_init())
|
||
{
|
||
DOCX::CSColor color;
|
||
if (color.Init(oXml.strokeColor))
|
||
{
|
||
m_nColor = color.Color();
|
||
}
|
||
}
|
||
|
||
if (oXml.opacity.is_init())
|
||
{
|
||
m_nOpacity = DOCXDOCUTILS::GetFixePointValue (oXml.opacity);
|
||
}
|
||
|
||
if (oXml.lineStyle.is_init())
|
||
{
|
||
m_nStyle = GetLineStyle(oXml.lineStyle);
|
||
}
|
||
|
||
if (oXml.endcap.is_init())
|
||
{
|
||
m_nEndCapStyle = GetEndCapStyle(oXml.endcap);
|
||
}
|
||
|
||
if (oXml.startarrow.is_init())
|
||
{
|
||
m_nStartArrow = GetLineArrowHead(oXml.startarrow);
|
||
}
|
||
|
||
if (oXml.endarrow.is_init())
|
||
{
|
||
m_nEndArrow = GetLineArrowHead(oXml.endarrow);
|
||
}
|
||
|
||
if (oXml.startarrowwidth.is_init())
|
||
{
|
||
m_nStartArrowWidth = GetLineArrowWidth(oXml.startarrowwidth);
|
||
}
|
||
|
||
if (oXml.startarrowlength.is_init())
|
||
{
|
||
m_nStartArrowLength = GetLineArrowLength(oXml.startarrowlength);
|
||
}
|
||
|
||
if (oXml.endarrowwidth.is_init())
|
||
{
|
||
m_nEndArrowWidth = GetLineArrowWidth(oXml.endarrowwidth);
|
||
}
|
||
|
||
if (oXml.endarrowlength.is_init())
|
||
{
|
||
m_nEndArrowLength = GetLineArrowLength(oXml.endarrowlength);
|
||
}
|
||
|
||
if (oXml.dashStyle.is_init())
|
||
{
|
||
m_nDashing = GetLineDash(oXml.dashStyle);
|
||
if (-1 == m_nDashing)
|
||
{
|
||
m_nDashing = 0;
|
||
|
||
// TODO : need add CUSTOM dash pen
|
||
}
|
||
|
||
m_oLineBooleans.fNoLineDrawDash = true;
|
||
m_oLineBooleans.fUsefNoLineDrawDash = true;
|
||
}
|
||
|
||
if (oXml.strokeWeight.is_init())
|
||
{
|
||
DOCX::CEmu oEmu (oXml.strokeWeight);
|
||
m_nWidth = oEmu.Get();
|
||
}
|
||
|
||
if (oXml.stroked.is_init())
|
||
{
|
||
if (std::string ("f") == oXml.stroked)
|
||
{
|
||
m_oLineBooleans.fLine = false;
|
||
m_oLineBooleans.fUsefLine = true;
|
||
}
|
||
}
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> ( <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ID )
|
||
|
||
AppendEntry (Enumerations::lineColor, m_nColor);
|
||
|
||
if (0x10000 != m_nOpacity)
|
||
AppendEntry (Enumerations::lineOpacity, m_nOpacity);
|
||
|
||
if (0 != m_nType)
|
||
AppendEntry (Enumerations::lineType, m_nType);
|
||
|
||
AppendEntry (Enumerations::lineWidth, m_nWidth);
|
||
|
||
if (0 != m_nStyle)
|
||
AppendEntry (Enumerations::lineStyle, m_nStyle);
|
||
|
||
if (0 != m_nDashing)
|
||
AppendEntry (Enumerations::lineDashing, m_nDashing);
|
||
|
||
if (Enumerations::msolineNoEnd != m_nStartArrow)
|
||
AppendEntry (Enumerations::lineStartArrowhead, m_nStartArrow);
|
||
|
||
if (Enumerations::msolineNoEnd != m_nEndArrow)
|
||
AppendEntry (Enumerations::lineEndArrowhead, m_nEndArrow);
|
||
|
||
if (Enumerations::msolineMediumWidthArrow != m_nStartArrowWidth)
|
||
AppendEntry (Enumerations::lineStartArrowWidth, m_nStartArrowWidth);
|
||
|
||
if (Enumerations::msolineMediumLenArrow != m_nStartArrowLength)
|
||
AppendEntry (Enumerations::lineStartArrowLength, m_nStartArrowLength);
|
||
|
||
if (Enumerations::msolineMediumWidthArrow != m_nEndArrowWidth)
|
||
AppendEntry (Enumerations::lineEndArrowWidth, m_nEndArrowWidth);
|
||
|
||
if (Enumerations::msolineMediumLenArrow != m_nEndArrowLength)
|
||
AppendEntry (Enumerations::lineEndArrowLength, m_nEndArrowLength);
|
||
|
||
if (Enumerations::msolineEndCapFlat != m_nEndCapStyle)
|
||
AppendEntry (Enumerations::lineEndCapStyle, m_nEndCapStyle);
|
||
|
||
if (0 != m_oLineBooleans.Get())
|
||
AppendEntry (Enumerations::lineStyleBooleanProperties, m_oLineBooleans.Get());
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL CLineStyle::Append (OfficeArtRGFOPTE& oTable)
|
||
{
|
||
if (m_arTable.size())
|
||
{
|
||
for (size_t i = 0; i < m_arTable.size(); ++i)
|
||
oTable.PushComplexProperty(m_arTable[i]);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
// READ
|
||
int CLineStyle::GetLineStyle (const std::string& lineType)
|
||
{
|
||
std::string type = lineType;
|
||
std::transform(type.begin(), type.end(), type.begin(), ::tolower);
|
||
|
||
if (type == std::string("single"))
|
||
return OfficeArt::Enumerations::msolineSimple;
|
||
|
||
if (type == std::string("thickbetweenthin"))
|
||
return OfficeArt::Enumerations::msolineTriple;
|
||
|
||
if (type == std::string("thickthin"))
|
||
return OfficeArt::Enumerations::msolineThickThin;
|
||
|
||
if (type == std::string("thinthick"))
|
||
return OfficeArt::Enumerations::msolineThinThick;
|
||
|
||
if (type == std::string("thinthin"))
|
||
return OfficeArt::Enumerations::msolineDouble;
|
||
|
||
return OfficeArt::Enumerations::msolineSimple;
|
||
}
|
||
|
||
int CLineStyle::GetLineDash (const std::string& dashType)
|
||
{
|
||
std::string type = dashType;
|
||
std::transform(type.begin(), type.end(), type.begin(), ::tolower);
|
||
|
||
if (type == std::string("solid"))
|
||
return OfficeArt::Enumerations::msolineSolid;
|
||
if (type == std::string("shortdash"))
|
||
return OfficeArt::Enumerations::msolineDashSys;
|
||
if (type == std::string("shortdot"))
|
||
return OfficeArt::Enumerations::msolineDotSys;
|
||
if (type == std::string("shortdashdot"))
|
||
return OfficeArt::Enumerations::msolineDashDotSys;
|
||
if (type == std::string("shortdashdotdot"))
|
||
return OfficeArt::Enumerations::msolineDashDotDotSys;
|
||
if (type == std::string("dot"))
|
||
return OfficeArt::Enumerations::msolineDotGEL;
|
||
if (type == std::string("dash"))
|
||
return OfficeArt::Enumerations::msolineDashGEL;
|
||
if (type == std::string("dashdot"))
|
||
return OfficeArt::Enumerations::msolineDashDotGEL;
|
||
if (type == std::string("longdash"))
|
||
return OfficeArt::Enumerations::msolineLongDashGEL;
|
||
if (type == std::string("longdashdot"))
|
||
return OfficeArt::Enumerations::msolineLongDashDotGEL;
|
||
if (type == std::string("longdashdotdot"))
|
||
return OfficeArt::Enumerations::msolineLongDashDotDotGEL;
|
||
if (type == std::string("1 1"))
|
||
return OfficeArt::Enumerations::msolineDotSys;
|
||
if (type == std::string("3 1"))
|
||
return OfficeArt::Enumerations::msolineDashSys;
|
||
|
||
return OfficeArt::Enumerations::msolineSolid; // CUSTOM
|
||
}
|
||
|
||
int CLineStyle::GetEndCapStyle (const std::string& capStyle)
|
||
{
|
||
std::string type = capStyle;
|
||
std::transform(type.begin(), type.end(), type.begin(), ::tolower);
|
||
|
||
if (type == std::string("round"))
|
||
return OfficeArt::Enumerations::msolineEndCapRound;
|
||
if (type == std::string("square"))
|
||
return OfficeArt::Enumerations::msolineEndCapSquare;
|
||
|
||
return OfficeArt::Enumerations::msolineEndCapFlat;
|
||
}
|
||
|
||
int CLineStyle::GetLineArrowHead (const std::string& strStyle)
|
||
{
|
||
std::string type = strStyle;
|
||
std::transform(type.begin(), type.end(), type.begin(), ::tolower);
|
||
|
||
if (type == std::string("none"))
|
||
return OfficeArt::Enumerations::msolineNoEnd;
|
||
if (type == std::string("diamond"))
|
||
return OfficeArt::Enumerations::msolineArrowDiamondEnd;
|
||
if (type == std::string("open"))
|
||
return OfficeArt::Enumerations::msolineArrowOpenEnd;
|
||
if (type == std::string("oval"))
|
||
return OfficeArt::Enumerations::msolineArrowOvalEnd;
|
||
if (type == std::string("block"))
|
||
return OfficeArt::Enumerations::msolineArrowEnd;
|
||
if (type == std::string("classic"))
|
||
return OfficeArt::Enumerations::msolineArrowStealthEnd;
|
||
|
||
return OfficeArt::Enumerations::msolineNoEnd;
|
||
}
|
||
|
||
int CLineStyle::GetLineArrowWidth (const std::string& strStyle)
|
||
{
|
||
std::string type = strStyle;
|
||
std::transform(type.begin(), type.end(), type.begin(), ::tolower);
|
||
|
||
if (type == std::string("narrow"))
|
||
return OfficeArt::Enumerations::msolineNarrowArrow;
|
||
if (type == std::string("medium"))
|
||
return OfficeArt::Enumerations::msolineMediumWidthArrow;
|
||
if (type == std::string("wide"))
|
||
return OfficeArt::Enumerations::msolineWideArrow;
|
||
|
||
return OfficeArt::Enumerations::msolineMediumWidthArrow;
|
||
}
|
||
|
||
int CLineStyle::GetLineArrowLength (const std::string& strStyle)
|
||
{
|
||
std::string type = strStyle;
|
||
std::transform(type.begin(), type.end(), type.begin(), ::tolower);
|
||
|
||
if (type == std::string("long"))
|
||
return OfficeArt::Enumerations::msolineLongArrow;
|
||
if (type == std::string("medium"))
|
||
return OfficeArt::Enumerations::msolineMediumLenArrow;
|
||
if (type == std::string("short"))
|
||
return OfficeArt::Enumerations::msolineShortArrow;
|
||
|
||
return OfficeArt::Enumerations::msolineMediumLenArrow;
|
||
}
|
||
}
|
||
|
||
namespace AVSDocFileFormat
|
||
{
|
||
CShadowStyle::CShadowStyle ()
|
||
{
|
||
m_bOK = false;
|
||
m_nType = 2; // OfficeArt::Enumerations::msoshadowRich
|
||
}
|
||
|
||
BOOL CShadowStyle::Read (const OOX::Logic::Shadow& oXml)
|
||
{
|
||
m_arTable.clear();
|
||
|
||
m_bOK = false;
|
||
|
||
if (!oXml.On.is_init())
|
||
return FALSE;
|
||
|
||
if (std::string("t") != oXml.On)
|
||
return FALSE;
|
||
|
||
m_bOK = true;
|
||
|
||
if (oXml.Type.is_init())
|
||
{
|
||
AppendEntry (Enumerations::shadowType, m_nType);
|
||
}
|
||
|
||
if (oXml.Color.is_init())
|
||
{
|
||
DOCX::CSColor dcColor;
|
||
if (dcColor.Init(oXml.Color))
|
||
{
|
||
m_nColor = dcColor.Color();
|
||
|
||
AppendEntry (Enumerations::shadowColor, m_nColor);
|
||
}
|
||
}
|
||
|
||
if (oXml.Opacity.is_init())
|
||
{
|
||
m_nOpacity = DOCXDOCUTILS::GetFixePointValue (oXml.Opacity);
|
||
|
||
AppendEntry (Enumerations::shadowOpacity, m_nOpacity);
|
||
}
|
||
|
||
if (oXml.Offset.is_init())
|
||
{
|
||
m_oOffset = DOCX::CPointF (oXml.Offset);
|
||
|
||
AppendEntry (Enumerations::shadowOffsetX, m_oOffset.X());
|
||
AppendEntry (Enumerations::shadowOffsetY, m_oOffset.Y());
|
||
}
|
||
|
||
if (oXml.Matrix.is_init()) // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
{
|
||
m_oTransform = DOCX::CMatrixF (oXml.Matrix);
|
||
|
||
if (0.0 != m_oTransform.XToX())
|
||
AppendEntry (Enumerations::shadowScaleXToX, m_oTransform.XToX());
|
||
if (0.0 != m_oTransform.XToY())
|
||
AppendEntry (Enumerations::shadowScaleXToY, m_oTransform.XToY());
|
||
if (0.0 != m_oTransform.YToX())
|
||
AppendEntry (Enumerations::shadowScaleYToX, m_oTransform.YToX());
|
||
if (0.0 != m_oTransform.YToY())
|
||
AppendEntry (Enumerations::shadowScaleYToY, m_oTransform.YToY());
|
||
if (0.0 != m_oTransform.PX())
|
||
AppendEntry (Enumerations::shadowPerspectiveX, m_oTransform.PX());
|
||
if (0.0 != m_oTransform.PY())
|
||
AppendEntry (Enumerations::shadowPerspectiveY, m_oTransform.PY());
|
||
}
|
||
|
||
if (oXml.Origin.is_init())
|
||
{
|
||
m_oOrigin = DOCX::CPointF (oXml.Origin);
|
||
|
||
if (0.0 != m_oOrigin.X())
|
||
AppendEntry (Enumerations::shadowOriginX, m_oOrigin.X());
|
||
if (0.0 != m_oOrigin.Y())
|
||
AppendEntry (Enumerations::shadowOriginY, m_oOrigin.Y());
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL CShadowStyle::Append (OfficeArtRGFOPTE& oTable, bool bFilled)
|
||
{
|
||
if (m_bOK)
|
||
{
|
||
m_oShadowBooleans.fUsefShadow = true;
|
||
m_oShadowBooleans.fShadow = true;
|
||
|
||
m_oShadowBooleans.fUsefShadowObscured = bFilled;
|
||
m_oShadowBooleans.fShadowObscured = bFilled;
|
||
|
||
AppendEntry (Enumerations::shadowStyleBooleanProperties, m_oShadowBooleans.Get());
|
||
|
||
for (size_t i = 0; i < m_arTable.size(); ++i)
|
||
oTable.PushComplexProperty(m_arTable[i]);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
namespace AVSDocFileFormat
|
||
{
|
||
CTransformStyle::CTransformStyle ()
|
||
{
|
||
m_bAngleBoundFlip = FALSE;
|
||
m_nRotate = 0;
|
||
}
|
||
|
||
BOOL CTransformStyle::SetRotate (const std::string& strRotate, bool bPicture)
|
||
{
|
||
if (strRotate.length())
|
||
{
|
||
double dAngle = 0.0;
|
||
|
||
if (bPicture)
|
||
{
|
||
if (strRotate.length())
|
||
dAngle = atof(strRotate.c_str()) / 60000.0;
|
||
}
|
||
else
|
||
{
|
||
dAngle = DOCXDOCUTILS::GetAngleValue(strRotate);
|
||
}
|
||
|
||
if (dAngle < -360.0)
|
||
dAngle += 360.0;
|
||
|
||
if ((dAngle >= 45.0 && dAngle <= 135.0) || (dAngle >= 225.0 && dAngle <= 315.0) ||
|
||
(dAngle <= -45.0 && dAngle >= -135.0) || (dAngle <= -225.0 && dAngle >= -315.0))
|
||
{
|
||
m_bAngleBoundFlip = TRUE;
|
||
}
|
||
|
||
m_nRotate = (unsigned int)(dAngle * 65536.0);
|
||
|
||
if (m_nRotate)
|
||
{
|
||
AppendEntry (Enumerations::rotation, m_nRotate);
|
||
|
||
return TRUE;
|
||
}
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL CTransformStyle::Append (OfficeArtRGFOPTE& oTable)
|
||
{
|
||
if (m_arTable.size())
|
||
{
|
||
for (size_t i = 0; i < m_arTable.size(); ++i)
|
||
oTable.PushComplexProperty(m_arTable[i]);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
namespace AVSDocFileFormat
|
||
{
|
||
CTextStyle::CTextStyle ()
|
||
{
|
||
m_nLTxID = 0;
|
||
|
||
m_nWrapMode = Enumerations::msowrapSquare;
|
||
m_nAnchorText = Enumerations::msoanchorTop;
|
||
}
|
||
|
||
BOOL CTextStyle::SetAnchor (const std::string& textAnchor)
|
||
{
|
||
m_nAnchorText = Enumerations::msoanchorTop;
|
||
|
||
std::string type = textAnchor;
|
||
std::transform(type.begin(), type.end(), type.begin(), ::tolower);
|
||
|
||
if (type == std::string("top"))
|
||
m_nAnchorText = Enumerations::msoanchorTop;
|
||
else if (type == std::string("middle"))
|
||
m_nAnchorText = Enumerations::msoanchorMiddle;
|
||
else if (type == std::string("bottom"))
|
||
m_nAnchorText = Enumerations::msoanchorBottom;
|
||
else if (type == std::string("top-center"))
|
||
m_nAnchorText = Enumerations::msoanchorTopCentered;
|
||
else if (type == std::string("middle-center"))
|
||
m_nAnchorText = Enumerations::msoanchorMiddleCentered;
|
||
else if (type == std::string("bottom-center"))
|
||
m_nAnchorText = Enumerations::msoanchorBottomCentered;
|
||
else if (type == std::string("top-baseline"))
|
||
m_nAnchorText = Enumerations::msoanchorTopBaseline;
|
||
else if (type == std::string("bottom-baseline"))
|
||
m_nAnchorText = Enumerations::msoanchorBottomBaseline;
|
||
else if (type == std::string("top-center-baseline"))
|
||
m_nAnchorText = Enumerations::msoanchorTopCenteredBaseline;
|
||
else if (type == std::string("bottom-center-baseline"))
|
||
m_nAnchorText = Enumerations::msoanchorBottomCenteredBaseline;
|
||
else
|
||
m_nAnchorText = Enumerations::msoanchorTop;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL CTextStyle::Append (OfficeArtRGFOPTE& oTable)
|
||
{
|
||
if (m_nLTxID)
|
||
AppendEntry (Enumerations::lTxid, m_nLTxID);
|
||
|
||
if (Enumerations::msowrapSquare != m_nWrapMode)
|
||
AppendEntry (Enumerations::anchorText, m_nWrapMode);
|
||
|
||
if (Enumerations::msoanchorTop != m_nAnchorText)
|
||
AppendEntry (Enumerations::anchorText, m_nAnchorText);
|
||
|
||
if (m_arTable.size())
|
||
{
|
||
AppendEntry (Enumerations::textBooleanProperties, m_oTextBooleans.Get());
|
||
|
||
for (size_t i = 0; i < m_arTable.size(); ++i)
|
||
oTable.PushComplexProperty(m_arTable[i]);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
namespace AVSDocFileFormat
|
||
{
|
||
CBlipStyle::CBlipStyle ()
|
||
{
|
||
m_nPib = 0;
|
||
}
|
||
|
||
BOOL CBlipStyle::SetPib (int nPib)
|
||
{
|
||
m_nPib = nPib;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL CBlipStyle::Append (OfficeArtRGFOPTE& oTable)
|
||
{
|
||
AppendEntry (Enumerations::pib, m_nPib, true, false);
|
||
AppendEntry (Enumerations::blipBooleanProperties, m_oBlipBooleans.Get());
|
||
|
||
for (size_t i = 0; i < m_arTable.size(); ++i)
|
||
oTable.PushComplexProperty(m_arTable[i]);
|
||
|
||
return TRUE;
|
||
}
|
||
}
|
||
|
||
namespace AVSDocFileFormat
|
||
{
|
||
CShapeSettings::CShapeSettings ()
|
||
{
|
||
m_nDXWrapDistLeft = 0x0001BE7C;
|
||
m_nDYWrapDistTop = 0x00000000;
|
||
m_nDXWrapDistRight = 0x0001BE7C;
|
||
m_nDYWrapDistBottom = 0x00000000;
|
||
}
|
||
//
|
||
void CShapeSettings::SetUseBehind (bool bUse)
|
||
{
|
||
m_oGroupShapeStyle.SetUseBehind (bUse);
|
||
}
|
||
|
||
//
|
||
void CShapeSettings::SetUseBehind (const OOX::Logic::ShapeStyle& refStyle) // <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
{
|
||
if (refStyle.ZIndex.is_init())
|
||
{
|
||
double fStatus = atof(refStyle.ZIndex->c_str());
|
||
if (fStatus < 0.0)
|
||
{
|
||
m_oGroupShapeStyle.SetUseBehind (true);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
void CShapeSettings::SetWrapDist (const OOX::Logic::ShapeStyle& refStyle)
|
||
{
|
||
if (refStyle.distanceLeftTop.is_init())
|
||
{
|
||
Unit<double, Dx> nLeft = *refStyle.distanceLeftTop->X;
|
||
m_nDXWrapDistLeft = (int) ( (double)nLeft * 635.0 );
|
||
|
||
Unit<double, Dx> nTop = *refStyle.distanceLeftTop->Y;
|
||
m_nDYWrapDistTop = (int) ( (double)nTop * 635.0 );
|
||
}
|
||
|
||
if (refStyle.distanceRightBottom.is_init())
|
||
{
|
||
Unit<double, Dx> nRight = *refStyle.distanceRightBottom->X;
|
||
m_nDXWrapDistRight = (int) ( (double)nRight * 635.0 );
|
||
|
||
Unit<double, Dx> nBottom = *refStyle.distanceRightBottom->Y;
|
||
m_nDYWrapDistBottom = (int) ( (double)nBottom * 635.0 );
|
||
}
|
||
}
|
||
|
||
//
|
||
void CShapeSettings::AddEntry (int nID, int nValue, bool bBid, bool bComplex)
|
||
{
|
||
OfficeArt::OfficeArtFOPTEOPID id (nID, bBid, bComplex);
|
||
OfficeArt::OfficeArtFOPTE oStyle (id, nValue);
|
||
|
||
m_oPrimary.PushComplexProperty(OfficeArt::ComplexOfficeArtProperty(oStyle));
|
||
}
|
||
|
||
BOOL CShapeSettings::SetupSecondaryOptions()
|
||
{
|
||
if (m_oFill.Append2(m_oSecondary) && m_oGroupShapeStyle.Append(m_oSecondary))
|
||
return TRUE;
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
OfficeArt::OfficeArtFOPT CShapeSettings::GetPrimaryOptions()
|
||
{
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
m_oText.Append(m_oPrimary);
|
||
m_oTransform.Append(m_oPrimary);
|
||
m_oGeometry.Append(m_oPrimary);
|
||
m_oFill.Append(m_oPrimary);
|
||
m_oLine.Append(m_oPrimary);
|
||
m_oShadow.Append(m_oPrimary, m_oFill.GetFill().fFilled);
|
||
|
||
// GROUP
|
||
|
||
if ((m_nDXWrapDistLeft != 0x0001BE7C) || (m_nDYWrapDistTop > 0) || (m_nDXWrapDistRight != 0x0001BE7C) || (m_nDYWrapDistBottom > 0))
|
||
{
|
||
AddEntry(OfficeArt::Enumerations::dxWrapDistLeft, m_nDXWrapDistLeft);
|
||
AddEntry(OfficeArt::Enumerations::dyWrapDistTop, m_nDYWrapDistTop);
|
||
AddEntry(OfficeArt::Enumerations::dxWrapDistRight, m_nDXWrapDistRight);
|
||
AddEntry(OfficeArt::Enumerations::dyWrapDistBottom, m_nDYWrapDistBottom);
|
||
}
|
||
|
||
return OfficeArt::OfficeArtFOPT(m_oPrimary);
|
||
}
|
||
|
||
OfficeArt::OfficeArtSecondaryFOPT CShapeSettings::GetSecondaryOptions()
|
||
{
|
||
return OfficeArt::OfficeArtSecondaryFOPT(m_oSecondary);
|
||
}
|
||
|
||
void CShapeSettings::AddOptionalEntry (OfficeArtRGFOPTE& oTable, int nID, int nValue, bool bBid, bool bComplex)
|
||
{
|
||
OfficeArtFOPTEOPID id (nID, bBid, bComplex);
|
||
OfficeArtFOPTE oStyle (id, nValue);
|
||
|
||
oTable.PushComplexProperty(ComplexOfficeArtProperty(oStyle));
|
||
}
|
||
}
|
||
|
||
namespace AVSDocFileFormat
|
||
{
|
||
CImageSettings::CImageSettings () : CShapeSettings()
|
||
{
|
||
m_oFillStyleBooleans.fFilled = false;
|
||
m_oFillStyleBooleans.fUsefFilled = true;
|
||
|
||
m_oLineStyleBooleans.fLine = false;
|
||
m_oLineStyleBooleans.fUsefLine = true;
|
||
}
|
||
|
||
void CImageSettings::SetWrapDist (const OOX::Logic::Inline& oInline)
|
||
{
|
||
if (oInline.distanceLeftTop.is_init())
|
||
{
|
||
Unit<int, Dx> nLeft = *oInline.distanceLeftTop->X;
|
||
m_nDXWrapDistLeft = nLeft;
|
||
|
||
Unit<int, Dx> nTop = *oInline.distanceLeftTop->Y;
|
||
m_nDYWrapDistTop = nTop;
|
||
}
|
||
|
||
if (oInline.distanceRightBottom.is_init())
|
||
{
|
||
Unit<int, Dx> nRight = *oInline.distanceRightBottom->X;
|
||
m_nDXWrapDistRight = nRight;
|
||
|
||
Unit<int, Dx> nBottom = *oInline.distanceRightBottom->Y;
|
||
m_nDYWrapDistBottom = nBottom;
|
||
}
|
||
}
|
||
|
||
|
||
BOOL CImageSettings::SetupSecondaryOptions()
|
||
{
|
||
if (m_oGroupShapeStyle.Append(m_oSecondary))
|
||
return TRUE;
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
OfficeArt::OfficeArtFOPT CImageSettings::GetPrimaryOptions()
|
||
{
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
m_oTransform.Append(m_oPrimary);
|
||
m_oBlipStyle.Append(m_oPrimary);
|
||
m_oFill.Append(m_oPrimary);
|
||
m_oLine.Append(m_oPrimary);
|
||
|
||
// GROUP
|
||
|
||
if ( (m_nDXWrapDistLeft != 0x0001BE7C) || m_nDYWrapDistTop > 0 || (m_nDXWrapDistRight != 0x0001BE7C) || m_nDYWrapDistBottom > 0 )
|
||
{
|
||
AddEntry (OfficeArt::Enumerations::dxWrapDistLeft, m_nDXWrapDistLeft);
|
||
AddEntry (OfficeArt::Enumerations::dyWrapDistTop, m_nDYWrapDistTop);
|
||
AddEntry (OfficeArt::Enumerations::dxWrapDistRight, m_nDXWrapDistRight);
|
||
AddEntry (OfficeArt::Enumerations::dyWrapDistBottom, m_nDYWrapDistBottom);
|
||
}
|
||
|
||
m_oGroupShapeStyle.Append(m_oPrimary);
|
||
|
||
return OfficeArt::OfficeArtFOPT(m_oPrimary);
|
||
}
|
||
OfficeArt::OfficeArtSecondaryFOPT CImageSettings::GetSecondaryOptions()
|
||
{
|
||
return OfficeArt::OfficeArtSecondaryFOPT(m_oSecondary);
|
||
}
|
||
} |