1691 lines
52 KiB
C++
1691 lines
52 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 "styles.h"
|
|
#include <xml/xmlchar.h>
|
|
|
|
#include <xml/attributes.h>
|
|
#include <xml/simple_xml_writer.h>
|
|
#include <iostream>
|
|
|
|
#include "office_elements_create.h"
|
|
|
|
#include "style_text_properties.h"
|
|
#include "style_paragraph_properties.h"
|
|
#include "style_table_properties.h"
|
|
#include "style_graphic_properties.h"
|
|
#include "style_chart_properties.h"
|
|
#include "style_section_properties.h"
|
|
#include "style_page_layout_properties.h"
|
|
#include "style_presentation.h"
|
|
|
|
namespace cpdoccore {
|
|
|
|
using namespace odf_types;
|
|
|
|
namespace odf_writer {
|
|
|
|
using xml::xml_char_wc;
|
|
//
|
|
text_format_properties * style_content::add_get_style_text_properties()
|
|
{
|
|
if (!style_text_properties_)
|
|
create_element(L"style", L"text-properties",style_text_properties_, Context);
|
|
|
|
return get_text_properties();
|
|
}
|
|
|
|
paragraph_format_properties * style_content::add_get_style_paragraph_properties()
|
|
{
|
|
if (!style_paragraph_properties_)
|
|
create_element(L"style", L"paragraph-properties",style_paragraph_properties_, Context);
|
|
|
|
return get_paragraph_properties();
|
|
}
|
|
graphic_format_properties* style_content::get_graphic_properties()
|
|
{
|
|
style_graphic_properties * style_gr = dynamic_cast<style_graphic_properties *>(style_graphic_properties_.get());
|
|
loext_graphic_properties * loext_gr = dynamic_cast<loext_graphic_properties *>(style_graphic_properties_.get());
|
|
|
|
if (style_gr)
|
|
{
|
|
return &style_gr->content_;
|
|
}
|
|
else if (loext_gr)
|
|
{
|
|
return &loext_gr->content_;
|
|
}
|
|
else
|
|
return NULL;
|
|
}
|
|
paragraph_format_properties* style_content::get_paragraph_properties()
|
|
{
|
|
style_paragraph_properties *style_paragraph = dynamic_cast<style_paragraph_properties *>(style_paragraph_properties_.get());
|
|
if (style_paragraph)
|
|
return &(style_paragraph->content_);
|
|
return NULL;
|
|
}
|
|
chart_format_properties* style_content::get_chart_properties()
|
|
{
|
|
style_chart_properties *style_chart = dynamic_cast<style_chart_properties *>(style_chart_properties_.get());
|
|
if (style_chart)
|
|
return &(style_chart->content_);
|
|
return NULL;
|
|
}
|
|
text_format_properties* style_content::get_text_properties()
|
|
{
|
|
style_text_properties *style_text = dynamic_cast<style_text_properties *>(style_text_properties_.get());
|
|
if (style_text)
|
|
return &(style_text->content_);
|
|
return NULL;
|
|
}
|
|
drawing_page_properties* style_content::get_drawing_page_properties()
|
|
{
|
|
style_drawing_page_properties* style_page = dynamic_cast<style_drawing_page_properties*>(style_drawing_page_properties_.get());
|
|
if (style_page)
|
|
return &(style_page->content_);
|
|
return NULL;
|
|
}
|
|
graphic_format_properties * style_content::add_get_style_graphic_properties()
|
|
{
|
|
if (!style_graphic_properties_)
|
|
{
|
|
if (style_family_ == odf_types::style_family::TableCell)
|
|
create_element(L"loext", L"graphic-properties", style_graphic_properties_, Context);
|
|
else
|
|
create_element(L"style", L"graphic-properties", style_graphic_properties_, Context);
|
|
}
|
|
return get_graphic_properties();
|
|
}
|
|
|
|
style_table_properties* style_content::add_get_style_table_properties()
|
|
{
|
|
if (!style_table_properties_)
|
|
create_element(L"style", L"table-properties", style_table_properties_, Context);
|
|
|
|
return dynamic_cast<style_table_properties *>(style_table_properties_.get());
|
|
}
|
|
|
|
style_section_properties * style_content::add_get_style_section_properties()
|
|
{
|
|
if (!style_section_properties_)
|
|
create_element(L"style", L"section-properties",style_section_properties_, Context);
|
|
|
|
return dynamic_cast<style_section_properties *>(style_section_properties_.get());
|
|
}
|
|
|
|
style_table_cell_properties * style_content::add_get_style_table_cell_properties()
|
|
{
|
|
//если запросили .. значит надо - создаем
|
|
if (!style_table_cell_properties_)
|
|
create_element(L"style", L"table-cell-properties",style_table_cell_properties_, Context);
|
|
|
|
return dynamic_cast<style_table_cell_properties *>(style_table_cell_properties_.get());
|
|
}
|
|
|
|
style_table_row_properties * style_content::add_get_style_table_row_properties()
|
|
{
|
|
if (!style_table_row_properties_)
|
|
create_element(L"style", L"table-row-properties",style_table_row_properties_, Context);
|
|
|
|
return dynamic_cast<style_table_row_properties *>(style_table_row_properties_.get());
|
|
}
|
|
|
|
style_table_column_properties* style_content::add_get_style_table_column_properties()
|
|
{
|
|
if (!style_table_column_properties_)
|
|
create_element(L"style", L"table-column-properties",style_table_column_properties_, Context);
|
|
|
|
return dynamic_cast<style_table_column_properties *>(style_table_column_properties_.get());
|
|
}
|
|
|
|
chart_format_properties* style_content::add_get_style_chart_properties()
|
|
{
|
|
if (!style_chart_properties_)
|
|
create_element(L"style", L"chart-properties", style_chart_properties_, Context);
|
|
|
|
return get_chart_properties();
|
|
}
|
|
style_drawing_page_properties * style_content::add_get_style_drawing_page_properties()
|
|
{
|
|
if (!style_drawing_page_properties_)
|
|
create_element(L"style", L"drawing-page-properties", style_drawing_page_properties_, Context);
|
|
|
|
return dynamic_cast<style_drawing_page_properties *>(style_drawing_page_properties_.get());
|
|
}
|
|
void style_content::add_child_element( const office_element_ptr & child)
|
|
{
|
|
if (!child)return;
|
|
|
|
ElementType type_ = child->get_type();
|
|
|
|
switch(type_)//перезатирать???
|
|
{
|
|
case typeStyleTextProperties: style_text_properties_ = child; break;
|
|
case typeStyleParagraphProperties: style_paragraph_properties_ = child; break;
|
|
case typeStyleTableProperties: style_table_properties_ = child; break;
|
|
case typeStyleTableColumnProperties:style_table_column_properties_ = child; break;
|
|
case typeStyleTableCellProperties: style_table_cell_properties_ = child; break;
|
|
case typeStyleTableRowProperties: style_table_row_properties_ = child; break;
|
|
case typeStyleSectionProperties: style_section_properties_ = child; break;
|
|
case typeStyleGraphicPropertis: style_graphic_properties_ = child; break;
|
|
case typeStyleChartProperties: style_chart_properties_ = child; break;
|
|
case typeStyleDrawingPageProperties:style_drawing_page_properties_ = child; break;
|
|
//ruby
|
|
}
|
|
}
|
|
|
|
void style_content::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
if CP_CHECK_NAME(L"style", L"text-properties")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(style_text_properties_);
|
|
}
|
|
else if CP_CHECK_NAME(L"style", L"paragraph-properties")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(style_paragraph_properties_);
|
|
}
|
|
else if CP_CHECK_NAME(L"style", L"table-properties")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(style_table_properties_);
|
|
}
|
|
else if CP_CHECK_NAME(L"style", L"table-column-properties")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(style_table_column_properties_);
|
|
}
|
|
else if CP_CHECK_NAME(L"style", L"table-cell-properties")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(style_table_cell_properties_);
|
|
}
|
|
else if CP_CHECK_NAME(L"style", L"table-row-properties")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(style_table_row_properties_);
|
|
}
|
|
else if CP_CHECK_NAME(L"style", L"section-properties")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(style_section_properties_);
|
|
}
|
|
else if CP_CHECK_NAME(L"style", L"graphic-properties")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(style_graphic_properties_);
|
|
}
|
|
else if CP_CHECK_NAME(L"style", L"chart-properties")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(style_chart_properties_);
|
|
}
|
|
else if CP_CHECK_NAME(L"style", L"drawing-page-properties")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(style_drawing_page_properties_);
|
|
}
|
|
else
|
|
{
|
|
not_applicable_element(L"style-content", Ns, Name);
|
|
}
|
|
}
|
|
void style_content::serialize(std::wostream & strm)
|
|
{
|
|
if (style_table_cell_properties_) style_table_cell_properties_->serialize(strm);
|
|
if (style_graphic_properties_) style_graphic_properties_->serialize(strm);
|
|
if (style_paragraph_properties_) style_paragraph_properties_->serialize(strm);
|
|
if (style_section_properties_) style_section_properties_->serialize(strm);
|
|
if (style_ruby_properties_) style_ruby_properties_->serialize(strm);
|
|
if (style_table_properties_) style_table_properties_->serialize(strm);
|
|
if (style_table_column_properties_) style_table_column_properties_->serialize(strm);
|
|
if (style_table_row_properties_) style_table_row_properties_->serialize(strm);
|
|
if (style_chart_properties_) style_chart_properties_->serialize(strm);
|
|
if (style_drawing_page_properties_) style_drawing_page_properties_->serialize(strm);
|
|
if (style_text_properties_) style_text_properties_->serialize(strm);
|
|
}
|
|
|
|
// style:default-style
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * default_style::ns = L"style";
|
|
const wchar_t * default_style::name = L"default-style";
|
|
|
|
|
|
void default_style::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
content_.create_child_element(Ns, Name);
|
|
}
|
|
void default_style::add_child_element( const office_element_ptr & child)
|
|
{
|
|
content_.add_child_element(child);
|
|
}
|
|
void default_style::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
CP_XML_ATTR(L"style:family", style_family_);
|
|
content_.serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * draw_fill_image::ns = L"draw";
|
|
const wchar_t * draw_fill_image::name = L"fill-image";
|
|
|
|
void draw_fill_image::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
CP_NOT_APPLICABLE_ELM();
|
|
}
|
|
void draw_fill_image::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"draw:name", draw_name_);
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"draw:display_name", draw_display_name_);
|
|
|
|
xlink_attlist_.serialize(CP_GET_XML_NODE());
|
|
}
|
|
}
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * draw_marker::ns = L"draw";
|
|
const wchar_t * draw_marker::name = L"marker";
|
|
|
|
void draw_marker::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
CP_NOT_APPLICABLE_ELM();
|
|
}
|
|
void draw_marker::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"draw:name", draw_name_);
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"draw:display_name", draw_display_name_);
|
|
|
|
CP_XML_ATTR_OPT(L"svg:d", svg_d_);
|
|
CP_XML_ATTR_OPT(L"svg:viewBox", svg_viewBox_);
|
|
}
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * draw_gradient::ns = L"draw";
|
|
const wchar_t * draw_gradient::name = L"gradient";
|
|
|
|
void draw_gradient::add_child_element(const office_element_ptr& child)
|
|
{
|
|
content_.push_back(child);
|
|
}
|
|
void draw_gradient::create_child_element(const std::wstring& Ns, const std::wstring& Name)
|
|
{
|
|
CP_CREATE_ELEMENT(content_);
|
|
}
|
|
void draw_gradient::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
CP_XML_ATTR_OPT(L"draw:start-color",draw_start_color_);
|
|
CP_XML_ATTR_OPT(L"draw:end-color", draw_end_color_);
|
|
|
|
CP_XML_ATTR_OPT(L"draw:end-intensity", draw_end_intensity_);
|
|
CP_XML_ATTR_OPT(L"draw:start-intensity",draw_start_intensity_);
|
|
|
|
CP_XML_ATTR_OPT(L"draw:cx", draw_cy_);//%
|
|
CP_XML_ATTR_OPT(L"draw:cy", draw_cx_);
|
|
|
|
CP_XML_ATTR_OPT(L"draw:border", draw_border_);
|
|
CP_XML_ATTR_OPT(L"draw:angle", draw_angle_);
|
|
CP_XML_ATTR_OPT(L"draw:style", draw_style_);
|
|
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"draw:name", draw_name_);
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"draw:display_name", draw_display_name_);
|
|
|
|
for (size_t i = 0; i < content_.size(); i++)
|
|
{
|
|
content_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * draw_hatch::ns = L"draw";
|
|
const wchar_t * draw_hatch::name = L"hatch";
|
|
|
|
void draw_hatch::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
CP_NOT_APPLICABLE_ELM();
|
|
}
|
|
void draw_hatch::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
CP_XML_ATTR_OPT(L"draw:color", draw_color_);
|
|
CP_XML_ATTR_OPT(L"draw:rotation", draw_rotation_);
|
|
|
|
CP_XML_ATTR_OPT(L"draw:distance", draw_distance_);
|
|
CP_XML_ATTR_OPT(L"draw:style", draw_style_);
|
|
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"draw:name", draw_name_);
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"draw:display_name", draw_display_name_);
|
|
}
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * draw_opacity::ns = L"draw";
|
|
const wchar_t * draw_opacity::name = L"opacity";
|
|
|
|
void draw_opacity::add_child_element(const office_element_ptr& child)
|
|
{
|
|
content_.push_back(child);
|
|
}
|
|
void draw_opacity::create_child_element(const std::wstring& Ns, const std::wstring& Name)
|
|
{
|
|
CP_CREATE_ELEMENT(content_);
|
|
}
|
|
void draw_opacity::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
CP_XML_ATTR_OPT(L"draw:start", draw_start_);
|
|
CP_XML_ATTR_OPT(L"draw:end", draw_end_);
|
|
|
|
CP_XML_ATTR_OPT(L"draw:cx", draw_cx_);
|
|
CP_XML_ATTR_OPT(L"draw:cy", draw_cy_);
|
|
|
|
CP_XML_ATTR_OPT(L"draw:border", draw_border_);
|
|
CP_XML_ATTR_OPT(L"draw:angle", draw_angle_);
|
|
CP_XML_ATTR_OPT(L"draw:style", draw_style_);
|
|
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"draw:name", draw_name_);
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"draw:display_name", draw_display_name_);
|
|
|
|
for (size_t i = 0; i < content_.size(); i++)
|
|
{
|
|
content_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * draw_layer::ns = L"draw";
|
|
const wchar_t * draw_layer::name = L"layer";
|
|
|
|
void draw_layer::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
CP_NOT_APPLICABLE_ELM();
|
|
}
|
|
void draw_layer::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"draw:name", draw_name_);
|
|
}
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * draw_layer_set::ns = L"draw";
|
|
const wchar_t * draw_layer_set::name = L"layer-set";
|
|
|
|
void draw_layer_set::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
CP_CREATE_ELEMENT(content_);
|
|
}
|
|
|
|
void draw_layer_set::add_child_element( const office_element_ptr & child)
|
|
{
|
|
content_.push_back(child);
|
|
}
|
|
|
|
void draw_layer_set::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
for (size_t i = 0; i < content_.size(); i++)
|
|
{
|
|
content_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// style:style
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * style::ns = L"style";
|
|
const wchar_t * style::name = L"style";
|
|
|
|
void style::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
if CP_CHECK_NAME(L"style", L"map")
|
|
{
|
|
CP_CREATE_ELEMENT(style_map_);
|
|
}
|
|
else
|
|
content_.create_child_element(Ns, Name);
|
|
}
|
|
|
|
void style::add_child_element( const office_element_ptr & child)
|
|
{
|
|
if (!child)return;
|
|
|
|
ElementType type_ = child->get_type();
|
|
|
|
if (type_ == typeStyleMap)
|
|
{
|
|
style_map_.push_back(child);
|
|
}
|
|
else
|
|
content_.add_child_element(child);
|
|
}
|
|
void style::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
CP_XML_ATTR_OPT(L"style:default-outline-level", style_default_outline_level_);
|
|
CP_XML_ATTR_OPT(L"style:parent-style-name", style_parent_style_name_);
|
|
CP_XML_ATTR_OPT(L"style:next-style-name", style_next_style_name_);
|
|
CP_XML_ATTR_OPT(L"style:list-style-name", style_list_style_name_);
|
|
CP_XML_ATTR_OPT(L"style:auto-update", style_auto_update_);
|
|
CP_XML_ATTR_OPT(L"style:data-style-name", style_data_style_name_);
|
|
CP_XML_ATTR_OPT(L"style:class", style_class_);
|
|
CP_XML_ATTR_OPT(L"style:master-page-name", style_master_page_name_);
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"style:display-name", style_display_name_);
|
|
CP_XML_ATTR(L"style:family", style_family_);
|
|
CP_XML_ATTR(L"style:name", XmlUtils::EncodeXmlString(style_name_));
|
|
|
|
content_.serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
// styles & draw_styles
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void styles::create_child_element( const std::wstring & Ns, const std::wstring & Name, odf_conversion_context * Context)
|
|
{
|
|
if CP_CHECK_NAME(L"style", L"style")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(style_style_);
|
|
}
|
|
else if CP_CHECK_NAME(L"text", L"list-style")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(text_list_style_);
|
|
}
|
|
else if (
|
|
CP_CHECK_NAME(L"number", L"number-style") ||
|
|
CP_CHECK_NAME(L"number", L"currency-style") ||
|
|
CP_CHECK_NAME(L"number", L"percentage-style") ||
|
|
CP_CHECK_NAME(L"number", L"date-style") ||
|
|
CP_CHECK_NAME(L"number", L"time-style") ||
|
|
CP_CHECK_NAME(L"number", L"number-boolean-style")
|
|
)
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(number_styles_);
|
|
}
|
|
else
|
|
{
|
|
CP_NOT_APPLICABLE_ELM_SIMPLE(L"styles");
|
|
}
|
|
}
|
|
void styles::add_child_element( const office_element_ptr & child, odf_conversion_context * Context)
|
|
{
|
|
if (!child)return;
|
|
|
|
ElementType type_ = child->get_type();
|
|
|
|
switch(type_)
|
|
{
|
|
case typeStyleStyle:
|
|
style_style_.push_back(child);
|
|
break;
|
|
case typeTextListStyle:
|
|
text_list_style_.push_back(child);
|
|
break;
|
|
case typeNumberTimeStyle:
|
|
case typeNumberDataStyle:
|
|
case typeNumberPercentageStyle:
|
|
case typeNumberCurrencyStyle:
|
|
case typeNumberNumberStyle:
|
|
//boolean
|
|
number_styles_.push_back(child);
|
|
break;
|
|
}
|
|
}
|
|
void styles::serialize(std::wostream & strm)//content from different element
|
|
{
|
|
for (size_t i = 0; i < number_styles_.size(); i++)
|
|
{
|
|
number_styles_[i]->serialize(strm);
|
|
}
|
|
for (size_t i = 0; i < style_style_.size(); i++)
|
|
{
|
|
style_style_[i]->serialize(strm);
|
|
}
|
|
for (size_t i = 0; i < text_list_style_.size(); i++)
|
|
{
|
|
text_list_style_[i]->serialize(strm);
|
|
}
|
|
}
|
|
void templates::create_child_element( const std::wstring & Ns, const std::wstring & Name, odf_conversion_context * Context)
|
|
{
|
|
if CP_CHECK_NAME(L"table", L"table-template")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(table_templates_);
|
|
}
|
|
}
|
|
void templates::add_child_element( const office_element_ptr & child)
|
|
{
|
|
if (!child)return;
|
|
|
|
ElementType type_ = child->get_type();
|
|
|
|
if (type_ == typeTableTemplate)
|
|
{
|
|
table_templates_.push_back(child);
|
|
}
|
|
}
|
|
void templates::serialize(std::wostream & strm)
|
|
{
|
|
for (size_t i = 0; i < table_templates_.size(); i++)
|
|
{
|
|
table_templates_[i]->serialize(strm);
|
|
}
|
|
}
|
|
void draw_styles::create_child_element(const std::wstring & Ns, const std::wstring & Name, odf_conversion_context * Context)
|
|
{
|
|
if CP_CHECK_NAME(L"draw", L"gradient")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(draw_gradient_);
|
|
}
|
|
else if CP_CHECK_NAME(L"draw", L"hatch")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(draw_hatch_);
|
|
}
|
|
else if CP_CHECK_NAME(L"draw", L"fill-image")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(draw_fill_image_);
|
|
}
|
|
else if CP_CHECK_NAME(L"draw", L"opacity")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(draw_opacity_);
|
|
}
|
|
else if CP_CHECK_NAME(L"draw", L"marker")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(draw_marker_);
|
|
}
|
|
else if CP_CHECK_NAME(L"draw", L"stroke-dash")
|
|
{
|
|
CP_CREATE_ELEMENT_SIMPLE(draw_stroke_dash_);
|
|
}
|
|
else
|
|
{
|
|
CP_NOT_APPLICABLE_ELM_SIMPLE(L"draw_styles");
|
|
}
|
|
}
|
|
|
|
void draw_styles::add_child_element( const office_element_ptr & child, odf_conversion_context * Context)
|
|
{
|
|
if (!child)return;
|
|
|
|
ElementType type_ = child->get_type();
|
|
|
|
switch(type_)
|
|
{
|
|
case typeStyleDrawGradient: draw_gradient_.push_back(child); break;
|
|
case typeStyleDrawHatch: draw_hatch_.push_back(child); break;
|
|
case typeStyleDrawFillImage: draw_fill_image_.push_back(child); break;
|
|
case typeStyleDrawOpacity: draw_opacity_.push_back(child); break;
|
|
case typeStyleDrawMarker: draw_marker_.push_back(child); break;
|
|
case typeStyleDrawStrokeDash: draw_stroke_dash_.push_back(child); break;
|
|
}
|
|
}
|
|
|
|
void draw_styles::serialize(std::wostream & strm)
|
|
{
|
|
for (size_t i = 0; i < draw_fill_image_.size(); i++)
|
|
{
|
|
draw_fill_image_[i]->serialize(strm);
|
|
}
|
|
for (size_t i = 0; i < draw_hatch_.size(); i++)
|
|
{
|
|
draw_hatch_[i]->serialize(strm);
|
|
}
|
|
for (size_t i = 0; i < draw_gradient_.size(); i++)
|
|
{
|
|
draw_gradient_[i]->serialize(strm);
|
|
}
|
|
for (size_t i = 0; i < draw_opacity_.size(); i++)
|
|
{
|
|
draw_opacity_[i]->serialize(strm);
|
|
}
|
|
for (size_t i = 0; i < draw_marker_.size(); i++)
|
|
{
|
|
draw_marker_[i]->serialize(strm);
|
|
}
|
|
for (size_t i = 0; i < draw_stroke_dash_.size(); i++)
|
|
{
|
|
draw_stroke_dash_[i]->serialize(strm);
|
|
}
|
|
}
|
|
// office:automatic-styles
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * office_automatic_styles::ns = L"office";
|
|
const wchar_t * office_automatic_styles::name = L"automatic-styles";
|
|
|
|
void office_automatic_styles::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
if (L"style" == Ns && L"page-layout" == Name)
|
|
{
|
|
CP_CREATE_ELEMENT(style_page_layout_);
|
|
}
|
|
else
|
|
{
|
|
styles_.create_child_element(Ns, Name, getContext());
|
|
}
|
|
}
|
|
|
|
void office_automatic_styles::add_child_element( const office_element_ptr & child)
|
|
{
|
|
if (!child)return;
|
|
|
|
ElementType type_ = child->get_type();
|
|
|
|
switch(type_)
|
|
{
|
|
case typeStylePageLayout:
|
|
style_page_layout_.push_back(child);
|
|
break;
|
|
default:
|
|
styles_.add_child_element(child, getContext());
|
|
break;
|
|
}
|
|
}
|
|
void office_automatic_styles::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
for (size_t i = 0; i < style_page_layout_.size(); i++)
|
|
{
|
|
style_page_layout_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
styles_.serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
// office:master-styles
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void style_master_page_attlist::serialize(CP_ATTR_NODE)
|
|
{
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"style:name", style_name_);
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"style:display-name", style_display_name_);
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"style:page-layout-name", style_page_layout_name_);
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"draw:style-name", draw_style_name_);
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"style:next-style-name", style_next_style_name_);
|
|
}
|
|
|
|
|
|
const wchar_t * office_master_styles::ns = L"office";
|
|
const wchar_t * office_master_styles::name = L"master-styles";
|
|
|
|
void office_master_styles::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
if (L"style" == Ns && L"master-page" == Name)
|
|
CP_CREATE_ELEMENT(style_master_page_);
|
|
else if (L"style" == Ns && L"handout-master" == Name)
|
|
CP_CREATE_ELEMENT(style_handout_master_);
|
|
else if (L"style" == Ns && L"draw-layer-set" == Name)
|
|
CP_CREATE_ELEMENT(draw_layer_set_);
|
|
else
|
|
{
|
|
CP_NOT_APPLICABLE_ELM();
|
|
}
|
|
}
|
|
|
|
void office_master_styles::add_child_element( const office_element_ptr & child)
|
|
{
|
|
if (!child)return;
|
|
|
|
ElementType type_ = child->get_type();
|
|
|
|
switch(type_)
|
|
{
|
|
case typeStyleMasterPage:
|
|
style_master_page_.push_back(child);
|
|
break;
|
|
case typeStyleHandoutMasterPage:
|
|
style_handout_master_ = child;
|
|
break;
|
|
case typeStyleDrawLayerSet:
|
|
draw_layer_set_ = child;
|
|
break;
|
|
}
|
|
}
|
|
void office_master_styles::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
if (draw_layer_set_)
|
|
draw_layer_set_->serialize(CP_XML_STREAM());
|
|
|
|
for (size_t i = 0; i < style_master_page_.size(); i++)
|
|
{
|
|
style_master_page_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
if (style_handout_master_)
|
|
style_handout_master_->serialize(CP_XML_STREAM());
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
// office:styles
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * office_styles::ns = L"office";
|
|
const wchar_t * office_styles::name = L"styles";
|
|
|
|
void office_styles::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
if (CP_CHECK_NAME(L"style", L"style") ||
|
|
CP_CHECK_NAME(L"text", L"list-style") ||
|
|
CP_CHECK_NAME(L"number", L"number-style") ||
|
|
CP_CHECK_NAME(L"number", L"currency-style") ||
|
|
CP_CHECK_NAME(L"number", L"text-style") ||
|
|
CP_CHECK_NAME(L"number", L"percentage-style") ||
|
|
CP_CHECK_NAME(L"number", L"date-style") ||
|
|
CP_CHECK_NAME(L"number", L"boolean-style")
|
|
)
|
|
{
|
|
styles_.create_child_element( Ns, Name, getContext());
|
|
}
|
|
else if (L"style" == Ns && L"default-style" == Name)
|
|
CP_CREATE_ELEMENT(style_default_style_);
|
|
|
|
else if (L"style" == Ns && L"presentation-page-layout" == Name)
|
|
CP_CREATE_ELEMENT(style_presentation_page_layout_);
|
|
|
|
else if(CP_CHECK_NAME(L"draw", L"gradient") ||
|
|
CP_CHECK_NAME(L"draw", L"fill-image") ||
|
|
CP_CHECK_NAME(L"draw", L"hatch") ||
|
|
CP_CHECK_NAME(L"draw", L"marker") ||
|
|
CP_CHECK_NAME(L"draw", L"opacity") ||
|
|
CP_CHECK_NAME(L"draw", L"stroke-dash") ||
|
|
CP_CHECK_NAME(L"svg", L"linearGradient") ||
|
|
CP_CHECK_NAME(L"svg", L"radialGradient")
|
|
)
|
|
{
|
|
draw_styles_.create_child_element( Ns, Name, getContext());
|
|
}
|
|
else if(CP_CHECK_NAME(L"table", L"table-template"))
|
|
{
|
|
templates_.create_child_element( Ns, Name, getContext());
|
|
}
|
|
else if (L"text" == Ns && L"outline-style" == Name)
|
|
CP_CREATE_ELEMENT(text_outline_style_);
|
|
else if (L"text" == Ns && L"notes-configuration" == Name)
|
|
CP_CREATE_ELEMENT(text_notes_configuration_);
|
|
else if (L"text" == Ns && L"bibliography-configuration" == Name)
|
|
CP_CREATE_ELEMENT(text_bibliography_configuration_);
|
|
else if (L"text" == Ns && L"linenumbering-configuration" == Name)
|
|
CP_CREATE_ELEMENT(text_linenumbering_configuration_);
|
|
else
|
|
{
|
|
CP_NOT_APPLICABLE_ELM();
|
|
}
|
|
}
|
|
void office_styles::add_child_element( const office_element_ptr & child)
|
|
{
|
|
if (!child)return;
|
|
|
|
ElementType type_ = child->get_type();
|
|
|
|
switch(type_)
|
|
{
|
|
case typeStyleStyle:
|
|
case typeTextListStyle:
|
|
|
|
case typeNumberTimeStyle:
|
|
case typeNumberDataStyle:
|
|
case typeNumberPercentageStyle:
|
|
case typeNumberCurrencyStyle:
|
|
case typeNumberNumberStyle:
|
|
styles_.add_child_element(child, getContext());
|
|
break;
|
|
case typeStyleDrawGradient:
|
|
case typeStyleDrawHatch:
|
|
case typeStyleDrawFillImage:
|
|
case typeStyleDrawOpacity:
|
|
case typeStyleDrawMarker:
|
|
case typeStyleDrawStrokeDash:
|
|
draw_styles_.add_child_element(child, getContext());
|
|
break;
|
|
case typeStyleDefaultStyle:
|
|
style_default_style_.push_back(child);
|
|
break;
|
|
case typeStylePresentationPageLayout:
|
|
style_presentation_page_layout_.push_back(child);
|
|
break;
|
|
case typeTableTemplate:
|
|
templates_.add_child_element(child);
|
|
break;
|
|
case typeTextOutlineStyle:
|
|
text_outline_style_ = child;
|
|
break;
|
|
case typeTextNotesConfiguration:
|
|
text_notes_configuration_.push_back(child);
|
|
break;
|
|
case typeTextLinenumberingConfiguration:
|
|
text_linenumbering_configuration_.push_back(child);
|
|
break;
|
|
//....
|
|
}
|
|
}
|
|
void office_styles::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
for (size_t i = 0; i < style_default_style_.size(); i++)
|
|
{
|
|
style_default_style_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
|
|
draw_styles_.serialize(CP_XML_STREAM());
|
|
|
|
for (size_t i = 0; i < style_presentation_page_layout_.size(); i++)
|
|
{
|
|
style_presentation_page_layout_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
|
|
templates_.serialize(CP_XML_STREAM());
|
|
|
|
styles_.serialize(CP_XML_STREAM());
|
|
|
|
if (text_outline_style_)
|
|
text_outline_style_->serialize(CP_XML_STREAM());
|
|
|
|
for (size_t i = 0; i < text_notes_configuration_.size(); i++)
|
|
{
|
|
text_notes_configuration_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
for (size_t i = 0; i < text_linenumbering_configuration_.size(); i++)
|
|
{
|
|
text_linenumbering_configuration_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// style:header
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * style_header::ns = L"style";
|
|
const wchar_t * style_header::name = L"header";
|
|
|
|
void style_header::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
content().header_footer_content_.create_child_element( Ns, Name, getContext());
|
|
}
|
|
void style_header::add_child_element( const office_element_ptr & child)
|
|
{
|
|
content().header_footer_content_.add_child_element( child, getContext());
|
|
}
|
|
void style_header::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
content().header_footer_content_.serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * style_footer::ns = L"style";
|
|
const wchar_t * style_footer::name = L"footer";
|
|
|
|
void style_footer::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
content().header_footer_content_.create_child_element(Ns, Name, getContext());
|
|
}
|
|
void style_footer::add_child_element( const office_element_ptr & child)
|
|
{
|
|
content().header_footer_content_.add_child_element( child, getContext());
|
|
}
|
|
void style_footer::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
content().header_footer_content_.serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * style_header_first::ns = L"style";
|
|
const wchar_t * style_header_first::name = L"header-first";
|
|
|
|
void style_header_first::create_child_element(const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
content().header_footer_content_.create_child_element(Ns, Name, getContext());
|
|
}
|
|
void style_header_first::add_child_element( const office_element_ptr & child)
|
|
{
|
|
content().header_footer_content_.add_child_element(child, getContext());
|
|
}
|
|
void style_header_first::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
content().header_footer_content_.serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * style_footer_first::ns = L"style";
|
|
const wchar_t * style_footer_first::name = L"footer-first";
|
|
|
|
void style_footer_first::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
content().header_footer_content_.create_child_element( Ns, Name, getContext());
|
|
}
|
|
void style_footer_first::add_child_element( const office_element_ptr & child)
|
|
{
|
|
content().header_footer_content_.add_child_element( child, getContext());
|
|
}
|
|
void style_footer_first::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
content().header_footer_content_.serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * style_header_left::ns = L"style";
|
|
const wchar_t * style_header_left::name = L"header-left";
|
|
|
|
void style_header_left::create_child_element(const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
content().header_footer_content_.create_child_element( Ns, Name, getContext());
|
|
}
|
|
void style_header_left::add_child_element( const office_element_ptr & child)
|
|
{
|
|
content().header_footer_content_.add_child_element( child, getContext());
|
|
}
|
|
|
|
void style_header_left::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
content().header_footer_content_.serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * style_footer_left::ns = L"style";
|
|
const wchar_t * style_footer_left::name = L"footer-left";
|
|
|
|
void style_footer_left::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
content().header_footer_content_.create_child_element( Ns, Name, getContext());
|
|
}
|
|
void style_footer_left::add_child_element( const office_element_ptr & child)
|
|
{
|
|
content().header_footer_content_.add_child_element(child, getContext());
|
|
}
|
|
void style_footer_left::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
content().header_footer_content_.serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
|
|
/// style:header-style
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * style_header_style::ns = L"style";
|
|
const wchar_t * style_header_style::name = L"header-style";
|
|
|
|
void style_header_style::create_child_element(const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
if (L"style" == Ns && L"header-footer-properties" == Name)
|
|
{
|
|
CP_CREATE_ELEMENT(style_header_footer_properties_);
|
|
}
|
|
else
|
|
{
|
|
CP_NOT_APPLICABLE_ELM();
|
|
}
|
|
}
|
|
void style_header_style::add_child_element( const office_element_ptr & child)
|
|
{
|
|
if (!child)return;
|
|
|
|
ElementType type_ = child->get_type();
|
|
|
|
if (type_ == typeStyleHeaderFooterProperties)
|
|
style_header_footer_properties_ = child;
|
|
|
|
}
|
|
void style_header_style::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
if (style_header_footer_properties_) style_header_footer_properties_->serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
/// style:footer-style
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * style_footer_style::ns = L"style";
|
|
const wchar_t * style_footer_style::name = L"footer-style";
|
|
|
|
void style_footer_style::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
if (L"style" == Ns && L"header-footer-properties" == Name)
|
|
{
|
|
CP_CREATE_ELEMENT(style_header_footer_properties_);
|
|
}
|
|
else
|
|
{
|
|
CP_NOT_APPLICABLE_ELM();
|
|
}
|
|
}
|
|
void style_footer_style::add_child_element( const office_element_ptr & child)
|
|
{
|
|
if (!child)return;
|
|
|
|
ElementType type_ = child->get_type();
|
|
|
|
if (type_ == typeStyleHeaderFooterProperties)
|
|
style_header_footer_properties_ = child;
|
|
|
|
}
|
|
void style_footer_style::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
if (style_header_footer_properties_) style_header_footer_properties_->serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
/// style:page-layout
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void style_page_layout_attlist::serialize(CP_ATTR_NODE)
|
|
{
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"style:name", style_name_);
|
|
CP_XML_ATTR_OPT(L"style:page-usage", style_page_usage_);
|
|
}
|
|
const wchar_t * style_page_layout::ns = L"style";
|
|
const wchar_t * style_page_layout::name = L"page-layout";
|
|
|
|
void style_page_layout::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
if (L"style" == Ns && L"header-style" == Name)
|
|
{
|
|
CP_CREATE_ELEMENT(style_header_style_);
|
|
}
|
|
else if (L"style" == Ns && L"footer-style" == Name)
|
|
{
|
|
CP_CREATE_ELEMENT(style_footer_style_);
|
|
}
|
|
else if (L"style" == Ns && L"page-layout-properties" == Name)
|
|
{
|
|
CP_CREATE_ELEMENT(style_page_layout_properties_);
|
|
}
|
|
else
|
|
{
|
|
CP_NOT_APPLICABLE_ELM();
|
|
}
|
|
}
|
|
void style_page_layout::add_child_element( const office_element_ptr & child)
|
|
{
|
|
if (!child)return;
|
|
|
|
ElementType type_ = child->get_type();
|
|
|
|
switch(type_)
|
|
{
|
|
case typeStyleHeaderStyle:
|
|
style_header_style_ = child;
|
|
break;
|
|
case typeStyleFooterStyle:
|
|
style_footer_style_ = child;
|
|
break;
|
|
case typeStylePageLayout:
|
|
style_page_layout_properties_ = child;
|
|
break;
|
|
}
|
|
}
|
|
void style_page_layout::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
style_page_layout_attlist_.serialize( CP_GET_XML_NODE());
|
|
|
|
if (style_page_layout_properties_) style_page_layout_properties_->serialize(CP_XML_STREAM());
|
|
if (style_header_style_) style_header_style_->serialize(CP_XML_STREAM());
|
|
if (style_footer_style_) style_footer_style_->serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
/// style:footnote-sep
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void style_footnote_sep_attlist::serialize(CP_ATTR_NODE)
|
|
{
|
|
CP_XML_ATTR_OPT(L"style:width", style_width_);
|
|
CP_XML_ATTR_OPT(L"style:rel-width", style_rel_width_);
|
|
CP_XML_ATTR_OPT(L"style:color", style_color_);
|
|
CP_XML_ATTR_OPT(L"style:line-style", style_line_style_);
|
|
CP_XML_ATTR_OPT(L"style:type", style_adjustment_); // default Left
|
|
CP_XML_ATTR_OPT(L"style:distance-before-sep", style_distance_before_sep_);
|
|
CP_XML_ATTR_OPT(L"style:distance-after-sep", style_distance_after_sep_);
|
|
}
|
|
|
|
const wchar_t * style_footnote_sep::ns = L"style";
|
|
const wchar_t * style_footnote_sep::name = L"footnote-sep";
|
|
|
|
void style_footnote_sep::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
CP_NOT_APPLICABLE_ELM();
|
|
}
|
|
void style_footnote_sep::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
style_footnote_sep_attlist_.serialize(CP_GET_XML_NODE());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// style:master-page
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * style_master_page::ns = L"style";
|
|
const wchar_t * style_master_page::name = L"master-page";
|
|
|
|
void style_master_page::create_child_element(const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
if (L"style" == Ns && L"header" == Name)
|
|
CP_CREATE_ELEMENT(style_header_);
|
|
else if (L"style" == Ns && L"header-first" == Name)
|
|
CP_CREATE_ELEMENT(style_header_first_);
|
|
else if (L"style" == Ns && L"header-left" == Name)
|
|
CP_CREATE_ELEMENT(style_header_left_);
|
|
|
|
else if (L"style" == Ns && L"footer" == Name)
|
|
CP_CREATE_ELEMENT(style_footer_);
|
|
else if (L"style" == Ns && L"footer-first" == Name)
|
|
CP_CREATE_ELEMENT(style_footer_first_);
|
|
else if (L"style" == Ns && L"footer-left" == Name)
|
|
CP_CREATE_ELEMENT(style_footer_left_);
|
|
|
|
else if (L"office" == Ns && L"forms" == Name)
|
|
CP_CREATE_ELEMENT(office_forms_);
|
|
else if (L"style" == Ns && L"style" == Name)
|
|
CP_CREATE_ELEMENT(style_style_);
|
|
else if (L"presentation" == Ns && L"notes" == Name)
|
|
CP_CREATE_ELEMENT(presentation_notes_);
|
|
else
|
|
{
|
|
CP_CREATE_ELEMENT(content_);
|
|
}
|
|
}
|
|
|
|
void style_master_page::add_child_element( const office_element_ptr & child)
|
|
{
|
|
if (!child)return;
|
|
|
|
ElementType type_ = child->get_type();
|
|
switch(type_)
|
|
{
|
|
case typeStyleHeader:
|
|
style_header_ = child;
|
|
break;
|
|
case typeStyleHeaderFirst:
|
|
style_header_first_ = child;
|
|
break;
|
|
case typeStyleHeaderLeft:
|
|
style_header_left_ = child;
|
|
break;
|
|
case typeStyleFooter:
|
|
style_footer_ = child;
|
|
break;
|
|
case typeStyleFooterFirst:
|
|
style_footer_first_ = child;
|
|
break;
|
|
case typeStyleFooterLeft:
|
|
style_footer_left_ = child;
|
|
break;
|
|
case typeOfficeForms:
|
|
office_forms_ = child;
|
|
break;
|
|
case typePresentationNotes:
|
|
presentation_notes_ = child;
|
|
case typeStyleStyle:
|
|
style_style_.push_back(child);
|
|
break;
|
|
default:
|
|
content_.push_back(child);
|
|
break;
|
|
}
|
|
}
|
|
void style_master_page::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
attlist_.serialize( CP_GET_XML_NODE());
|
|
|
|
if (style_footer_) style_footer_->serialize(CP_XML_STREAM());
|
|
if (style_header_) style_header_->serialize(CP_XML_STREAM());
|
|
|
|
if (style_header_left_) style_header_left_->serialize(CP_XML_STREAM());
|
|
if (style_header_first_) style_header_first_->serialize(CP_XML_STREAM());
|
|
|
|
if (style_footer_left_) style_footer_left_->serialize(CP_XML_STREAM());
|
|
if (style_footer_first_) style_footer_first_->serialize(CP_XML_STREAM());
|
|
|
|
if (office_forms_) office_forms_->serialize(CP_XML_STREAM());
|
|
|
|
for (size_t i = 0; i < style_style_.size(); i++)
|
|
{
|
|
style_style_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
for (size_t i = 0; i < content_.size(); i++)
|
|
{
|
|
content_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
int style_master_page::find_placeHolderIndex(presentation_class::type placeHolder,int & last_idx)
|
|
{
|
|
int idx = -1;
|
|
|
|
//int i=0;
|
|
//int size = content_.size();
|
|
//
|
|
//while(true)
|
|
// {
|
|
// if (i>=size)break;
|
|
// if (content_[i]->get_type() == odf_writer::typeDrawFrame)
|
|
// {
|
|
// draw_frame* frame = dynamic_cast<draw_frame *>(content_[i].get());
|
|
|
|
// if (frame->idx_in_owner<0)frame->idx_in_owner = last_idx++;
|
|
|
|
// if ((frame) && (frame->common_presentation_attlist_.presentation_class_) &&
|
|
// (frame->common_presentation_attlist_.presentation_class_->get_type()== placeHolder))
|
|
// {
|
|
// idx = frame->idx_in_owner;
|
|
// break;
|
|
// }
|
|
// }
|
|
// i++;
|
|
// }
|
|
return idx;
|
|
}
|
|
|
|
/// text:notes-configuration
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * text_notes_configuration::ns = L"text";
|
|
const wchar_t * text_notes_configuration::name = L"notes-configuration";
|
|
|
|
void text_notes_configuration::create_child_element(const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
if CP_CHECK_NAME(L"text", L"note-continuation-notice-forward")
|
|
CP_CREATE_ELEMENT(text_note_continuation_notice_forward_);
|
|
else if CP_CHECK_NAME(L"text", L"note-continuation-notice-backward")
|
|
CP_CREATE_ELEMENT(text_note_continuation_notice_backward_);
|
|
else
|
|
CP_NOT_APPLICABLE_ELM();
|
|
}
|
|
// text:linenumbering-configuration
|
|
//-------------------------------------------------------------------------------------------------------
|
|
const wchar_t * text_linenumbering_configuration::ns = L"text";
|
|
const wchar_t * text_linenumbering_configuration::name = L"linenumbering-configuration";
|
|
|
|
void text_linenumbering_configuration::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
CP_XML_ATTR_OPT(L"text:style-name", text_style_name_);
|
|
if (false == text_number_lines_)
|
|
{
|
|
CP_XML_ATTR(L"text:number-lines", text_number_lines_);
|
|
}
|
|
CP_XML_ATTR_OPT(L"style:num-format", style_num_format_);
|
|
CP_XML_ATTR_OPT(L"style:num-letter-sync", style_num_letter_sync_);
|
|
CP_XML_ATTR_OPT(L"text:count-empty-lines", text_count_empty_lines_);
|
|
CP_XML_ATTR_OPT(L"text:count-in-text-boxes", text_count_in_text_boxes_);
|
|
CP_XML_ATTR_OPT(L"text:increment", text_increment_);
|
|
CP_XML_ATTR_OPT(L"text:start", text_start_);
|
|
CP_XML_ATTR_OPT(L"text:number-position", text_number_position_); //inner, left, outer, right
|
|
CP_XML_ATTR_OPT(L"text:offset", text_offset_);
|
|
CP_XML_ATTR_OPT(L"text:restart-on-page", text_restart_on_page_);
|
|
|
|
if (text_linenumbering_separator_)
|
|
text_linenumbering_separator_->serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
void text_linenumbering_configuration::create_child_element(const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
if CP_CHECK_NAME(L"text", L"linenumbering-separator")
|
|
CP_CREATE_ELEMENT(text_linenumbering_separator_);
|
|
}
|
|
|
|
// text:linenumbering-separator
|
|
//-------------------------------------------------------------------------------------------------------
|
|
const wchar_t * text_linenumbering_separator::ns = L"text";
|
|
const wchar_t * text_linenumbering_separator::name = L"linenumbering-separator";
|
|
|
|
void text_linenumbering_separator::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
CP_XML_ATTR_OPT(L"text:increment", text_increment_);
|
|
|
|
if (text_)
|
|
{
|
|
CP_XML_STREAM() << *text_;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// style:presentation-page-layout
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * style_presentation_page_layout::ns = L"style";
|
|
const wchar_t * style_presentation_page_layout::name = L"presentation-page-layout";
|
|
|
|
void style_presentation_page_layout::create_child_element( const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
if (L"presentation" == Ns && L"placeholder" == Name)
|
|
{
|
|
CP_CREATE_ELEMENT(content_);
|
|
}
|
|
else
|
|
{
|
|
CP_NOT_APPLICABLE_ELM();
|
|
}
|
|
}
|
|
|
|
void style_presentation_page_layout::add_child_element( const office_element_ptr & child)
|
|
{
|
|
content_.push_back(child);
|
|
}
|
|
|
|
void style_presentation_page_layout::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"style:name", style_name_);
|
|
|
|
for (size_t i = 0; i < content_.size(); i++)
|
|
{
|
|
content_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//-------------------------------------------------------------------------------------------------
|
|
const wchar_t * office_font_face_decls::ns = L"office";
|
|
const wchar_t * office_font_face_decls::name = L"font-face-decls";
|
|
|
|
void office_font_face_decls::add_child_element( const office_element_ptr & child)
|
|
{
|
|
content_.push_back(child);
|
|
}
|
|
void office_font_face_decls::create_child_element(const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
if CP_CHECK_NAME(L"style", L"font-face")
|
|
{
|
|
CP_CREATE_ELEMENT(content_);
|
|
}
|
|
}
|
|
void office_font_face_decls::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
for (size_t i = 0; i < content_.size(); i++)
|
|
{
|
|
content_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const wchar_t * style_font_face::ns = L"style";
|
|
const wchar_t * style_font_face::name = L"font-face";
|
|
|
|
void style_font_face::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
CP_XML_ATTR_OPT_ENCODE_STRING(L"style:name", style_name_);
|
|
CP_XML_ATTR_OPT(L"style:font-adornments", style_font_adornments_);
|
|
CP_XML_ATTR_OPT(L"style:font-family-generic", style_font_family_generic_);
|
|
CP_XML_ATTR_OPT(L"style:font-pitch", style_font_pitch_);
|
|
CP_XML_ATTR_OPT(L"style:font-charset", style_font_charset_);
|
|
|
|
CP_XML_ATTR_OPT(L"svg:font-family", svg_font_family_);
|
|
CP_XML_ATTR_OPT(L"svg:font-style", svg_font_style_);
|
|
CP_XML_ATTR_OPT(L"svg:font-variant", svg_font_variant_);
|
|
CP_XML_ATTR_OPT(L"svg:font-weight", svg_font_weight_);
|
|
CP_XML_ATTR_OPT(L"svg:font-stretch", svg_font_stretch_);
|
|
CP_XML_ATTR_OPT(L"svg:font-size", svg_font_size_);
|
|
CP_XML_ATTR_OPT(L"svg:unicode-range", svg_unicode_range_);
|
|
CP_XML_ATTR_OPT(L"svg:units-per-em", svg_units_per_em_);
|
|
CP_XML_ATTR_OPT(L"svg:panose-1", svg_panose_1_);
|
|
CP_XML_ATTR_OPT(L"svg:stemv", svg_stemv_);
|
|
CP_XML_ATTR_OPT(L"svg:stemh", svg_stemh_);
|
|
CP_XML_ATTR_OPT(L"svg:slope", svg_slope_);
|
|
CP_XML_ATTR_OPT(L"svg:cap-height", svg_cap_height_);
|
|
CP_XML_ATTR_OPT(L"svg:x-height", svg_x_height_);
|
|
CP_XML_ATTR_OPT(L"svg:accent-height", svg_accent_height_);
|
|
CP_XML_ATTR_OPT(L"svg:ascent", svg_ascent_);
|
|
CP_XML_ATTR_OPT(L"svg:descent", svg_descent_);
|
|
CP_XML_ATTR_OPT(L"svg:widths", svg_widths_);
|
|
CP_XML_ATTR_OPT(L"svg:bbox", svg_bbox_);
|
|
CP_XML_ATTR_OPT(L"svg:ideographic", svg_ideographic_);
|
|
CP_XML_ATTR_OPT(L"svg:alphabetic", svg_alphabetic_);
|
|
CP_XML_ATTR_OPT(L"svg:mathematical", svg_mathematical_);
|
|
CP_XML_ATTR_OPT(L"svg:hanging", svg_hanging_);
|
|
CP_XML_ATTR_OPT(L"svg:v-ideographic", svg_v_ideographic_);
|
|
CP_XML_ATTR_OPT(L"svg:v-alphabetic", svg_v_alphabetic_);
|
|
CP_XML_ATTR_OPT(L"svg:v-mathematical", svg_v_mathematical_);
|
|
CP_XML_ATTR_OPT(L"svg:v-hanging", svg_v_hanging_);
|
|
CP_XML_ATTR_OPT(L"svg:underline-position", svg_underline_position_);
|
|
CP_XML_ATTR_OPT(L"svg:underline-thickness", svg_underline_thickness_);
|
|
CP_XML_ATTR_OPT(L"svg:strikethrough-position", svg_strikethrough_position_);
|
|
CP_XML_ATTR_OPT(L"svg:strikethrough-thickness", svg_strikethrough_thickness_);
|
|
CP_XML_ATTR_OPT(L"svg:overline-position", svg_overline_position_);
|
|
CP_XML_ATTR_OPT(L"svg:overline-thickness", svg_overline_thickness_);
|
|
}
|
|
}
|
|
}
|
|
// style:region-left
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * style_region_left::ns = L"style";
|
|
const wchar_t * style_region_left::name = L"region-left";
|
|
|
|
void style_region_left::add_child_element( const office_element_ptr & child)
|
|
{
|
|
content_.push_back(child);
|
|
}
|
|
void style_region_left::create_child_element(const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
CP_CREATE_ELEMENT(content_);
|
|
}
|
|
void style_region_left::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
for (size_t i = 0; i < content_.size(); i++)
|
|
{
|
|
content_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// style:region-right
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * style_region_right::ns = L"style";
|
|
const wchar_t * style_region_right::name = L"region-right";
|
|
|
|
void style_region_right::add_child_element( const office_element_ptr & child)
|
|
{
|
|
content_.push_back(child);
|
|
}
|
|
void style_region_right::create_child_element(const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
CP_CREATE_ELEMENT(content_);
|
|
}
|
|
void style_region_right::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
for (size_t i = 0; i < content_.size(); i++)
|
|
{
|
|
content_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// style:region-center
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const wchar_t * style_region_center::ns = L"style";
|
|
const wchar_t * style_region_center::name = L"region-center";
|
|
|
|
void style_region_center::add_child_element( const office_element_ptr & child)
|
|
{
|
|
content_.push_back(child);
|
|
}
|
|
void style_region_center::create_child_element(const std::wstring & Ns, const std::wstring & Name)
|
|
{
|
|
CP_CREATE_ELEMENT(content_);
|
|
}
|
|
void style_region_center::serialize(std::wostream & strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
for (size_t i = 0; i < content_.size(); i++)
|
|
{
|
|
content_[i]->serialize(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//--------------------------------------------------------------------------------------------------
|
|
const wchar_t* loext_gradient_stop::ns = L"loext";
|
|
const wchar_t* loext_gradient_stop::name = L"gradient-stop";
|
|
|
|
void loext_gradient_stop::serialize(std::wostream& strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
CP_XML_ATTR_OPT(L"loext:color-type", color_type_);
|
|
CP_XML_ATTR_OPT(L"loext:color-value", color_value_);
|
|
CP_XML_ATTR_OPT(L"svg:offset", svg_offset_);
|
|
}
|
|
}
|
|
}
|
|
//--------------------------------------------------------------------------------------------------
|
|
const wchar_t* loext_opacity_stop::ns = L"loext";
|
|
const wchar_t* loext_opacity_stop::name = L"opacity-stop";
|
|
|
|
void loext_opacity_stop::serialize(std::wostream& strm)
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE_SIMPLE()
|
|
{
|
|
CP_XML_ATTR_OPT(L"svg:stop-opacity", stop_opacity_);
|
|
CP_XML_ATTR_OPT(L"svg:offset", svg_offset_);
|
|
|
|
//CP_XML_ATTR_OPT(L"loext:stop-opacity", stop_opacity_); //??
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|