mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-02-10 18:05:41 +08:00
1036 lines
34 KiB
C++
1036 lines
34 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
|
|
*
|
|
*/
|
|
#pragma once
|
|
|
|
#include <iosfwd>
|
|
#include <vector>
|
|
#include <CPOptional.h>
|
|
#include <CPWeakPtr.h>
|
|
#include <xml/nodetype.h>
|
|
|
|
#include "office_elements_create.h"
|
|
|
|
#include "../../DataTypes/targetframename.h"
|
|
#include "../../DataTypes/noteclass.h"
|
|
#include "../../DataTypes/bibliography.h"
|
|
#include "../../DataTypes/referenceformat.h"
|
|
|
|
#include "../../DataTypes/common_attlists.h"
|
|
|
|
namespace cpdoccore {
|
|
namespace odf_writer {
|
|
|
|
// simple text
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_text : public office_element_impl<text_text>
|
|
{
|
|
public:
|
|
static office_element_ptr create(const std::wstring & Text);
|
|
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
static const ElementType type = typeTextText;
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element( const office_element_ptr & child_element){}
|
|
|
|
virtual std::wostream & text_to_stream(std::wostream & _Wostream, bool bXmlEncode = true) const;
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
text_text(const std::wstring & Text) : text_(Text) {}
|
|
text_text() {}
|
|
|
|
std::wstring & attr_text() { return text_; }
|
|
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
std::wstring text_;
|
|
|
|
};
|
|
|
|
// text:s
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_s : public office_element_impl<text_s>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextS;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
text_s(unsigned int c) : text_c_(c) {};
|
|
text_s() {};
|
|
|
|
_CP_OPT(unsigned int) text_c_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_s);
|
|
|
|
// text:tab
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_tab : public office_element_impl<text_tab>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextTab;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
text_tab(unsigned int ab_ref) : text_tab_ref_(ab_ref) {};
|
|
text_tab() {};
|
|
|
|
_CP_OPT(unsigned int) attr_tab_ref() const { return text_tab_ref_; }
|
|
|
|
_CP_OPT(unsigned int) text_tab_ref_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_tab);
|
|
|
|
// text:line-break
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_line_break : public office_element_impl<text_line_break>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextLineBreak;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
text_line_break() {};
|
|
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_line_break);
|
|
|
|
// text:bookmark
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_bookmark : public office_element_impl<text_bookmark>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextBookmark;
|
|
|
|
text_bookmark() {}
|
|
text_bookmark(const std::wstring & Name) : text_name_(Name){};
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
std::wstring text_name_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_bookmark);
|
|
|
|
// text:bookmark-start
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_bookmark_start : public office_element_impl<text_bookmark_start>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextBookmarkStart;
|
|
|
|
text_bookmark_start() {}
|
|
text_bookmark_start(const std::wstring & Name) : text_name_(Name){};
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
std::wstring text_name_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_bookmark_start);
|
|
|
|
// text:bookmark-end
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_bookmark_end : public office_element_impl<text_bookmark_end>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextBookmarkEnd;
|
|
|
|
text_bookmark_end() {} ;
|
|
text_bookmark_end(const std::wstring & Name) : text_name_(Name){};
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
std::wstring text_name_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_bookmark_end);
|
|
//-------------------------------------------------------------------------------------------------------------------
|
|
// text:bookmark-ref
|
|
//-------------------------------------------------------------------------------------------------------------------
|
|
class text_bookmark_ref : public office_element_impl<text_bookmark_ref>
|
|
{
|
|
public:
|
|
static const wchar_t* ns;
|
|
static const wchar_t* name;
|
|
|
|
static const ElementType type = typeTextBookmarkRef;
|
|
|
|
text_bookmark_ref() {};
|
|
text_bookmark_ref(const std::wstring& Name) : ref_name_(Name) {};
|
|
|
|
virtual void create_child_element(const std::wstring& Ns, const std::wstring& Name);
|
|
virtual void add_child_element(const office_element_ptr& child_element);
|
|
virtual void add_text(const std::wstring& Text);
|
|
|
|
virtual void serialize(std::wostream& _Wostream);
|
|
|
|
_CP_OPT(std::wstring) ref_name_;
|
|
_CP_OPT(odf_types::reference_format) reference_format_;
|
|
|
|
_CP_OPT(std::wstring) text_;
|
|
office_element_ptr_array content_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_bookmark_ref);
|
|
// text:reference-mark
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_reference_mark : public office_element_impl<text_reference_mark>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextReferenceMark;
|
|
|
|
text_reference_mark() {};
|
|
text_reference_mark(const std::wstring & Name) : text_name_(Name){};
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
std::wstring text_name_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_reference_mark);
|
|
|
|
// text:reference-mark-start
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_reference_mark_start : public office_element_impl<text_reference_mark_start>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextReferenceMarkStart;
|
|
|
|
text_reference_mark_start() {}
|
|
text_reference_mark_start(const std::wstring & Name) : text_name_(Name){}
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
std::wstring text_name_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_reference_mark_start);
|
|
|
|
// text:reference-mark-end
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_reference_mark_end : public office_element_impl<text_reference_mark_end>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextReferenceMarkEnd;
|
|
|
|
text_reference_mark_end() {};
|
|
text_reference_mark_end(const std::wstring & Name) : text_name_(Name){};
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
std::wstring text_name_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_reference_mark_end);
|
|
|
|
// text:span
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_span : public office_element_impl<text_span>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextSpan;
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
virtual std::wostream & text_to_stream(std::wostream & _Wostream, bool bXmlEncode = true) const;
|
|
|
|
text_span() {}
|
|
|
|
office_element_ptr_array content_;
|
|
|
|
_CP_OPT(std::wstring) text_style_name_;//ваще то это такой элемент где стиль должОн быть всегда
|
|
std::vector<std::wstring> text_class_names_;
|
|
|
|
virtual void add_text(const std::wstring & Text);
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_span);
|
|
|
|
// text:a
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_a : public office_element_impl<text_a>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextA;
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
text_a() {}
|
|
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
odf_types::common_xlink_attlist common_xlink_attlist_;
|
|
|
|
_CP_OPT(std::wstring) office_name_;
|
|
_CP_OPT(odf_types::target_frame_name) office_target_frame_name_;
|
|
|
|
_CP_OPT(std::wstring) text_style_name_;
|
|
_CP_OPT(std::wstring) text_visited_style_name_;
|
|
|
|
office_element_ptr_array paragraph_content_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_a);
|
|
|
|
// text:note-citation
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_note_citation : public office_element_impl<text_note_citation>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextNoteCitation;
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
text_note_citation() {}
|
|
|
|
_CP_OPT(std::wstring) text_label_;
|
|
office_element_ptr_array content_;
|
|
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_note_citation);
|
|
|
|
// text:note-body
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_note_body : public office_element_impl<text_note_body>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextNoteBody;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
virtual void add_text(const std::wstring & Text){}
|
|
|
|
text_note_body() {}
|
|
|
|
office_element_ptr_array content_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_note_body);
|
|
|
|
|
|
// text:note
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_note : public office_element_impl<text_note>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextNote;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
text_note();
|
|
|
|
std::wstring text_id_;
|
|
odf_types::noteclass text_note_class_;
|
|
|
|
office_element_ptr text_note_citation_;
|
|
office_element_ptr text_note_body_;
|
|
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_note);
|
|
|
|
// text:ruby
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_ruby : public office_element_impl<text_ruby>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextRuby;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
std::wstring text_style_name_;
|
|
|
|
office_element_ptr text_ruby_base_;
|
|
office_element_ptr text_ruby_text_;
|
|
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_ruby);
|
|
|
|
class common_field_fixed_attlist
|
|
{
|
|
public:
|
|
|
|
_CP_OPT(odf_types::Bool) text_fixed_;
|
|
|
|
void serialize(CP_ATTR_NODE);
|
|
|
|
};
|
|
|
|
// text:title
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_title : public office_element_impl<text_title>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextTitle;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
common_field_fixed_attlist common_field_fixed_attlist_;
|
|
office_element_ptr_array content_;
|
|
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_title);
|
|
|
|
// text:placeholder
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_placeholder : public office_element_impl<text_placeholder>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextPlaceholder;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
office_element_ptr_array content_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_placeholder);
|
|
|
|
// text:page-number
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_page_number: public office_element_impl<text_page_number>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextPageNumber;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
odf_types::common_num_format_attlist common_num_format_attlist_;
|
|
common_field_fixed_attlist common_field_fixed_attlist_;
|
|
|
|
_CP_OPT(int) text_page_adjust_;
|
|
_CP_OPT(std::wstring) text_select_page_;
|
|
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
office_element_ptr_array text_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_page_number);
|
|
|
|
// text:page-count
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_page_count : public office_element_impl<text_page_count>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextPageCount;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
common_field_fixed_attlist common_field_fixed_attlist_;
|
|
|
|
office_element_ptr_array text_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_page_count);
|
|
|
|
// text:date
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_date : public office_element_impl<text_date>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextDate;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
common_field_fixed_attlist common_field_fixed_attlist_;
|
|
|
|
_CP_OPT(std::wstring) style_data_style_name_;
|
|
_CP_OPT(std::wstring) text_date_value_;//with format
|
|
|
|
office_element_ptr_array text_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_date);
|
|
|
|
// text:time
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_time : public office_element_impl<text_time>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextTime;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
common_field_fixed_attlist common_field_fixed_attlist_;
|
|
|
|
_CP_OPT(std::wstring) style_data_style_name_;
|
|
_CP_OPT(std::wstring) text_time_value_;//with format
|
|
|
|
office_element_ptr_array text_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_time);
|
|
|
|
// text:file-name
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_file_name : public office_element_impl<text_file_name>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextFileName;
|
|
|
|
|
|
virtual void create_child_element (const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element ( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
common_field_fixed_attlist common_field_fixed_attlist_;
|
|
|
|
office_element_ptr_array text_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_file_name);
|
|
|
|
// text:sequence
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_sequence : public office_element_impl<text_sequence>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextSequence;
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
_CP_OPT(odf_types::style_numformat) style_num_format_;
|
|
_CP_OPT(std::wstring) style_num_letter_sync_;
|
|
_CP_OPT(std::wstring) formula_;
|
|
_CP_OPT(std::wstring) name_;
|
|
_CP_OPT(std::wstring) ref_name_;
|
|
|
|
_CP_OPT(std::wstring) template_;
|
|
office_element_ptr_array text_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_sequence);
|
|
|
|
// text:text-input
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_text_input : public office_element_impl<text_text_input>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextTextInput;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
_CP_OPT(std::wstring) text_description_;
|
|
office_element_ptr_array text_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_text_input);
|
|
|
|
// text:sheet-name
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_sheet_name : public office_element_impl<text_sheet_name>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextSheetName;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element( const office_element_ptr & child_element);
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
virtual void add_text(const std::wstring & Text);
|
|
|
|
office_element_ptr_array text_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_sheet_name);
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//presentation:footer
|
|
class presentation_footer : public office_element_impl<presentation_footer>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typePresentationFooter;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(presentation_footer);
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//presentation:date-time
|
|
class presentation_date_time: public office_element_impl<presentation_date_time>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typePresentationDateTime;
|
|
|
|
|
|
virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(presentation_date_time);
|
|
//---------------------------------------------------------------------------------------------------
|
|
//text:toc-mark-start
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_toc_mark_start : public office_element_impl<text_toc_mark_start>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextTocMarkStart;
|
|
|
|
|
|
virtual void create_child_element (const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element ( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
_CP_OPT(int) outline_level_;
|
|
std::wstring id_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_toc_mark_start);
|
|
//---------------------------------------------------------------------------------------------------
|
|
//text:toc-mark-end
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_toc_mark_end : public office_element_impl<text_toc_mark_end>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextTocMarkEnd;
|
|
|
|
|
|
virtual void create_child_element (const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element ( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
std::wstring id_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_toc_mark_end);
|
|
//---------------------------------------------------------------------------------------------------
|
|
//text:toc-mark
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_toc_mark : public office_element_impl<text_toc_mark>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextTocMark;
|
|
|
|
|
|
virtual void create_child_element (const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element ( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
_CP_OPT(std::wstring) string_value_;
|
|
_CP_OPT(int) outline_level_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_toc_mark);
|
|
//---------------------------------------------------------------------------------------------------
|
|
//text:alphabetical-index-mark-start
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_alphabetical_index_mark_start : public office_element_impl<text_alphabetical_index_mark_start>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextAlphabeticalIndexMarkStart;
|
|
|
|
|
|
virtual void create_child_element (const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element ( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
std::wstring id_;
|
|
_CP_OPT(std::wstring) key1_;
|
|
_CP_OPT(std::wstring) key1_phonetic_;
|
|
_CP_OPT(std::wstring) key2_;
|
|
_CP_OPT(std::wstring) key2_phonetic_;
|
|
_CP_OPT(odf_types::Bool) main_entry_;
|
|
_CP_OPT(std::wstring) string_value_phonetic_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_alphabetical_index_mark_start);
|
|
//---------------------------------------------------------------------------------------------------
|
|
//text:alphabetical-index-mark-end
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_alphabetical_index_mark_end : public office_element_impl<text_alphabetical_index_mark_end>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextAlphabeticalIndexMarkEnd;
|
|
|
|
|
|
virtual void create_child_element (const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element ( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
std::wstring id_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_alphabetical_index_mark_end);
|
|
//---------------------------------------------------------------------------------------------------
|
|
//text:alphabetical-index-mark
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_alphabetical_index_mark : public office_element_impl<text_alphabetical_index_mark>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextAlphabeticalIndexMark;
|
|
|
|
virtual void create_child_element (const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element ( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
_CP_OPT(std::wstring) key1_;
|
|
_CP_OPT(std::wstring) key1_phonetic_;
|
|
_CP_OPT(std::wstring) key2_;
|
|
_CP_OPT(std::wstring) key2_phonetic_;
|
|
_CP_OPT(odf_types::Bool) main_entry_;
|
|
_CP_OPT(std::wstring) string_value_;
|
|
_CP_OPT(std::wstring) string_value_phonetic_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_alphabetical_index_mark);
|
|
//---------------------------------------------------------------------------------------------------
|
|
//text:bibliography-mark
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_bibliography_mark : public office_element_impl<text_bibliography_mark>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextBibliographyMark;
|
|
|
|
virtual void create_child_element (const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element ( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
std::wstring identifier_;
|
|
odf_types::bibliography bibliography_type_;
|
|
|
|
_CP_OPT(std::wstring) url_;
|
|
_CP_OPT(std::wstring) author_;
|
|
_CP_OPT(std::wstring) title_;
|
|
_CP_OPT(std::wstring) year_;
|
|
_CP_OPT(std::wstring) isbn_;
|
|
_CP_OPT(std::wstring) chapter_;
|
|
_CP_OPT(std::wstring) address_;
|
|
_CP_OPT(std::wstring) annote_;
|
|
_CP_OPT(std::wstring) booktitle_;
|
|
_CP_OPT(std::wstring) edition_;
|
|
_CP_OPT(std::wstring) editor_;
|
|
_CP_OPT(std::wstring) howpublished_;
|
|
_CP_OPT(std::wstring) institution_;
|
|
_CP_OPT(std::wstring) issn_;
|
|
_CP_OPT(std::wstring) journal_;
|
|
_CP_OPT(std::wstring) month_;
|
|
_CP_OPT(std::wstring) note_;
|
|
_CP_OPT(std::wstring) number_;
|
|
_CP_OPT(std::wstring) organizations_;
|
|
_CP_OPT(std::wstring) pages_;
|
|
_CP_OPT(std::wstring) publisher_;
|
|
_CP_OPT(std::wstring) report_type_;
|
|
_CP_OPT(std::wstring) school_;
|
|
_CP_OPT(std::wstring) series_;
|
|
_CP_OPT(std::wstring) volume_;
|
|
|
|
_CP_OPT(std::wstring) content_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_bibliography_mark);
|
|
//-------------------------------------------------------------------------------------------------------------------
|
|
// text:sequence-ref
|
|
//-------------------------------------------------------------------------------------------------------------------
|
|
class text_sequence_ref : public office_element_impl<text_sequence_ref>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextSequenceRef;
|
|
|
|
virtual void create_child_element (const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element ( const office_element_ptr & child_element){}
|
|
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
_CP_OPT(odf_types::reference_format) reference_format_;
|
|
_CP_OPT(std::wstring) ref_name_;
|
|
|
|
std::wstring content_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_sequence_ref);
|
|
//-------------------------------------------------------------------------------------------------------------------
|
|
//text:drop-down
|
|
//-------------------------------------------------------------------------------------------------------------------
|
|
class text_drop_down : public office_element_impl<text_drop_down>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextDropDown;
|
|
|
|
virtual void create_child_element (const std::wstring & Ns, const std::wstring & Name);
|
|
virtual void add_child_element ( const office_element_ptr & child_element);
|
|
|
|
virtual void add_text(const std::wstring & Text);
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
_CP_OPT(std::wstring) text_name_;
|
|
office_element_ptr_array content_;
|
|
|
|
office_element_ptr text_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_drop_down);
|
|
//-------------------------------------------------------------------------------------------------------------------
|
|
//text:label
|
|
//-------------------------------------------------------------------------------------------------------------------
|
|
class text_label : public office_element_impl<text_label>
|
|
{
|
|
public:
|
|
static const wchar_t * ns;
|
|
static const wchar_t * name;
|
|
|
|
static const ElementType type = typeTextLabel;
|
|
|
|
virtual void create_child_element (const std::wstring & Ns, const std::wstring & Name){}
|
|
virtual void add_child_element ( const office_element_ptr & child_element){}
|
|
|
|
virtual void add_text(const std::wstring & Text);
|
|
virtual void serialize(std::wostream & _Wostream);
|
|
|
|
_CP_OPT(odf_types::Bool)text_current_selected_;
|
|
_CP_OPT(std::wstring) text_value_;
|
|
_CP_OPT(std::wstring) text_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_label);
|
|
//-------------------------------------------------------------------------------------------------------------------
|
|
//text:user-defined
|
|
//---------------------------------------------------------------------------------------------------
|
|
class text_user_defined : public office_element_impl<text_user_defined>
|
|
{
|
|
public:
|
|
static const wchar_t* ns;
|
|
static const wchar_t* name;
|
|
|
|
static const ElementType type = typeTextUserDefined;
|
|
|
|
virtual void create_child_element(const std::wstring& Ns, const std::wstring& Name) {}
|
|
virtual void add_child_element(const office_element_ptr& child_element);
|
|
|
|
virtual void add_text(const std::wstring& Text);
|
|
virtual void serialize(std::wostream& _Wostream);
|
|
|
|
std::wstring get_text_content();
|
|
|
|
_CP_OPT(std::wstring) style_data_style_name_;
|
|
_CP_OPT(std::wstring) text_name_;
|
|
_CP_OPT(odf_types::Bool) text_fixed_;
|
|
odf_types::common_value_and_type_attlist office_value_;
|
|
|
|
_CP_OPT(std::wstring) text_;
|
|
office_element_ptr_array content_;
|
|
};
|
|
CP_REGISTER_OFFICE_ELEMENT2(text_user_defined);
|
|
} // namespace odf_writer
|
|
} // namespace cpdoccore
|