pengjunjie/core
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/core.git synced 2026-07-11 13:03:11 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
3250a848ee4ef20c2fb8c38dc86350ec579124b8
core/OOXML/XlsxFormat/Styles/Borders.cpp
Alexander Trofimov 76ee07f61c [copyright] Update copyright header 
Co-authored-by: Alexander Trofimov <alexander.trofimov@onlyoffice.com>
Co-committed-by: Alexander Trofimov <alexander.trofimov@onlyoffice.com>
2026-05-14 08:23:56 +00:00

548 lines
18 KiB
C++
Raw Blame History

/*
* Copyright (C) Ascensio System SIA, 2009-2026
*
* This program is a free software product. You can redistribute it and/or
* modify it under the terms of the GNU Affero General Public License (AGPL)
* version 3 as published by the Free Software Foundation, together with the
* additional terms provided in the LICENSE file.
*
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
* details, see the GNU AGPL at: https://www.gnu.org/licenses/agpl-3.0.html
*
* You can contact Ascensio System SIA by email at info@onlyoffice.com
* or by postal mail at 20A-6 Ernesta Birznieka-Upisha Street, Riga,
* LV-1050, Latvia, European Union.
*
* The interactive user interfaces in modified versions of the Program
* are required to display Appropriate Legal Notices in accordance with
* Section 5 of the GNU AGPL version 3.
*
* No trademark rights are granted under this License.
*
* All non-code elements of the Product, including illustrations,
* icon sets, and technical writing content, are licensed under the
* Creative Commons Attribution-ShareAlike 4.0 International License:
* https://creativecommons.org/licenses/by-sa/4.0/legalcode
*
* This license applies only to such non-code elements and does not
* modify or replace the licensing terms applicable to the Program's
* source code, which remains licensed under the GNU Affero General
* Public License v3.
*
* SPDX-License-Identifier: AGPL-3.0-only
*/
#include "Borders.h"
#include "../../Common/SimpleTypes_Shared.h"
#include "../../Common/SimpleTypes_Spreadsheet.h"
#include "../../XlsbFormat/Biff12_records/Border.h"
#include "../../XlsbFormat/Biff12_records/BeginBorders.h"
#include "../../../MsBinaryFile/XlsFile/Format/Logic/Biff_structures/BiffStructure.h"
#include "../../XlsbFormat/Biff12_unions/BORDERS.h"
namespace OOX
{
namespace Spreadsheet
{
CBorderProp::CBorderProp()
{
}
CBorderProp::~CBorderProp()
{
}
void CBorderProp::fromXML(XmlUtils::CXmlNode& node)
{
}
std::wstring CBorderProp::toXML() const
{
return _T("");
}
void CBorderProp::toXML(NSStringUtils::CStringBuilder& writer) const
{
}
void CBorderProp::toXML2(NSStringUtils::CStringBuilder& writer, const std::wstring& sName) const
{
toXMLWithNS(writer, L"", sName, L"");
}
void CBorderProp::toXMLWithNS(NSStringUtils::CStringBuilder& writer, const std::wstring &node_ns, const std::wstring &node_name, const std::wstring &child_ns) const
{
writer.StartNodeWithNS(node_ns, node_name);
writer.StartAttributes();
WritingStringNullableAttrString(L"style", m_oStyle, m_oStyle->ToString());
writer.EndAttributes();
if(m_oColor.IsInit())
m_oColor->toXMLWithNS(writer, child_ns, L"color", child_ns);
writer.EndNodeWithNS(node_ns, node_name);
}
void CBorderProp::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( oReader.IsEmptyNode() )
return;
int nCurDepth = oReader.GetDepth();
while( oReader.ReadNextSiblingNode( nCurDepth ) )
{
std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
if ( L"color" == sName )
m_oColor = oReader;
}
}
EElementType CBorderProp::getType () const
{
return et_x_BorderProp;
}
void CBorderProp::fromBin(XLS::BiffStructure* obj)
{
auto ptr = static_cast<XLSB::Blxf*>(obj);
if(ptr != nullptr)
{
m_oColor.Init();
m_oColor->fromBin(dynamic_cast<XLS::BaseObject*>(&ptr->brtColor));
switch(ptr->dg)
{
case 0x00:
m_oStyle = SimpleTypes::Spreadsheet::EBorderStyle::borderstyleNone; break;
case 0x01:
m_oStyle = SimpleTypes::Spreadsheet::EBorderStyle::borderstyleThin; break;
case 0x02:
m_oStyle = SimpleTypes::Spreadsheet::EBorderStyle::borderstyleMedium; break;
case 0x03:
m_oStyle = SimpleTypes::Spreadsheet::EBorderStyle::borderstyleDashed; break;
case 0x04:
m_oStyle = SimpleTypes::Spreadsheet::EBorderStyle::borderstyleDotted; break;
case 0x05:
m_oStyle = SimpleTypes::Spreadsheet::EBorderStyle::borderstyleThick; break;
case 0x06:
m_oStyle = SimpleTypes::Spreadsheet::EBorderStyle::borderstyleDouble; break;
case 0x07:
m_oStyle = SimpleTypes::Spreadsheet::EBorderStyle::borderstyleHair; break;
case 0x08:
m_oStyle = SimpleTypes::Spreadsheet::EBorderStyle::borderstyleMediumDashed; break;
case 0x09:
m_oStyle = SimpleTypes::Spreadsheet::EBorderStyle::borderstyleDashDot; break;
case 0x0A:
m_oStyle = SimpleTypes::Spreadsheet::EBorderStyle::borderstyleMediumDashDot; break;
case 0x0B:
m_oStyle = SimpleTypes::Spreadsheet::EBorderStyle::borderstyleDashDotDot; break;
case 0x0C:
m_oStyle = SimpleTypes::Spreadsheet::EBorderStyle::borderstyleMediumDashDotDot; break;
case 0x0D:
m_oStyle = SimpleTypes::Spreadsheet::EBorderStyle::borderstyleSlantDashDot; break;
}
}
}
void CBorderProp::toBin(XLS::BiffStructure* obj)
{
auto ptr = static_cast<XLSB::Blxf*>(obj);
if(this == nullptr)
{
CColor color;
ptr->brtColor = color.GetDefaultColor();
ptr->dg = 0x00;
return;
}
if(m_oColor.IsInit())
ptr->brtColor = m_oColor->toColor();
else
{
ptr->brtColor = m_oColor->GetDefaultColor();
}
if(!m_oStyle.IsInit())
{
ptr->dg = 0x00;
return;
}
if (m_oStyle == SimpleTypes::Spreadsheet::EBorderStyle::borderstyleNone)
ptr->dg = 0x00;
else if (m_oStyle == SimpleTypes::Spreadsheet::EBorderStyle::borderstyleThin)
ptr->dg = 0x01;
else if (m_oStyle == SimpleTypes::Spreadsheet::EBorderStyle::borderstyleMedium)
ptr->dg = 0x02;
else if (m_oStyle == SimpleTypes::Spreadsheet::EBorderStyle::borderstyleDashed)
ptr->dg = 0x03;
else if (m_oStyle == SimpleTypes::Spreadsheet::EBorderStyle::borderstyleDotted)
ptr->dg = 0x04;
else if (m_oStyle == SimpleTypes::Spreadsheet::EBorderStyle::borderstyleThick)
ptr->dg = 0x05;
else if (m_oStyle == SimpleTypes::Spreadsheet::EBorderStyle::borderstyleDouble)
ptr->dg = 0x06;
else if (m_oStyle == SimpleTypes::Spreadsheet::EBorderStyle::borderstyleHair)
ptr->dg = 0x07;
else if (m_oStyle == SimpleTypes::Spreadsheet::EBorderStyle::borderstyleMediumDashed)
ptr->dg = 0x08;
else if (m_oStyle == SimpleTypes::Spreadsheet::EBorderStyle::borderstyleDashDot)
ptr->dg = 0x09;
else if (m_oStyle == SimpleTypes::Spreadsheet::EBorderStyle::borderstyleMediumDashDot)
ptr->dg = 0x0A;
else if (m_oStyle == SimpleTypes::Spreadsheet::EBorderStyle::borderstyleDashDotDot)
ptr->dg = 0x0B;
else if (m_oStyle == SimpleTypes::Spreadsheet::EBorderStyle::borderstyleMediumDashDotDot)
ptr->dg = 0x0C;
else if (m_oStyle == SimpleTypes::Spreadsheet::EBorderStyle::borderstyleSlantDashDot)
ptr->dg = 0x0D;
else
ptr->dg = 0x00;
}
bool CBorderProp::IsEmpty()
{
return !(m_oStyle.IsInit() || m_oColor.IsInit());
}
void CBorderProp::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
nullable_int iWeight;
nullable_string sColor, sLineStyle;
WritingElement_ReadAttributes_Start(oReader)
WritingElement_ReadAttributes_Read_if(oReader, L"style", m_oStyle)
WritingElement_ReadAttributes_Read_else_if(oReader, L"ss:Color", sColor)
WritingElement_ReadAttributes_Read_else_if(oReader, L"ss:LineStyle", sLineStyle)
WritingElement_ReadAttributes_Read_else_if(oReader, L"ss:Position", m_oType)
WritingElement_ReadAttributes_Read_else_if(oReader, L"ss:Weight", iWeight)
WritingElement_ReadAttributes_End(oReader)
if (sColor.IsInit())
{
m_oColor.Init(); m_oColor->m_oRgb.Init();
m_oColor->m_oRgb->FromString(*sColor);
}
if (sLineStyle.IsInit())
{
if (*sLineStyle == L"Dot")
m_oStyle.reset(new SimpleTypes::Spreadsheet::CBorderStyle(SimpleTypes::Spreadsheet::borderstyleDotted));
else if (*sLineStyle == L"Dash")
m_oStyle.reset(new SimpleTypes::Spreadsheet::CBorderStyle(SimpleTypes::Spreadsheet::borderstyleDashed));
else if (*sLineStyle == L"DashDot")
m_oStyle.reset(new SimpleTypes::Spreadsheet::CBorderStyle(SimpleTypes::Spreadsheet::borderstyleDashDot));
else if (*sLineStyle == L"DashDotDot")
m_oStyle.reset(new SimpleTypes::Spreadsheet::CBorderStyle(SimpleTypes::Spreadsheet::borderstyleDashDotDot));
else if (*sLineStyle == L"Double")
m_oStyle.reset(new SimpleTypes::Spreadsheet::CBorderStyle(SimpleTypes::Spreadsheet::borderstyleDouble));
else if (*sLineStyle == L"None")
m_oStyle.reset(new SimpleTypes::Spreadsheet::CBorderStyle(SimpleTypes::Spreadsheet::borderstyleNone));
else if (*sLineStyle == L"SlantDashDot")
m_oStyle.reset(new SimpleTypes::Spreadsheet::CBorderStyle(SimpleTypes::Spreadsheet::borderstyleSlantDashDot));
else if (*sLineStyle == L"Continuous")
{
if (iWeight.IsInit()) m_oStyle.reset();
else
m_oStyle.reset(new SimpleTypes::Spreadsheet::CBorderStyle(SimpleTypes::Spreadsheet::borderstyleHair));
bBorderContinuous = true;
}
}
if (iWeight.IsInit())
{
switch (*iWeight)
{
case 1: //Thin
{
if (false == m_oStyle.IsInit())
m_oStyle.reset(new SimpleTypes::Spreadsheet::CBorderStyle(SimpleTypes::Spreadsheet::borderstyleThin));
}break;
case 3: //Thick
{
if (false == m_oStyle.IsInit())
m_oStyle.reset(new SimpleTypes::Spreadsheet::CBorderStyle(SimpleTypes::Spreadsheet::borderstyleThick));
}break;
case 2:
default: //Medium
{
if (false == m_oStyle.IsInit())
m_oStyle.reset(new SimpleTypes::Spreadsheet::CBorderStyle(SimpleTypes::Spreadsheet::borderstyleMedium));
else
{
switch (m_oStyle->GetValue())
{
case SimpleTypes::Spreadsheet::borderstyleDashed: m_oStyle.reset(new SimpleTypes::Spreadsheet::CBorderStyle(SimpleTypes::Spreadsheet::borderstyleMediumDashed)); break;
case SimpleTypes::Spreadsheet::borderstyleDashDot: m_oStyle.reset(new SimpleTypes::Spreadsheet::CBorderStyle(SimpleTypes::Spreadsheet::borderstyleMediumDashDot)); break;
case SimpleTypes::Spreadsheet::borderstyleDashDotDot: m_oStyle.reset(new SimpleTypes::Spreadsheet::CBorderStyle(SimpleTypes::Spreadsheet::borderstyleMediumDashDotDot)); break;
}
}
}break;
}
}
}
CBorder::CBorder()
{
}
CBorder::~CBorder()
{
}
void CBorder::fromXML(XmlUtils::CXmlNode& node)
{
}
std::wstring CBorder::toXML() const
{
return _T("");
}
void CBorder::toXML(NSStringUtils::CStringBuilder& writer) const
{
toXMLWithNS(writer, L"", L"border", L"");
}
void CBorder::toXMLWithNS(NSStringUtils::CStringBuilder& writer, const std::wstring &node_ns, const std::wstring &node_name, const std::wstring &child_ns) const
{
writer.StartNodeWithNS(node_ns, node_name);
writer.StartAttributes();
if (m_oDiagonalDown.IsInit() && SimpleTypes::onoffTrue == m_oDiagonalDown->GetValue())
{
WritingStringAttrString(L"diagonalDown", m_oDiagonalDown->ToString3(SimpleTypes::onofftostring1));
}
if (m_oDiagonalUp.IsInit() && SimpleTypes::onoffTrue == m_oDiagonalUp->GetValue())
{
WritingStringAttrString(L"diagonalUp", m_oDiagonalUp->ToString3(SimpleTypes::onofftostring1));
}
writer.EndAttributes();
if(m_oStart.IsInit() && false == m_oStart->IsEmpty())
m_oStart->toXMLWithNS(writer, child_ns, _T("left"), child_ns);
else
writer.WriteString(_T("<left/>"));
if(m_oEnd.IsInit() && false == m_oEnd->IsEmpty())
m_oEnd->toXMLWithNS(writer, child_ns, _T("right"), child_ns);
else
writer.WriteString(_T("<right/>"));
if(m_oTop.IsInit() && false == m_oTop->IsEmpty())
m_oTop->toXMLWithNS(writer, child_ns, _T("top"), child_ns);
else
writer.WriteString(_T("<top/>"));
if(m_oBottom.IsInit() && false == m_oBottom->IsEmpty())
m_oBottom->toXMLWithNS(writer, child_ns, _T("bottom"), child_ns);
else
writer.WriteString(_T("<bottom/>"));
if(m_oDiagonal.IsInit() && false == m_oDiagonal->IsEmpty())
m_oDiagonal->toXMLWithNS(writer, child_ns, _T("diagonal"), child_ns);
else
writer.WriteString(_T("<diagonal/>"));
if(m_oVertical.IsInit() && false == m_oVertical->IsEmpty())
m_oVertical->toXMLWithNS(writer, child_ns, _T("vertical"), child_ns);
if(m_oHorizontal.IsInit() && false == m_oHorizontal->IsEmpty())
m_oHorizontal->toXMLWithNS(writer, child_ns, _T("horizontal"), child_ns);
writer.EndNodeWithNS(node_ns, node_name);
}
void CBorder::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( oReader.IsEmptyNode() )
return;
int nCurDepth = oReader.GetDepth();
while( oReader.ReadNextSiblingNode( nCurDepth ) )
{
std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
if ( _T("bottom") == sName )
m_oBottom = oReader;
else if ( _T("diagonal") == sName )
m_oDiagonal = oReader;
else if ( _T("end") == sName || _T("right") == sName )
m_oEnd = oReader;
else if ( _T("horizontal") == sName )
m_oHorizontal = oReader;
else if ( _T("start") == sName || _T("left") == sName )
m_oStart = oReader;
else if ( _T("top") == sName )
m_oTop = oReader;
else if ( L"vertical" == sName )
m_oVertical = oReader;
else if (L"Border" == sName)
{
CBorderProp* border = new CBorderProp();
*border = oReader;
if ((border) && (border->m_oType.IsInit()))
{
if (*border->m_oType == L"Bottom") m_oBottom = border;
else if (*border->m_oType == L"Top") m_oTop = border;
else if (*border->m_oType == L"Left") m_oStart = border;
else if (*border->m_oType == L"Right") m_oEnd = border;
else if (*border->m_oType == L"DiagonalLeft")
{
if (false == m_oDiagonal.IsInit())
{
m_oDiagonal = border;
}
m_oDiagonalUp = true;
}
else if (*border->m_oType == L"DiagonalRight")
{
if (false == m_oDiagonal.IsInit())
{
m_oDiagonal = border;
}
m_oDiagonalDown = true;
}
if (border->bBorderContinuous)
bBorderContinuous = true;
}
else
{
delete border;
}
}
}
}
void CBorder::fromBin(XLS::BaseObjectPtr& obj)
{
ReadAttributes(obj);
}
XLS::BaseObjectPtr CBorder::toBin()
{
auto ptr(new XLSB::Border);
XLS::BaseObjectPtr objectPtr(ptr);
m_oBottom->toBin(&ptr->blxfBottom);
m_oDiagonal->toBin(&ptr->blxfDiag);
m_oTop->toBin(&ptr->blxfTop);
m_oStart->toBin(&ptr->blxfLeft);
m_oEnd->toBin(&ptr->blxfRight);
if(m_oDiagonalDown.IsInit())
ptr->fBdrDiagDown = m_oDiagonalDown->GetValue();
else
ptr->fBdrDiagDown = false;
if(m_oDiagonalUp.IsInit())
ptr->fBdrDiagUp = m_oDiagonalUp->GetValue();
else
ptr->fBdrDiagUp = false;
return objectPtr;
}
EElementType CBorder::getType () const
{
return et_x_Border;
}
void CBorder::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
WritingElement_ReadAttributes_Start( oReader )
WritingElement_ReadAttributes_Read_if ( oReader, _T("diagonalDown"), m_oDiagonalDown )
WritingElement_ReadAttributes_Read_if ( oReader, _T("diagonalUp"), m_oDiagonalUp )
WritingElement_ReadAttributes_Read_if ( oReader, _T("outline"), m_oOutline )
WritingElement_ReadAttributes_End( oReader )
}
void CBorder::ReadAttributes(XLS::BaseObjectPtr& obj)
{
auto ptr = static_cast<XLSB::Border*>(obj.get());
if(ptr != nullptr)
{
m_oDiagonalDown = ptr->fBdrDiagDown;
m_oDiagonalUp = ptr->fBdrDiagUp;
m_oBottom.Init();
m_oBottom.GetPointer()->fromBin(dynamic_cast<XLS::BiffStructure*>(&ptr->blxfBottom));
m_oDiagonal.Init();
m_oDiagonal.GetPointer()->fromBin(dynamic_cast<XLS::BiffStructure*>(&ptr->blxfDiag));
m_oTop.Init();
m_oTop.GetPointer()->fromBin(dynamic_cast<XLS::BiffStructure*>(&ptr->blxfTop));
m_oStart.Init();
m_oStart.GetPointer()->fromBin(dynamic_cast<XLS::BiffStructure*>(&ptr->blxfLeft));
m_oEnd.Init();
m_oEnd.GetPointer()->fromBin(dynamic_cast<XLS::BiffStructure*>(&ptr->blxfRight));
}
}
CBorders::CBorders()
{
}
CBorders::~CBorders()
{
}
void CBorders::fromXML(XmlUtils::CXmlNode& node)
{
}
std::wstring CBorders::toXML() const
{
return L"";
}
void CBorders::toXML(NSStringUtils::CStringBuilder& writer) const
{
writer.WriteString(L"<borders");
WritingStringNullableAttrInt(L"count", m_oCount, m_oCount->GetValue());
writer.WriteString(L">");
for ( size_t i = 0; i < m_arrItems.size(); ++i)
{
if ( m_arrItems[i] )
{
m_arrItems[i]->toXML(writer);
}
}
writer.WriteString(L"</borders>");
}
void CBorders::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
if ( oReader.IsEmptyNode() )
return;
int index = 0;
int nCurDepth = oReader.GetDepth();
while( oReader.ReadNextSiblingNode( nCurDepth ) )
{
std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
if ( L"border" == sName || L"Border" == sName)
{
CBorder *pBorder = new CBorder();
*pBorder = oReader;
m_arrItems.push_back( pBorder );
m_mapBorders.insert(std::make_pair(index++, pBorder));
}
}
}
void CBorders::fromBin(std::vector<XLS::BaseObjectPtr>& obj)
{
ReadAttributes(obj);
int index = 0;
for(auto &border : obj)
{
CBorder *pBorder = new CBorder(border);
m_arrItems.push_back(pBorder);
m_mapBorders.insert(std::make_pair(index++, pBorder));
}
}
XLS::BaseObjectPtr CBorders::toBin()
{
auto ptr(new XLSB::BORDERS);
auto ptr1(new XLSB::BeginBorders);
ptr->m_BrtBeginBorders = XLS::BaseObjectPtr{ptr1};
XLS::BaseObjectPtr objectPtr(ptr);
for(auto i:m_arrItems)
ptr->m_arBrtBorder.push_back(i->toBin());
ptr1->cborders = ptr->m_arBrtBorder.size();
return objectPtr;
}
EElementType CBorders::getType () const
{
return et_x_Borders;
}
void CBorders::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
WritingElement_ReadAttributes_Start( oReader )
WritingElement_ReadAttributes_Read_if ( oReader, L"count", m_oCount )
WritingElement_ReadAttributes_End( oReader )
}
void CBorders::ReadAttributes(std::vector<XLS::BaseObjectPtr>& obj)
{
m_oCount = (_UINT32)obj.size();
}
} //Spreadsheet
} // namespace OOX
Reference in New Issue View Git Blame Copy Permalink