400 lines
11 KiB
C++
400 lines
11 KiB
C++
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2023
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
|
|
#include "xlsx_drawings.h"
|
|
#include "xlsx_drawing.h"
|
|
|
|
#include <vector>
|
|
#include <xml/simple_xml_writer.h>
|
|
|
|
#include "oox_rels.h"
|
|
|
|
namespace cpdoccore {
|
|
namespace oox {
|
|
|
|
class xlsx_drawings::Impl
|
|
{
|
|
public:
|
|
void add(_xlsx_drawing & d, bool isInternal, std::wstring const & rid, std::wstring const & ref, _rels_type type, bool sheet_rel )//объект
|
|
{
|
|
if ( type == typeControlProps || type == typeComment)
|
|
{
|
|
vml_drawings_.push_back(d);
|
|
add (isInternal, rid, ref, type, sheet_rel, true);
|
|
}
|
|
else if (type == typeControl)
|
|
{
|
|
vml_drawings_.push_back(d);
|
|
add (isInternal, rid, ref, type, sheet_rel, true);
|
|
|
|
d.hidden = true;
|
|
drawings_.push_back(d);
|
|
}
|
|
else
|
|
{
|
|
drawings_.push_back(d);
|
|
add (isInternal, rid, ref, type, sheet_rel, false);
|
|
|
|
for (size_t i = 0; i < d.hlinks.size(); i++)
|
|
{
|
|
drawing_rels_.push_back(_rel(false, d.hlinks[i].hId, d.hlinks[i].hRef, typeHyperlink));
|
|
}
|
|
if (!d.action.hId.empty())
|
|
drawing_rels_.push_back(_rel(false, d.action.hId, d.action.hRef, d.action.typeRels));
|
|
}
|
|
}
|
|
void add( bool isInternal, std::wstring const & rid, std::wstring const & ref, _rels_type type, bool sheet_rel, bool vml_rel) //не объект
|
|
{
|
|
bool present = false;
|
|
|
|
if (type == typeHyperlink) isInternal = false;
|
|
|
|
if (sheet_rel)
|
|
{
|
|
for (size_t i = 0 ; i < xlsx_sheet_rels_.size(); i++)
|
|
{
|
|
if (xlsx_sheet_rels_[i].rid == rid && xlsx_sheet_rels_[i].ref == ref)
|
|
present = true;
|
|
}
|
|
if (!present)
|
|
xlsx_sheet_rels_.push_back (_rel(isInternal, rid, ref, type));
|
|
}
|
|
else if (vml_rel)
|
|
{
|
|
for (size_t i = 0 ; i < vml_drawing_rels_.size(); i++)
|
|
{
|
|
if (vml_drawing_rels_[i].rid == rid && vml_drawing_rels_[i].ref == ref)
|
|
present = true;
|
|
}
|
|
if (!present)
|
|
vml_drawing_rels_.push_back(_rel(isInternal, rid, ref, type));
|
|
}
|
|
else
|
|
{
|
|
for (size_t i = 0 ; i < drawing_rels_.size(); i++)
|
|
{
|
|
if (drawing_rels_[i].rid == rid && drawing_rels_[i].ref == ref)
|
|
present = true;
|
|
}
|
|
if (!present)
|
|
drawing_rels_.push_back(_rel(isInternal, rid, ref, type));
|
|
}
|
|
}
|
|
|
|
void serialize(std::wostream & strm, const std::wstring & ns, bool local)
|
|
{
|
|
if (drawings_.empty()) return;
|
|
|
|
if (inGroup)
|
|
{
|
|
for (size_t i = 0 ; i < drawings_.size(); i++)
|
|
{
|
|
drawings_[i].serialize(strm, ns, local);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
if (false == local)
|
|
{
|
|
CP_XML_NODE(ns + L":wsDr")
|
|
{
|
|
if (ns == L"xdr")
|
|
{
|
|
CP_XML_ATTR(L"xmlns:xdr", L"http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing");
|
|
}
|
|
if (ns == L"cdr")
|
|
{
|
|
CP_XML_ATTR(L"xmlns:cdr", L"http://schemas.openxmlformats.org/drawingml/2006/chartDrawing");
|
|
}
|
|
CP_XML_ATTR(L"xmlns:a", L"http://schemas.openxmlformats.org/drawingml/2006/main");
|
|
CP_XML_ATTR(L"xmlns:r", L"http://schemas.openxmlformats.org/officeDocument/2006/relationships");
|
|
CP_XML_ATTR(L"xmlns:a14", L"http://schemas.microsoft.com/office/drawing/2010/main");
|
|
|
|
for (size_t i = 0; i < drawings_.size(); i++)
|
|
{
|
|
drawings_[i].serialize(CP_XML_STREAM(), ns, false);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (size_t i = 0; i < drawings_.size(); i++)
|
|
{
|
|
drawings_[i].serialize(strm, ns, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
void serialize_vml(std::wostream & strm)
|
|
{
|
|
if (vml_drawings_.empty()) return;
|
|
|
|
if (inGroup)
|
|
{
|
|
for (size_t i = 0 ; i < vml_drawings_.size(); i++)
|
|
{
|
|
vml_drawings_[i].serialize_vml(strm);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CP_XML_WRITER(strm)
|
|
{
|
|
CP_XML_NODE(L"xml")
|
|
{
|
|
CP_XML_ATTR(L"xmlns:v", L"urn:schemas-microsoft-com:vml");
|
|
CP_XML_ATTR(L"xmlns:o", L"urn:schemas-microsoft-com:office:office");
|
|
CP_XML_ATTR(L"xmlns:x", L"urn:schemas-microsoft-com:office:excel");
|
|
|
|
CP_XML_NODE(L"v:shapetype")
|
|
{
|
|
CP_XML_ATTR(L"id", L"_x0000_t201");
|
|
CP_XML_ATTR(L"o:spt", L"201"); // sptHostControl = 201
|
|
|
|
CP_XML_ATTR(L"coordsize", L"21600,21600");
|
|
CP_XML_ATTR(L"path", L"m,l,21600r21600,l21600,xe");
|
|
|
|
CP_XML_NODE(L"v:stroke")
|
|
{
|
|
CP_XML_ATTR(L"joinstyle", L"miter");
|
|
}
|
|
CP_XML_NODE(L"v:path")
|
|
{
|
|
CP_XML_ATTR(L"shadowok", L"f");
|
|
CP_XML_ATTR(L"o:extrusionok", L"f");
|
|
CP_XML_ATTR(L"strokeok", L"f");
|
|
CP_XML_ATTR(L"fillok", L"f");
|
|
CP_XML_ATTR(L"o:connecttype", L"rect");
|
|
}
|
|
CP_XML_NODE(L"o:lock")
|
|
{
|
|
CP_XML_ATTR(L"v:ext", L"edit");
|
|
CP_XML_ATTR(L"shapetype", L"t");
|
|
}
|
|
}
|
|
CP_XML_NODE(L"v:shapetype")
|
|
{
|
|
CP_XML_ATTR(L"id", L"_x0000_t202");
|
|
CP_XML_ATTR(L"o:spt", L"202"); // sptTextBox = 202
|
|
|
|
CP_XML_ATTR(L"coordsize", L"21600,21600");
|
|
CP_XML_ATTR(L"path", L"m,l,21600l21600,21600l21600,xe");
|
|
|
|
CP_XML_NODE(L"v:stroke")
|
|
{
|
|
CP_XML_ATTR(L"joinstyle", L"miter");
|
|
}
|
|
CP_XML_NODE(L"v:path")
|
|
{
|
|
CP_XML_ATTR(L"gradientshapeok", L"t");
|
|
CP_XML_ATTR(L"o:connecttype", L"rect");
|
|
}
|
|
}
|
|
for (size_t i = 0 ; i < vml_drawings_.size(); i++)
|
|
{
|
|
vml_drawings_[i].serialize_vml(CP_XML_STREAM());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void serialize_objects(std::wostream & strm)
|
|
{
|
|
serialize_objects(drawings_, strm);
|
|
}
|
|
void serialize_controls(std::wostream & strm)
|
|
{
|
|
for (size_t i = 0 ; i < vml_drawings_.size(); i++)
|
|
{
|
|
if (vml_drawings_[i].type != typeControl) continue;
|
|
|
|
vml_drawings_[i].serialize_control(strm);
|
|
}
|
|
}
|
|
bool empty() const
|
|
{
|
|
return (drawings_.empty());
|
|
}
|
|
bool vml_empty() const
|
|
{
|
|
return (vml_drawings_.empty());
|
|
}
|
|
|
|
void dump_rels_drawing(rels & Rels)
|
|
{
|
|
for (size_t i = 0 ; i < drawing_rels_.size(); i++)
|
|
{
|
|
if (drawing_rels_[i].type == typeImage ||
|
|
drawing_rels_[i].type == typeMedia ||
|
|
drawing_rels_[i].type == typeChart ||
|
|
drawing_rels_[i].type == typeHyperlink )
|
|
{
|
|
|
|
if (drawing_rels_[i].ref.empty() && drawing_rels_[i].type == typeImage) continue;
|
|
|
|
Rels.add(relationship( drawing_rels_[i].rid,
|
|
mediaitems::get_rel_type(drawing_rels_[i].type),
|
|
(drawing_rels_[i].is_internal ? std::wstring(L"../") + drawing_rels_[i].ref : drawing_rels_[i].ref),
|
|
(drawing_rels_[i].is_internal ? L"" : L"External")) );
|
|
}
|
|
}
|
|
}
|
|
void dump_rels_vml_drawing(rels & Rels)
|
|
{
|
|
for (size_t i = 0 ; i < vml_drawing_rels_.size(); i++)
|
|
{
|
|
if (vml_drawing_rels_[i].type == typeImage ||
|
|
vml_drawing_rels_[i].type == typeMedia ||
|
|
vml_drawing_rels_[i].type == typeChart ||
|
|
vml_drawing_rels_[i].type == typeHyperlink )
|
|
{
|
|
|
|
Rels.add(relationship( vml_drawing_rels_[i].rid,
|
|
mediaitems::get_rel_type(vml_drawing_rels_[i].type),
|
|
(vml_drawing_rels_[i].is_internal ? std::wstring(L"../") + vml_drawing_rels_[i].ref : vml_drawing_rels_[i].ref),
|
|
(vml_drawing_rels_[i].is_internal ? L"" : L"External")) );
|
|
}
|
|
}
|
|
}
|
|
void dump_rels_sheet(rels & Rels)
|
|
{
|
|
for (size_t i = 0 ; i < xlsx_sheet_rels_.size(); i++)
|
|
{
|
|
Rels.add(relationship( xlsx_sheet_rels_[i].rid,
|
|
mediaitems::get_rel_type(xlsx_sheet_rels_[i].type),
|
|
(xlsx_sheet_rels_[i].is_internal ? std::wstring(L"../") + xlsx_sheet_rels_[i].ref : xlsx_sheet_rels_[i].ref),
|
|
(xlsx_sheet_rels_[i].is_internal ? L"" : L"External")) );
|
|
}
|
|
}
|
|
std::vector<_xlsx_drawing> get()
|
|
{
|
|
return drawings_;
|
|
}
|
|
bool inGroup = false;
|
|
private:
|
|
void serialize_objects(std::vector<_xlsx_drawing> & drawings, std::wostream & strm)
|
|
{
|
|
for (size_t i = 0; i < drawings.size(); i++)
|
|
{
|
|
if (drawings[i].type == typeGroupShape)
|
|
{
|
|
return serialize_objects(drawings[i].childs_, strm);
|
|
}
|
|
if (drawings[i].type != typeOleObject && drawings[i].type != typeMsObject) continue;
|
|
|
|
drawings[i].serialize_object(strm);
|
|
}
|
|
}
|
|
|
|
std::vector<_xlsx_drawing> drawings_;
|
|
std::vector<_xlsx_drawing> vml_drawings_;
|
|
|
|
std::vector<_rel> drawing_rels_;
|
|
std::vector<_rel> vml_drawing_rels_;
|
|
std::vector<_rel> xlsx_sheet_rels_;
|
|
};
|
|
|
|
xlsx_drawings::xlsx_drawings(bool inGroup_) : impl_( new xlsx_drawings::Impl() )
|
|
{
|
|
impl_->inGroup = inGroup_;
|
|
}
|
|
|
|
xlsx_drawings::~xlsx_drawings()
|
|
{
|
|
}
|
|
std::vector<_xlsx_drawing> xlsx_drawings::get()
|
|
{
|
|
return impl_->get();
|
|
}
|
|
void xlsx_drawings::add(_xlsx_drawing & d, bool isInternal, std::wstring const & rid,
|
|
std::wstring const & ref, _rels_type type, bool sheet_rel)
|
|
{
|
|
impl_->add(d, isInternal, rid, ref, type, sheet_rel);
|
|
}
|
|
|
|
void xlsx_drawings::add( bool isInternal, std::wstring const & rid, std::wstring const & ref, _rels_type type, bool sheet_rel, bool vml_rel)
|
|
{
|
|
impl_->add(isInternal, rid, ref, type, sheet_rel, vml_rel);
|
|
}
|
|
|
|
void xlsx_drawings::serialize(std::wostream & strm, const std::wstring & ns, bool local)
|
|
{
|
|
impl_->serialize(strm, ns, local);
|
|
}
|
|
void xlsx_drawings::serialize_vml(std::wostream & strm)
|
|
{
|
|
impl_->serialize_vml(strm);
|
|
}
|
|
|
|
void xlsx_drawings::serialize_objects(std::wostream & strm)
|
|
{
|
|
impl_->serialize_objects(strm);
|
|
}
|
|
void xlsx_drawings::serialize_controls(std::wostream & strm)
|
|
{
|
|
impl_->serialize_controls(strm);
|
|
}
|
|
|
|
bool xlsx_drawings::empty() const
|
|
{
|
|
return impl_->empty();
|
|
}
|
|
bool xlsx_drawings::vml_empty() const
|
|
{
|
|
return impl_->vml_empty();
|
|
}
|
|
void xlsx_drawings::dump_rels_drawing(rels & Rels)
|
|
{
|
|
return impl_->dump_rels_drawing(Rels);
|
|
}
|
|
void xlsx_drawings::dump_rels_vml_drawing(rels & Rels)
|
|
{
|
|
return impl_->dump_rels_vml_drawing(Rels);
|
|
}
|
|
void xlsx_drawings::dump_rels_sheet(rels & Rels)
|
|
{
|
|
return impl_->dump_rels_sheet(Rels);
|
|
}
|
|
|
|
xlsx_drawings_ptr xlsx_drawings::create(bool inGroup)
|
|
{
|
|
return boost::make_shared<xlsx_drawings>(inGroup);
|
|
}
|
|
|
|
}
|
|
}
|
|
|