410 lines
12 KiB
C++
410 lines
12 KiB
C++
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2023
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
#include "xlsx_font.h"
|
|
|
|
#include "../Format/style_text_properties.h"
|
|
#include "../Format/style_table_properties.h"
|
|
#include "../Format/style_paragraph_properties.h"
|
|
|
|
#include "../Format/odf_document.h"
|
|
#include "../Format/odfcontext.h"
|
|
|
|
#include <boost/functional.hpp>
|
|
#include <xml/simple_xml_writer.h>
|
|
|
|
namespace cpdoccore {
|
|
namespace oox {
|
|
|
|
namespace {
|
|
|
|
std::wostream & operator << (std::wostream & _Wostream, const xlsx_vertAlign & vertAlign)
|
|
{
|
|
switch(vertAlign)
|
|
{
|
|
default:
|
|
case vertAlignBaseline:
|
|
_Wostream << L"baseline";
|
|
break;
|
|
case vertAlignSubscript:
|
|
_Wostream << L"subscript";
|
|
break;
|
|
case vertAlignSuperscript:
|
|
_Wostream << L"superscript";
|
|
break;
|
|
}
|
|
return _Wostream;
|
|
}
|
|
|
|
std::wostream & operator << (std::wostream & _Wostream, const XlsxUnderline & u)
|
|
{
|
|
switch(u)
|
|
{
|
|
default:
|
|
case XUNDERLINE_NONE:
|
|
_Wostream << L"none";
|
|
break;
|
|
case XUNDERLINE_SINGLE:
|
|
_Wostream << L"single";
|
|
break;
|
|
case XUNDERLINE_DOUBLE:
|
|
_Wostream << L"double";
|
|
break;
|
|
case XUNDERLINE_SINGLE_ACCOUNTING:
|
|
_Wostream << L"singleAccounting";
|
|
break;
|
|
case XUNDERLINE_DOUBLE_ACCOUNTING:
|
|
_Wostream << L"doubleAccounting";
|
|
break;
|
|
}
|
|
return _Wostream;
|
|
}
|
|
|
|
}
|
|
|
|
void xlsx_serialize(std::wostream & _Wostream, const xlsx_font & font)
|
|
{
|
|
CP_XML_WRITER(_Wostream)
|
|
{
|
|
CP_XML_NODE(L"font")
|
|
{
|
|
if (font.bold)
|
|
{
|
|
CP_XML_NODE(L"b")
|
|
{
|
|
CP_XML_ATTR(L"val", (int)(*font.bold));
|
|
}
|
|
}
|
|
|
|
if (font.charset)
|
|
{
|
|
CP_XML_NODE(L"charset")
|
|
{
|
|
CP_XML_ATTR(L"val", *font.charset);
|
|
}
|
|
}
|
|
|
|
if (font.color)
|
|
xlsx_serialize(CP_XML_STREAM(), *font.color);
|
|
|
|
if (font.condense)
|
|
{
|
|
CP_XML_NODE(L"condense")
|
|
{
|
|
CP_XML_ATTR(L"val", (int)(*font.condense));
|
|
}
|
|
}
|
|
|
|
if (font.extend)
|
|
{
|
|
CP_XML_NODE(L"extend")
|
|
{
|
|
CP_XML_ATTR(L"val", (int)(*font.extend));
|
|
}
|
|
}
|
|
|
|
if (font.family)
|
|
{
|
|
CP_XML_NODE(L"family")
|
|
{
|
|
CP_XML_ATTR(L"val", (int)(*font.family));
|
|
}
|
|
}
|
|
|
|
if (font.i)
|
|
{
|
|
CP_XML_NODE(L"i")
|
|
{
|
|
CP_XML_ATTR(L"val", (int)(*font.i));
|
|
}
|
|
}
|
|
|
|
if (font.name)
|
|
{
|
|
CP_XML_NODE(L"name")
|
|
{
|
|
CP_XML_ATTR(L"val", *font.name);
|
|
}
|
|
}
|
|
|
|
if (font.outline)
|
|
{
|
|
CP_XML_NODE(L"outline")
|
|
{
|
|
CP_XML_ATTR(L"val", (int)(*font.outline));
|
|
}
|
|
}
|
|
|
|
if (font.scheme)
|
|
{
|
|
CP_XML_NODE(L"scheme")
|
|
{
|
|
CP_XML_ATTR(L"val", *font.scheme);
|
|
}
|
|
}
|
|
|
|
if (font.shadow)
|
|
{
|
|
CP_XML_NODE(L"shadow")
|
|
{
|
|
CP_XML_ATTR(L"val", (int)(*font.shadow));
|
|
}
|
|
}
|
|
|
|
if (font.strike)
|
|
{
|
|
CP_XML_NODE(L"strike")
|
|
{
|
|
CP_XML_ATTR(L"val", (int)(*font.strike));
|
|
}
|
|
}
|
|
|
|
if (font.sz)
|
|
{
|
|
CP_XML_NODE(L"sz")
|
|
{
|
|
CP_XML_ATTR(L"val", *font.sz);
|
|
}
|
|
}
|
|
|
|
if (font.u)
|
|
{
|
|
CP_XML_NODE(L"u")
|
|
{
|
|
CP_XML_ATTR(L"val", *font.u);
|
|
}
|
|
}
|
|
|
|
if (font.vertAlign)
|
|
{
|
|
CP_XML_NODE(L"vertAlign")
|
|
{
|
|
CP_XML_ATTR(L"val", *font.vertAlign);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
bool xlsx_font::operator == (const xlsx_font & rVal) const
|
|
{
|
|
const bool res =
|
|
bold.get_value_or(false) == rVal.bold.get_value_or(false) &&
|
|
charset == rVal.charset &&
|
|
color == rVal.color &&
|
|
condense.get_value_or(false) == rVal.condense.get_value_or(false) &&
|
|
extend.get_value_or(false) == rVal.extend.get_value_or(false) &&
|
|
family == rVal.family &&
|
|
i.get_value_or(false) == rVal.i.get_value_or(false) &&
|
|
name == rVal.name &&
|
|
outline.get_value_or(false) == rVal.outline.get_value_or(false) &&
|
|
scheme == rVal.scheme &&
|
|
shadow.get_value_or(false) == rVal.shadow.get_value_or(false) &&
|
|
strike.get_value_or(false) == rVal.strike.get_value_or(false) &&
|
|
sz == rVal.sz &&
|
|
u.get_value_or(XUNDERLINE_NONE) == rVal.u.get_value_or(XUNDERLINE_NONE) &&
|
|
vertAlign == rVal.vertAlign;
|
|
|
|
return res;
|
|
}
|
|
|
|
bool xlsx_font::operator != (const xlsx_font & rVal) const
|
|
{
|
|
return !(this->operator ==(rVal));
|
|
}
|
|
|
|
std::size_t hash_value(xlsx_font const & val)
|
|
{
|
|
std::size_t seed = 0;
|
|
boost::hash_combine(seed, val.bold.get_value_or(false));
|
|
boost::hash_combine(seed, val.charset.get_value_or(0));
|
|
boost::hash_combine(seed, val.color.get_value_or(xlsx_color()));
|
|
boost::hash_combine(seed, val.condense.get_value_or(false));
|
|
boost::hash_combine(seed, val.extend.get_value_or(false));
|
|
boost::hash_combine(seed, val.family.get_value_or(XFAMILY_EMPTY));
|
|
boost::hash_combine(seed, val.i.get_value_or(false));
|
|
boost::hash_combine(seed, val.name.get_value_or(L""));
|
|
boost::hash_combine(seed, val.outline.get_value_or(false));
|
|
boost::hash_combine(seed, val.scheme.get_value_or(L""));
|
|
boost::hash_combine(seed, val.shadow.get_value_or(false));
|
|
boost::hash_combine(seed, val.strike.get_value_or(false));
|
|
boost::hash_combine(seed, val.sz.get_value_or(0));
|
|
boost::hash_combine(seed, val.u.get_value_or(XUNDERLINE_NONE));
|
|
boost::hash_combine(seed, val.vertAlign.get_value_or(vertAlignBaseline));
|
|
return seed;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
XlsxFontCharset GetXlsxFontCharset(const odf_reader::text_format_properties_ptr textProp)
|
|
{
|
|
// TODO
|
|
return XCHARSET_EMPTY;
|
|
}
|
|
|
|
XlsxFontFamily GetXlsxFontFamily(const odf_reader::text_format_properties_ptr textProp)
|
|
{
|
|
// TODO
|
|
return XFAMILY_EMPTY;
|
|
}
|
|
|
|
xlsx_font::xlsx_font ( const odf_reader::text_format_properties_ptr &textProp,
|
|
const odf_reader::paragraph_format_properties *parProp,
|
|
const odf_reader::style_table_cell_properties_attlist *cellProp,
|
|
bool default_set, odf_reader::fonts_container & fonts)
|
|
{
|
|
bEnabled = false;
|
|
if (!textProp) return;
|
|
|
|
bEnabled = true;
|
|
if (textProp->fo_font_weight_)
|
|
{
|
|
if (textProp->fo_font_weight_.get().get_type() == odf_types::font_weight::WBold)
|
|
bold = true;
|
|
else
|
|
bold = false;
|
|
}
|
|
|
|
if (textProp->fo_font_style_)
|
|
{
|
|
if (textProp->fo_font_style_.get().get_type() == odf_types::font_style::Italic)
|
|
i = true;
|
|
else
|
|
i = false;
|
|
}
|
|
|
|
XlsxFontCharset charset_ = GetXlsxFontCharset(textProp);
|
|
if (charset_ != XCHARSET_EMPTY)
|
|
{
|
|
charset = (unsigned int)charset_;
|
|
}
|
|
|
|
XlsxFontFamily family_ = GetXlsxFontFamily(textProp);
|
|
if (family_ != XFAMILY_EMPTY)
|
|
{
|
|
family = family_;
|
|
}
|
|
if (textProp->style_font_name_ || textProp->style_font_name_asian_ || textProp->style_font_name_complex_ || textProp->fo_font_family_)
|
|
{
|
|
std::wstring w_eastAsia;
|
|
std::wstring w_hAnsi;
|
|
std::wstring w_cs;
|
|
std::wstring w_ascii = w_hAnsi = w_cs = (textProp->fo_font_family_ ? *textProp->fo_font_family_ : L"");
|
|
|
|
if (textProp->style_font_name_complex_)
|
|
{
|
|
odf_reader::font_instance * font = fonts.font_by_style_name(*textProp->style_font_name_complex_);
|
|
if (font)
|
|
w_cs = font->name();
|
|
}
|
|
if (textProp->style_font_name_asian_)
|
|
{
|
|
odf_reader::font_instance * font = fonts.font_by_style_name(*textProp->style_font_name_asian_);
|
|
if (font)
|
|
w_eastAsia = font->name();
|
|
}
|
|
if (textProp->style_font_name_)
|
|
{
|
|
odf_reader::font_instance * font = fonts.font_by_style_name(*textProp->style_font_name_);
|
|
if (font)
|
|
{
|
|
w_ascii = w_hAnsi = font->name();
|
|
|
|
if (font->charset() == L"02")
|
|
{
|
|
if (w_cs.empty()) w_cs = font->name();
|
|
if (w_eastAsia.empty()) w_eastAsia = font->name();
|
|
}
|
|
}
|
|
}
|
|
name = !w_ascii.empty() ? w_ascii : (!w_cs.empty() ? w_cs : (!w_eastAsia.empty() ? w_eastAsia : w_hAnsi));
|
|
}
|
|
|
|
if (textProp->fo_font_size_)
|
|
{
|
|
sz = textProp->fo_font_size_->get_length().get_value_unit(odf_types::length::pt);
|
|
}
|
|
//else
|
|
//{
|
|
// sz = 10.;//kDefaultFontSize; //todooo ... вытащить как в math
|
|
//}
|
|
|
|
if ((textProp->style_text_underline_type_ &&
|
|
textProp->style_text_underline_type_->get_type() != odf_types::line_type::None) ||
|
|
|
|
(textProp->style_text_underline_style_ &&
|
|
textProp->style_text_underline_style_->get_type() != odf_types::line_style::None))
|
|
{
|
|
if (textProp->style_text_underline_type_ &&
|
|
textProp->style_text_underline_type_->get_type() == odf_types::line_type::Double)
|
|
u = XUNDERLINE_DOUBLE;
|
|
else
|
|
u = XUNDERLINE_SINGLE;
|
|
}
|
|
|
|
if ((textProp->style_text_line_through_type_ &&
|
|
textProp->style_text_line_through_type_->get_type() != odf_types::line_type::None) ||
|
|
|
|
(textProp->style_text_line_through_style_ &&
|
|
textProp->style_text_line_through_style_->get_type() != odf_types::line_style::None))
|
|
{
|
|
strike = true;
|
|
}
|
|
|
|
if (textProp->fo_text_shadow_)
|
|
{
|
|
if (textProp->fo_text_shadow_->get_type() == odf_types::shadow_type::Enable)
|
|
shadow = true;
|
|
else
|
|
shadow = false;
|
|
}
|
|
|
|
bool default_color = false;
|
|
if (textProp->style_use_window_font_color_)
|
|
default_color = true;
|
|
|
|
if (textProp->fo_color_ && !default_color)
|
|
{
|
|
color = xlsx_color();
|
|
color->rgb = L"ff" + textProp->fo_color_->get_hex_value();
|
|
|
|
}
|
|
|
|
if (default_set && !name)
|
|
{
|
|
name = L"Liberation Sans";
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|