mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-02-10 18:05:41 +08:00
265 lines
8.5 KiB
C++
265 lines
8.5 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 "calcs_styles.h"
|
|
#include <algorithm>
|
|
|
|
namespace cpdoccore {
|
|
|
|
using namespace odf_types;
|
|
|
|
namespace odf_reader {
|
|
|
|
text_format_properties_ptr calc_text_properties_content(const std::vector<const style_text_properties*> & textProps)
|
|
{
|
|
if (textProps.empty()) return text_format_properties_ptr();
|
|
|
|
text_format_properties_ptr result = boost::make_shared<text_format_properties>();
|
|
|
|
for (size_t i = 0; i < textProps.size(); i++)
|
|
{
|
|
if (textProps[i])
|
|
result->apply_from(textProps[i]->content_);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
text_format_properties_ptr calc_text_properties_content(const style_instance * styleInstance)
|
|
{
|
|
std::vector<const style_text_properties*> textProps;
|
|
|
|
while (styleInstance)
|
|
{
|
|
if (const style_content * content = styleInstance->content())
|
|
{
|
|
const style_text_properties * textProp = content->get_style_text_properties();
|
|
if (textProp)
|
|
{
|
|
textProps.insert(textProps.begin(), textProp);
|
|
}
|
|
}
|
|
|
|
styleInstance = styleInstance->parent();
|
|
}
|
|
return calc_text_properties_content(textProps);
|
|
}
|
|
|
|
text_format_properties_ptr calc_text_properties_content(const std::vector<const style_instance *> & styleInstances)
|
|
{
|
|
if (styleInstances.empty()) return text_format_properties_ptr();
|
|
|
|
text_format_properties_ptr result = boost::make_shared<text_format_properties>();
|
|
|
|
for (size_t i = 0; i < styleInstances.size(); i++)
|
|
{
|
|
text_format_properties_ptr props = calc_text_properties_content(styleInstances[i]);
|
|
if (props)
|
|
{
|
|
result->apply_from(*props.get());
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//////////////
|
|
graphic_format_properties_ptr calc_graphic_properties_content(const std::vector<const graphic_format_properties*> & graphicProps)
|
|
{
|
|
if (graphicProps.empty()) return graphic_format_properties_ptr();
|
|
|
|
graphic_format_properties_ptr result = boost::make_shared<graphic_format_properties>();
|
|
|
|
for (size_t i = 0; i < graphicProps.size(); i++)
|
|
{
|
|
if (graphicProps[i])
|
|
result->apply_from(graphicProps[i]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
graphic_format_properties_ptr calc_graphic_properties_content(const style_instance * styleInstance, bool noParentStandard)
|
|
{
|
|
if (!styleInstance) return graphic_format_properties_ptr();
|
|
|
|
std::vector<const graphic_format_properties*> graphicProps;
|
|
while (styleInstance)
|
|
{
|
|
if (const style_content * content = styleInstance->content())
|
|
if (const graphic_format_properties * graphicProp = content->get_graphic_properties())
|
|
{
|
|
graphicProps.insert(graphicProps.begin(), graphicProp);
|
|
}
|
|
|
|
styleInstance = (noParentStandard && L"standard" == XmlUtils::GetLower(styleInstance->parent_name())) ? NULL : styleInstance->parent();
|
|
}
|
|
return calc_graphic_properties_content(graphicProps);
|
|
}
|
|
|
|
graphic_format_properties_ptr calc_graphic_properties_content(const std::vector<const style_instance *> & styleInstances, bool noParentStandard)
|
|
{
|
|
if (styleInstances.empty()) return graphic_format_properties_ptr();
|
|
|
|
graphic_format_properties_ptr result = boost::make_shared<graphic_format_properties>();
|
|
|
|
for (size_t i = 0; i < styleInstances.size(); i++)
|
|
{
|
|
graphic_format_properties_ptr f = calc_graphic_properties_content(styleInstances[i], noParentStandard);
|
|
result->apply_from(f.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
paragraph_format_properties calc_paragraph_properties_content(const std::vector<const style_paragraph_properties*> & parProps)
|
|
{
|
|
paragraph_format_properties result;
|
|
|
|
for (size_t i = 0; i < parProps.size(); i++)
|
|
{
|
|
if (parProps[i])
|
|
result.apply_from(parProps[i]->content_);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
paragraph_format_properties calc_paragraph_properties_content(const style_instance * styleInstance)
|
|
{
|
|
std::vector<const style_paragraph_properties*> parProps;
|
|
while (styleInstance)
|
|
{
|
|
if (const style_content * content = styleInstance->content())
|
|
if (const style_paragraph_properties * parProp = content->get_style_paragraph_properties())
|
|
{
|
|
parProps.insert(parProps.begin(), parProp);
|
|
}
|
|
styleInstance = styleInstance->parent();
|
|
}
|
|
return calc_paragraph_properties_content(parProps);
|
|
}
|
|
|
|
paragraph_format_properties calc_paragraph_properties_content(const std::vector<const style_instance *> & styleInstances)
|
|
{
|
|
paragraph_format_properties result;
|
|
for (size_t i = 0; i < styleInstances.size(); i++)
|
|
{
|
|
result.apply_from(calc_paragraph_properties_content(styleInstances[i]));
|
|
}
|
|
return result;
|
|
}
|
|
_CP_OPT(int) calc_outline_level(_CP_OPT(int) value, const style_instance * styleInstance)
|
|
{
|
|
if (value) return value;
|
|
|
|
while (styleInstance)
|
|
{
|
|
if (styleInstance->outline_level())
|
|
{
|
|
return styleInstance->outline_level();
|
|
}
|
|
|
|
styleInstance = styleInstance->parent();
|
|
}
|
|
|
|
return boost::none;
|
|
}
|
|
|
|
void calc_tab_stops(const style_instance * styleInstance, oox::tabs_context & context)
|
|
{
|
|
std::vector<const style_paragraph_properties*> parProps;
|
|
while (styleInstance)
|
|
{
|
|
if (const style_content * content = styleInstance->content())
|
|
if (const style_paragraph_properties * parProp = content->get_style_paragraph_properties())
|
|
{
|
|
parProps.insert(parProps.begin(), parProp);
|
|
}
|
|
styleInstance = styleInstance->parent();
|
|
}
|
|
double margin_left = 0;
|
|
|
|
for (size_t i = 0; i < parProps.size(); i++)
|
|
{
|
|
if (parProps[i]->content_.fo_margin_left_)
|
|
margin_left = 20.0 * parProps[i]->content_.fo_margin_left_->get_length().get_value_unit(odf_types::length::pt);
|
|
|
|
if ( parProps[i]->content_.style_tab_stops_ )
|
|
{
|
|
style_tab_stops *tab_stops = dynamic_cast<style_tab_stops*>(parProps[i]->content_.style_tab_stops_.get());
|
|
context.reset();
|
|
for (size_t j = 0; j < tab_stops->content_.size(); j++)
|
|
{
|
|
context.add(tab_stops->content_[j], margin_left);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//////
|
|
|
|
style_table_cell_properties_attlist calc_table_cell_properties(const std::vector<const style_table_cell_properties*> & props)
|
|
{
|
|
style_table_cell_properties_attlist result;
|
|
for (size_t i = 0; i < props.size(); i++)
|
|
{
|
|
if (props[i])
|
|
result.apply_from(props[i]->attlist_);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
style_table_cell_properties_attlist calc_table_cell_properties(const style_instance * styleInstance)
|
|
{
|
|
std::vector<const style_table_cell_properties*> props;
|
|
while (styleInstance)
|
|
{
|
|
if (style_content * content = styleInstance->content())
|
|
if (style_table_cell_properties * prop = content->get_style_table_cell_properties())
|
|
{
|
|
props.insert(props.begin(), prop);
|
|
}
|
|
styleInstance = styleInstance->parent();
|
|
}
|
|
return calc_table_cell_properties(props);
|
|
}
|
|
|
|
style_table_cell_properties_attlist calc_table_cell_properties(const std::vector<const style_instance *> & styleInstances)
|
|
{
|
|
style_table_cell_properties_attlist result;
|
|
for (size_t i = 0; i < styleInstances.size(); i++)
|
|
{
|
|
result.apply_from(calc_table_cell_properties(styleInstances[i]));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
}
|
|
}
|