StarMirror/xlnt
1
0
Fork 0
mirror of https://github.com/tfussell/xlnt.git synced 2024-03-22 13:11:17 +08:00
Code Issues Projects Releases Wiki Activity
b004d0863c
xlnt/source/detail/serialization/xlsx_consumer.cpp

3041 lines
107 KiB
C++
Raw Normal View History

copyright year bump (2018)
2018-01-22 22:38:48 +08:00
// Copyright (c) 2014-2018 Thomas Fussell
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, WRISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE
//
// @license: http://www.opensource.org/licenses/mit-license.php
// @author: see AUTHORS file
use streams to access zip files and their contents instead of std::stringstream to reduce memory usage, replaces miniz with zlib, closes #66
2016-10-31 03:48:40 +08:00
a little refactoring
2016-08-05 13:52:05 +08:00
#include <cctype>
implement reading of cell comments
2016-10-29 22:23:04 +08:00
#include <numeric> // for std::accumulate
encapsulate stateful stringstream string to float conversion into a separate struct
2017-09-09 08:10:46 +08:00
#include <sstream>
fix clang warnings
2017-09-09 10:59:19 +08:00
#include <unordered_map>
a little refactoring
2016-08-05 13:52:05 +08:00
improve styles
2016-08-18 19:34:18 +08:00
#include <xlnt/cell/cell.hpp>
organize detail files, start wiring up encryption logic
2017-04-21 02:03:03 +08:00
#include <xlnt/cell/comment.hpp>
improve hyperlinks and style round tripping
2018-03-21 21:03:37 +08:00
#include <xlnt/cell/hyperlink.hpp>
a little refactoring
2016-08-05 13:52:05 +08:00
#include <xlnt/packaging/manifest.hpp>
intermediate commit
2017-06-16 06:10:27 +08:00
#include <xlnt/utils/optional.hpp>
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
#include <xlnt/utils/path.hpp>
a little refactoring
2016-08-05 13:52:05 +08:00
#include <xlnt/workbook/workbook.hpp>
implement sheet view selection consumption, closes #164
2017-09-13 21:36:42 +08:00
#include <xlnt/worksheet/selection.hpp>
a little refactoring
2016-08-05 13:52:05 +08:00
#include <xlnt/worksheet/worksheet.hpp>
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
#include <detail/constants.hpp>
#include <detail/header_footer/header_footer_code.hpp>
#include <detail/implementations/workbook_impl.hpp>
#include <detail/serialization/custom_value_traits.hpp>
#include <detail/serialization/vector_streambuf.hpp>
#include <detail/serialization/xlsx_consumer.hpp>
#include <detail/serialization/zstream.hpp>
a little refactoring
2016-08-05 13:52:05 +08:00
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
namespace std {
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
/// <summary>
/// Allows xml::qname to be used as a key in a std::unordered_map.
/// </summary>
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
template <>
struct hash<xml::qname>
{
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
std::size_t operator()(const xml::qname &k) const
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
{
static std::hash<std::string> hasher;
return hasher(k.string());
}
};
} // namespace std
a little refactoring
2016-08-05 13:52:05 +08:00
namespace {
memoize calls to xml::qname builder
2017-09-09 05:39:59 +08:00
xml::qname &qn(const std::string &namespace_, const std::string &name)
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
{
optimize hot code paths
2017-09-09 07:08:38 +08:00
using qname_map = std::unordered_map<std::string, xml::qname>;
static auto &memo = *new std::unordered_map<std::string, qname_map>();
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
memoize calls to xml::qname builder
2017-09-09 05:39:59 +08:00
auto &ns_memo = memo[namespace_];
optimize hot code paths
2017-09-09 07:08:38 +08:00
if (ns_memo.find(name) == ns_memo.end())
memoize calls to xml::qname builder
2017-09-09 05:39:59 +08:00
{
optimize hot code paths
2017-09-09 07:08:38 +08:00
return ns_memo.emplace(name, xml::qname(xlnt::constants::ns(namespace_), name)).first->second;
memoize calls to xml::qname builder
2017-09-09 05:39:59 +08:00
}
return ns_memo[name];
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
}
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
#ifdef THROW_ON_INVALID_XML
#define unexpected_element(element) throw xlnt::exception(element.string());
#else
#define unexpected_element(element) skip_remaining_content(element);
#endif
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
/// <summary>
/// Returns true if bool_string represents a true xsd:boolean.
/// </summary>
a little refactoring
2016-08-05 13:52:05 +08:00
bool is_true(const std::string &bool_string)
{
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
if (bool_string == "1" || bool_string == "true")
{
return true;
}
#ifdef THROW_ON_INVALID_XML
if (bool_string == "0" || bool_string == "false")
{
return false;
}
throw xlnt::exception("xsd:boolean should be one of: 0, 1, true, or false, found " + bool_string);
#else
a little refactoring
2016-08-05 13:52:05 +08:00
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
return false;
a little refactoring
2016-08-05 13:52:05 +08:00
#endif
}
encapsulate stateful stringstream string to float conversion into a separate struct
2017-09-09 08:10:46 +08:00
struct number_converter
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
{
encapsulate stateful stringstream string to float conversion into a separate struct
2017-09-09 08:10:46 +08:00
number_converter()
{
stream.imbue(std::locale("C"));
}
change cell numeric value type from long double to double, closes #201
2017-09-09 09:05:34 +08:00
double stold(const std::string &s)
encapsulate stateful stringstream string to float conversion into a separate struct
2017-09-09 08:10:46 +08:00
{
stream.str(s);
stream.clear();
stream >> result;
return result;
fix clang warnings
2017-09-09 10:59:19 +08:00
}
encapsulate stateful stringstream string to float conversion into a separate struct
2017-09-09 08:10:46 +08:00
std::istringstream stream;
change cell numeric value type from long double to double, closes #201
2017-09-09 09:05:34 +08:00
double result;
encapsulate stateful stringstream string to float conversion into a separate struct
2017-09-09 08:10:46 +08:00
};
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
reformat a little
2017-12-09 04:31:25 +08:00
using style_id_pair = std::pair<xlnt::detail::style_impl, std::size_t>;
/// <summary>
/// Try to find given xfid value in the styles vector and, if succeeded, set's the optional style.
/// </summary>
void set_style_by_xfid(const std::vector<style_id_pair> &styles,
std::size_t xfid, xlnt::optional<std::string> &style)
{
for (auto &item : styles)
{
if (item.second == xfid)
{
style = item.first.name;
}
}
}
a little refactoring
2016-08-05 13:52:05 +08:00
} // namespace
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
/*
class parsing_context
{
public:
clang-format all source files, fix broken test helpers--lots of cleanup necessary as a result [ci skip]
2016-12-24 23:04:57 +08:00
parsing_context(xlnt::detail::zip_file_reader &archive, const std::string &filename)
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
: parser_(stream_, filename)
{
}
xml::parser &parser();
private:
std::istream stream_;
xml::parser parser_;
};
*/
a little refactoring
2016-08-05 13:52:05 +08:00
namespace xlnt {
namespace detail {
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
xlsx_consumer::xlsx_consumer(workbook &target)
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
: target_(target),
start cleaning up code
2017-06-25 21:29:45 +08:00
parser_(nullptr)
{
}
xlsx_consumer::~xlsx_consumer()
a little refactoring
2016-08-05 13:52:05 +08:00
{
}
void xlsx_consumer::read(std::istream &source)
{
clean up test xml_helper, rename zip to zstream
2017-01-05 08:02:31 +08:00
archive_.reset(new izstream(source));
intermediate commit
2017-06-16 06:10:27 +08:00
populate_workbook(false);
}
void xlsx_consumer::open(std::istream &source)
{
archive_.reset(new izstream(source));
populate_workbook(true);
}
cell xlsx_consumer::read_cell()
{
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
if (!has_cell())
{
return cell(nullptr);
}
start cleaning up code
2017-06-25 21:29:45 +08:00
auto ws = worksheet(current_worksheet_);
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
use memoization to replace cached static qnames
2017-09-09 06:03:56 +08:00
if (in_element(qn("spreadsheetml", "sheetData")))
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
{
use memoization to replace cached static qnames
2017-09-09 06:03:56 +08:00
expect_start_element(qn("spreadsheetml", "row"), xml::content::complex); // CT_Row
fixup formatting
2017-08-27 00:04:23 +08:00
auto row_index = static_cast<row_t>(std::stoul(parser().attribute("r")));
work on hyperlinks, x14 extentions, other round tripping silliness
2018-03-17 09:21:16 +08:00
auto &row_properties = ws.row_properties(row_index);
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
if (parser().attribute_present("ht"))
{
work on hyperlinks, x14 extentions, other round tripping silliness
2018-03-17 09:21:16 +08:00
row_properties.height = parser().attribute<double>("ht");
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
}
if (parser().attribute_present("customHeight"))
{
work on hyperlinks, x14 extentions, other round tripping silliness
2018-03-17 09:21:16 +08:00
row_properties.custom_height = is_true(parser().attribute("customHeight"));
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
}
if (parser().attribute_present("hidden") && is_true(parser().attribute("hidden")))
{
work on hyperlinks, x14 extentions, other round tripping silliness
2018-03-17 09:21:16 +08:00
row_properties.hidden = true;
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
}
work on hyperlinks, x14 extentions, other round tripping silliness
2018-03-17 09:21:16 +08:00
if (parser().attribute_present(qn("x14ac", "dyDescent")))
{
row_properties.dy_descent = parser().attribute<double>(qn("x14ac", "dyDescent"));
}
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
skip_attributes({"customFormat", "s", "customFont",
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
"outlineLevel", "collapsed", "thickTop", "thickBot",
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
"ph", "spans"});
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
}
use memoization to replace cached static qnames
2017-09-09 06:03:56 +08:00
if (!in_element(qn("spreadsheetml", "row")))
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
{
return cell(nullptr);
fix clang warnings
2017-09-09 10:59:19 +08:00
}
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
use memoization to replace cached static qnames
2017-09-09 06:03:56 +08:00
expect_start_element(qn("spreadsheetml", "c"), xml::content::complex);
start cleaning up code
2017-06-25 21:29:45 +08:00
work on hyperlinks, x14 extentions, other round tripping silliness
2018-03-17 09:21:16 +08:00
auto cell = streaming_
? xlnt::cell(streaming_cell_.get())
start cleaning up code
2017-06-25 21:29:45 +08:00
: ws.cell(cell_reference(parser().attribute("r")));
auto reference = cell_reference(parser().attribute("r"));
cell.d_->parent_ = current_worksheet_;
cell.d_->column_ = reference.column_index();
cell.d_->row_ = reference.row();
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
auto has_type = parser().attribute_present("t");
auto type = has_type ? parser().attribute("t") : "n";
Merge branch 'dev' into dev
2017-09-09 11:15:06 +08:00
if (parser().attribute_present("s"))
{
suppress conversion warnings -- tolower takes chars and returns chars, types are int because C only deals with ints -- format parameter is size_t but there is no std parsing function that returns size_t. stoull is used instead as the widest alternative, and then the cast is applied to suppress the conversion warnings
2018-06-18 19:24:13 +08:00
cell.format(target_.format(static_cast<std::size_t>(std::stoull(parser().attribute("s")))));
Merge branch 'dev' into dev
2017-09-09 11:15:06 +08:00
}
implement sheet view selection consumption, closes #164
2017-09-13 21:36:42 +08:00
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
auto has_value = false;
auto value_string = std::string();
auto has_formula = false;
auto has_shared_formula = false;
auto formula_value_string = std::string();
use memoization to replace cached static qnames
2017-09-09 06:03:56 +08:00
while (in_element(qn("spreadsheetml", "c")))
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
{
auto current_element = expect_start_element(xml::content::mixed);
use memoization to replace cached static qnames
2017-09-09 06:03:56 +08:00
if (current_element == qn("spreadsheetml", "v")) // s:ST_Xstring
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
{
has_value = true;
value_string = read_text();
}
else if (current_element == qn("spreadsheetml", "f")) // CT_CellFormula
{
has_formula = true;
if (parser().attribute_present("t"))
{
has_shared_formula = parser().attribute("t") == "shared";
}
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
skip_attributes({"aca", "ref", "dt2D", "dtr", "del1",
"del2", "r1", "r2", "ca", "si", "bx"});
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
formula_value_string = read_text();
}
else if (current_element == qn("spreadsheetml", "is")) // CT_Rst
{
expect_start_element(qn("spreadsheetml", "t"), xml::content::simple);
value_string = read_text();
expect_end_element(qn("spreadsheetml", "t"));
}
else
{
unexpected_element(current_element);
}
expect_end_element(current_element);
}
optimize hot code paths
2017-09-09 07:08:38 +08:00
expect_end_element(qn("spreadsheetml", "c"));
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
if (has_formula && !has_shared_formula)
{
cell.formula(formula_value_string);
}
encapsulate stateful stringstream string to float conversion into a separate struct
2017-09-09 08:10:46 +08:00
number_converter converter;
optimize hot code paths
2017-09-09 07:08:38 +08:00
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
if (has_value)
{
if (type == "str")
{
cell.d_->value_text_ = value_string;
cell.data_type(cell::type::formula_string);
}
else if (type == "inlineStr")
{
cell.d_->value_text_ = value_string;
cell.data_type(cell::type::inline_string);
}
else if (type == "s")
{
encapsulate stateful stringstream string to float conversion into a separate struct
2017-09-09 08:10:46 +08:00
cell.d_->value_numeric_ = converter.stold(value_string);
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
cell.data_type(cell::type::shared_string);
}
else if (type == "b") // boolean
{
cell.value(is_true(value_string));
}
else if (type == "n") // numeric
{
encapsulate stateful stringstream string to float conversion into a separate struct
2017-09-09 08:10:46 +08:00
cell.value(converter.stold(value_string));
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
}
else if (!value_string.empty() && value_string[0] == '#')
{
cell.error(value_string);
}
}
use memoization to replace cached static qnames
2017-09-09 06:03:56 +08:00
if (!in_element(qn("spreadsheetml", "row")))
basic streaming read works now, just need to clean up the logic
2017-06-25 10:07:37 +08:00
{
use memoization to replace cached static qnames
2017-09-09 06:03:56 +08:00
expect_end_element(qn("spreadsheetml", "row"));
basic streaming read works now, just need to clean up the logic
2017-06-25 10:07:37 +08:00
use memoization to replace cached static qnames
2017-09-09 06:03:56 +08:00
if (!in_element(qn("spreadsheetml", "sheetData")))
basic streaming read works now, just need to clean up the logic
2017-06-25 10:07:37 +08:00
{
use memoization to replace cached static qnames
2017-09-09 06:03:56 +08:00
expect_end_element(qn("spreadsheetml", "sheetData"));
basic streaming read works now, just need to clean up the logic
2017-06-25 10:07:37 +08:00
}
}
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
return cell;
intermediate commit
2017-06-16 06:10:27 +08:00
}
start cleaning up code
2017-06-25 21:29:45 +08:00
void xlsx_consumer::read_worksheet(const std::string &rel_id)
minor fixes to get it to compile. lots of failing tests for now...
2017-06-21 01:29:50 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
read_worksheet_begin(rel_id);
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
start cleaning up code
2017-06-25 21:29:45 +08:00
if (!streaming_)
work on streaming cell reading, using ugly copy-pasted code for now [ci skip]
2017-06-24 23:39:37 +08:00
{
read_worksheet_sheetdata();
read_worksheet_end(rel_id);
}
minor fixes to get it to compile. lots of failing tests for now...
2017-06-21 01:29:50 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
std::string xlsx_consumer::read_worksheet_begin(const std::string &rel_id)
intermediate commit
2017-06-16 06:10:27 +08:00
{
start cleaning up code
2017-06-25 21:29:45 +08:00
if (streaming_ && streaming_cell_ == nullptr)
{
streaming_cell_.reset(new detail::cell_impl());
}
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
auto title = std::find_if(target_.d_->sheet_title_rel_id_map_.begin(),
target_.d_->sheet_title_rel_id_map_.end(),
[&](const std::pair<std::string, std::string> &p) {
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
return p.second == rel_id;
Cleanup from review
2018-06-26 16:32:59 +08:00
})->first;
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
start cleaning up code
2017-06-25 21:29:45 +08:00
auto ws = worksheet(current_worksheet_);
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
expect_start_element(qn("spreadsheetml", "worksheet"), xml::content::complex); // CT_Worksheet
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
skip_attributes({qn("mc", "Ignorable")});
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
while (in_element(qn("spreadsheetml", "worksheet")))
{
auto current_worksheet_element = expect_start_element(xml::content::complex);
if (current_worksheet_element == qn("spreadsheetml", "sheetPr")) // CT_SheetPr 0-1
{
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
sheet_pr props;
if (parser().attribute_present("syncHorizontal"))
{ // optional, boolean, false
Cleanup from review
2018-06-26 16:32:59 +08:00
props.sync_horizontal.set(parser().attribute<bool>("syncHorizontal"));
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
}
if (parser().attribute_present("syncVertical"))
{// optional, boolean, false
Cleanup from review
2018-06-26 16:32:59 +08:00
props.sync_vertical.set(parser().attribute<bool>("syncVertical"));
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
}
if (parser().attribute_present("syncRef"))
{ // optional, ST_Ref, false
Cleanup from review
2018-06-26 16:32:59 +08:00
props.sync_ref.set(cell_reference(parser().attribute("syncRef")));
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
}
if (parser().attribute_present("transitionEvaluation"))
{ // optional, boolean, false
Cleanup from review
2018-06-26 16:32:59 +08:00
props.transition_evaluation.set(parser().attribute<bool>("transitionEvaluation"));
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
}
if (parser().attribute_present("transitionEntry"))
{// optional, boolean, false
Cleanup from review
2018-06-26 16:32:59 +08:00
props.transition_entry.set(parser().attribute<bool>("transitionEntry"));
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
}
if (parser().attribute_present("published"))
{// optional, boolean, true
Cleanup from review
2018-06-26 16:32:59 +08:00
props.published.set(parser().attribute<bool>("published"));
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
}
if (parser().attribute_present("codeName"))
{ // optional, string
Cleanup from review
2018-06-26 16:32:59 +08:00
props.code_name.set(parser().attribute<std::string>("codeName"));
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
}
if (parser().attribute_present("filterMode"))
{// optional, boolean, false
props.filter_mode.set(parser().attribute<bool>("filterMode"));
}
if (parser().attribute_present("enableFormatConditionsCalculation"))
{// optional, boolean, true
Cleanup from review
2018-06-26 16:32:59 +08:00
props.enable_format_condition_calculation.set(parser().attribute<bool>("enableFormatConditionsCalculation"));
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
}
ws.d_->sheet_properties_.set(props);
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
while (in_element(current_worksheet_element))
{
auto sheet_pr_child_element = expect_start_element(xml::content::simple);
if (sheet_pr_child_element == qn("spreadsheetml", "tabColor")) // CT_Color 0-1
{
read_color();
}
else if (sheet_pr_child_element == qn("spreadsheetml", "outlinePr")) // CT_OutlinePr 0-1
{
skip_attribute("applyStyles"); // optional, boolean, false
skip_attribute("summaryBelow"); // optional, boolean, true
skip_attribute("summaryRight"); // optional, boolean, true
skip_attribute("showOutlineSymbols"); // optional, boolean, true
}
else if (sheet_pr_child_element == qn("spreadsheetml", "pageSetUpPr")) // CT_PageSetUpPr 0-1
{
skip_attribute("autoPageBreaks"); // optional, boolean, true
skip_attribute("fitToPage"); // optional, boolean, false
}
else
{
unexpected_element(sheet_pr_child_element);
}
expect_end_element(sheet_pr_child_element);
}
}
else if (current_worksheet_element == qn("spreadsheetml", "dimension")) // CT_SheetDimension 0-1
{
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
skip_remaining_content(current_worksheet_element);
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
}
else if (current_worksheet_element == qn("spreadsheetml", "sheetViews")) // CT_SheetViews 0-1
{
while (in_element(current_worksheet_element))
{
expect_start_element(qn("spreadsheetml", "sheetView"), xml::content::complex); // CT_SheetView 1+
sheet_view new_view;
new_view.id(parser().attribute<std::size_t>("workbookViewId"));
if (parser().attribute_present("showGridLines")) // default="true"
{
new_view.show_grid_lines(is_true(parser().attribute("showGridLines")));
}
Add serialisation of "topLeftCell" sheetView attribute
2018-06-24 10:19:03 +08:00
if (parser().attribute_present("topLeftCell"))
{
new_view.top_left_cell(cell_reference(parser().attribute("topLeftCell")));
}
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
if (parser().attribute_present("defaultGridColor")) // default="true"
{
new_view.default_grid_color(is_true(parser().attribute("defaultGridColor")));
}
improve hyperlinks and style round tripping
2018-03-21 21:03:37 +08:00
if (parser().attribute_present("view")
&& parser().attribute("view") != "normal")
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
{
implement sheet view selection consumption, closes #164
2017-09-13 21:36:42 +08:00
new_view.type(parser().attribute("view") == "pageBreakPreview"
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
? sheet_view_type::page_break_preview
: sheet_view_type::page_layout);
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
}
improve hyperlinks and style round tripping
2018-03-21 21:03:37 +08:00
if (parser().attribute_present("tabSelected")
&& is_true(parser().attribute("tabSelected")))
{
target_.d_->view_.get().active_tab = ws.id() - 1;
}
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
skip_attributes({"windowProtection", "showFormulas", "showRowColHeaders", "showZeros", "rightToLeft", "showRuler", "showOutlineSymbols", "showWhiteSpace",
implement sheet view serialization
2018-03-15 08:12:07 +08:00
"view", "topLeftCell", "colorId", "zoomScale", "zoomScaleNormal", "zoomScaleSheetLayoutView",
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
"zoomScalePageLayoutView"});
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
while (in_element(qn("spreadsheetml", "sheetView")))
{
auto sheet_view_child_element = expect_start_element(xml::content::simple);
if (sheet_view_child_element == qn("spreadsheetml", "pane")) // CT_Pane 0-1
{
pane new_pane;
if (parser().attribute_present("topLeftCell"))
{
new_pane.top_left_cell = cell_reference(parser().attribute("topLeftCell"));
}
if (parser().attribute_present("xSplit"))
{
new_pane.x_split = parser().attribute<column_t::index_t>("xSplit");
}
if (parser().attribute_present("ySplit"))
{
new_pane.y_split = parser().attribute<row_t>("ySplit");
}
if (parser().attribute_present("activePane"))
{
new_pane.active_pane = parser().attribute<pane_corner>("activePane");
}
if (parser().attribute_present("state"))
{
new_pane.state = parser().attribute<pane_state>("state");
}
new_view.pane(new_pane);
}
else if (sheet_view_child_element == qn("spreadsheetml", "selection")) // CT_Selection 0-4
{
implement sheet view selection consumption, closes #164
2017-09-13 21:36:42 +08:00
selection current_selection;
if (parser().attribute_present("activeCell"))
{
current_selection.active_cell(parser().attribute("activeCell"));
}
implement sheet view serialization
2018-03-15 08:12:07 +08:00
if (parser().attribute_present("sqref"))
{
const auto sqref = range_reference(parser().attribute("sqref"));
current_selection.sqref(sqref);
}
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
implement sheet view selection consumption, closes #164
2017-09-13 21:36:42 +08:00
current_selection.pane(pane_corner::top_left);
new_view.add_selection(current_selection);
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
skip_remaining_content(sheet_view_child_element);
}
else if (sheet_view_child_element == qn("spreadsheetml", "pivotSelection")) // CT_PivotSelection 0-4
{
skip_remaining_content(sheet_view_child_element);
}
else if (sheet_view_child_element == qn("spreadsheetml", "extLst")) // CT_ExtensionList 0-1
{
skip_remaining_content(sheet_view_child_element);
}
else
{
unexpected_element(sheet_view_child_element);
}
expect_end_element(sheet_view_child_element);
}
expect_end_element(qn("spreadsheetml", "sheetView"));
ws.d_->views_.push_back(new_view);
}
}
else if (current_worksheet_element == qn("spreadsheetml", "sheetFormatPr")) // CT_SheetFormatPr 0-1
{
implement sheetFormatPr, x14ac:dyDescent, reordering workbook rels so sheets come first after insertions
2018-01-27 03:32:00 +08:00
if (parser().attribute_present("baseColWidth"))
{
ws.d_->format_properties_.base_col_width =
parser().attribute<double>("baseColWidth");
}
re-save custom_heights_widths.xlsx, add defaultColWidth sheet attribute -- custom_heights was the only test sheet where the integral value was being saved with a trailing ".0" -- Updated tests to expect the new values -- added the new property "defaultColWidth"
2018-06-24 07:53:45 +08:00
if (parser().attribute_present("defaultColWidth"))
{
ws.d_->format_properties_.default_column_width =
parser().attribute<double>("defaultColWidth");
}
implement sheetFormatPr, x14ac:dyDescent, reordering workbook rels so sheets come first after insertions
2018-01-27 03:32:00 +08:00
if (parser().attribute_present("defaultRowHeight"))
{
ws.d_->format_properties_.default_row_height =
parser().attribute<double>("defaultRowHeight");
}
if (parser().attribute_present(qn("x14ac", "dyDescent")))
{
ws.d_->format_properties_.dy_descent =
parser().attribute<double>(qn("x14ac", "dyDescent"));
}
skip_attributes();
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
}
else if (current_worksheet_element == qn("spreadsheetml", "cols")) // CT_Cols 0+
{
while (in_element(qn("spreadsheetml", "cols")))
{
expect_start_element(qn("spreadsheetml", "col"), xml::content::simple);
update bestFit commit error compiling std::vector<std::string>
2018-07-19 19:53:54 +08:00
skip_attributes(std::vector<std::string>{"collapsed", "outlineLevel"});
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
auto min = static_cast<column_t::index_t>(std::stoull(parser().attribute("min")));
auto max = static_cast<column_t::index_t>(std::stoull(parser().attribute("max")));
optional<double> width;
if (parser().attribute_present("width"))
{
use column width adjustment as specified in standard so that width in Excel on Windows matches value in xlnt, #193
2017-08-19 09:38:10 +08:00
width = (parser().attribute<double>("width") * 7 - 5) / 7;
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
}
optional<std::size_t> column_style;
if (parser().attribute_present("style"))
{
column_style = parser().attribute<std::size_t>("style");
}
clarify target_mode namespace
2017-07-03 10:17:14 +08:00
auto custom = parser().attribute_present("customWidth")
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
? is_true(parser().attribute("customWidth"))
: false;
clarify target_mode namespace
2017-07-03 10:17:14 +08:00
auto hidden = parser().attribute_present("hidden")
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
? is_true(parser().attribute("hidden"))
: false;
Add "bestFit" column attribute serialisation
2018-06-24 06:13:27 +08:00
auto best_fit = parser().attribute_present("bestFit")
? is_true(parser().attribute("bestFit"))
: false;
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
expect_end_element(qn("spreadsheetml", "col"));
for (auto column = min; column <= max; column++)
{
column_properties props;
if (width.is_set())
{
props.width = width.get();
}
if (column_style.is_set())
{
props.style = column_style.get();
}
props.hidden = hidden;
props.custom_width = custom;
Add "bestFit" column attribute serialisation
2018-06-24 06:13:27 +08:00
props.best_fit = best_fit;
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
ws.add_column_properties(column, props);
}
}
}
else if (current_worksheet_element == qn("spreadsheetml", "sheetData")) // CT_SheetData 1
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
return title;
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
}
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
expect_end_element(current_worksheet_element);
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
}
return title;
intermediate commit
2017-06-16 06:10:27 +08:00
}
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
void xlsx_consumer::read_worksheet_sheetdata()
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
{
start cleaning up code
2017-06-25 21:29:45 +08:00
auto ws = worksheet(current_worksheet_);
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
if (stack_.back() != qn("spreadsheetml", "sheetData"))
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
{
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
return;
}
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
encapsulate stateful stringstream string to float conversion into a separate struct
2017-09-09 08:10:46 +08:00
number_converter converter;
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
while (in_element(qn("spreadsheetml", "sheetData")))
{
expect_start_element(qn("spreadsheetml", "row"), xml::content::complex); // CT_Row
auto row_index = parser().attribute<row_t>("r");
work on hyperlinks, x14 extentions, other round tripping silliness
2018-03-17 09:21:16 +08:00
auto &row_properties = ws.row_properties(row_index);
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
if (parser().attribute_present("ht"))
{
work on hyperlinks, x14 extentions, other round tripping silliness
2018-03-17 09:21:16 +08:00
row_properties.height = parser().attribute<double>("ht");
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
}
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
if (parser().attribute_present("customHeight"))
{
work on hyperlinks, x14 extentions, other round tripping silliness
2018-03-17 09:21:16 +08:00
row_properties.custom_height = is_true(parser().attribute("customHeight"));
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
}
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
if (parser().attribute_present("hidden") && is_true(parser().attribute("hidden")))
{
work on hyperlinks, x14 extentions, other round tripping silliness
2018-03-17 09:21:16 +08:00
row_properties.hidden = true;
}
if (parser().attribute_present(qn("x14ac", "dyDescent")))
{
row_properties.dy_descent = parser().attribute<double>(qn("x14ac", "dyDescent"));
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
}
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
serialisation of custom row format property added
2018-06-23 18:29:57 +08:00
if (parser().attribute_present("s"))
{
row_properties.style.set(static_cast<std::size_t>(std::stoull(parser().attribute("s"))));
}
if (parser().attribute_present("customFormat"))
{
row_properties.custom_format.set(parser().attribute<bool>("customFormat"));
}
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
skip_attributes({"customFont",
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
"outlineLevel", "collapsed", "thickTop", "thickBot",
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
"ph", "spans"});
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
while (in_element(qn("spreadsheetml", "row")))
{
expect_start_element(qn("spreadsheetml", "c"), xml::content::complex);
auto cell = ws.cell(cell_reference(parser().attribute("r")));
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
auto has_type = parser().attribute_present("t");
auto type = has_type ? parser().attribute("t") : "n";
implement sheet view selection consumption, closes #164
2017-09-13 21:36:42 +08:00
Merge branch 'dev' into dev
2017-09-09 11:15:06 +08:00
if (parser().attribute_present("s"))
{
suppress conversion warnings -- tolower takes chars and returns chars, types are int because C only deals with ints -- format parameter is size_t but there is no std parsing function that returns size_t. stoull is used instead as the widest alternative, and then the cast is applied to suppress the conversion warnings
2018-06-18 19:24:13 +08:00
cell.format(target_.format(static_cast<std::size_t>(std::stoull(parser().attribute("s")))));
Merge branch 'dev' into dev
2017-09-09 11:15:06 +08:00
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
auto has_value = false;
auto value_string = std::string();
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
auto has_formula = false;
auto has_shared_formula = false;
auto formula_value_string = std::string();
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
while (in_element(qn("spreadsheetml", "c")))
{
auto current_element = expect_start_element(xml::content::mixed);
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
if (current_element == qn("spreadsheetml", "v")) // s:ST_Xstring
{
has_value = true;
value_string = read_text();
}
else if (current_element == qn("spreadsheetml", "f")) // CT_CellFormula
{
has_formula = true;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
if (parser().attribute_present("t"))
{
has_shared_formula = parser().attribute("t") == "shared";
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
skip_attributes(
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
{"aca", "ref", "dt2D", "dtr", "del1", "del2", "r1", "r2", "ca", "si", "bx"});
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
formula_value_string = read_text();
}
else if (current_element == qn("spreadsheetml", "is")) // CT_Rst
{
expect_start_element(qn("spreadsheetml", "t"), xml::content::simple);
value_string = read_text();
expect_end_element(qn("spreadsheetml", "t"));
}
else
{
unexpected_element(current_element);
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
expect_end_element(current_element);
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
expect_end_element(qn("spreadsheetml", "c"));
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
if (has_formula && !has_shared_formula)
{
cell.formula(formula_value_string);
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
if (has_value)
{
if (type == "str")
{
cell.d_->value_text_ = value_string;
cell.data_type(cell::type::formula_string);
}
else if (type == "inlineStr")
{
cell.d_->value_text_ = value_string;
cell.data_type(cell::type::inline_string);
}
else if (type == "s")
{
encapsulate stateful stringstream string to float conversion into a separate struct
2017-09-09 08:10:46 +08:00
cell.d_->value_numeric_ = converter.stold(value_string);
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
cell.data_type(cell::type::shared_string);
}
else if (type == "b") // boolean
{
cell.value(is_true(value_string));
}
else if (type == "n") // numeric
{
encapsulate stateful stringstream string to float conversion into a separate struct
2017-09-09 08:10:46 +08:00
cell.value(converter.stold(value_string));
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
else if (!value_string.empty() && value_string[0] == '#')
{
cell.error(value_string);
}
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
expect_end_element(qn("spreadsheetml", "row"));
}
expect_end_element(qn("spreadsheetml", "sheetData"));
}
worksheet xlsx_consumer::read_worksheet_end(const std::string &rel_id)
{
auto &manifest = target_.manifest();
const auto workbook_rel = manifest.relationship(path("/"), relationship_type::office_document);
const auto sheet_rel = manifest.relationship(workbook_rel.target().path(), rel_id);
path sheet_path(sheet_rel.source().path().parent().append(sheet_rel.target().path()));
auto hyperlinks = manifest.relationships(sheet_path, xlnt::relationship_type::hyperlink);
start cleaning up code
2017-06-25 21:29:45 +08:00
auto ws = worksheet(current_worksheet_);
read worksheet xml correctly
2017-06-22 20:56:01 +08:00
while (in_element(qn("spreadsheetml", "worksheet")))
{
auto current_worksheet_element = expect_start_element(xml::content::complex);
if (current_worksheet_element == qn("spreadsheetml", "sheetCalcPr")) // CT_SheetCalcPr 0-1
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "sheetProtection")) // CT_SheetProtection 0-1
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "protectedRanges")) // CT_ProtectedRanges 0-1
begin translating xml parsing and serialization to libstudxml
2016-09-17 10:59:13 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
begin translating xml parsing and serialization to libstudxml
2016-09-17 10:59:13 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "scenarios")) // CT_Scenarios 0-1
begin translating xml parsing and serialization to libstudxml
2016-09-17 10:59:13 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
begin translating xml parsing and serialization to libstudxml
2016-09-17 10:59:13 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "autoFilter")) // CT_AutoFilter 0-1
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
ws.auto_filter(xlnt::range_reference(parser().attribute("ref")));
// auto filter complex
skip_remaining_content(current_worksheet_element);
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "sortState")) // CT_SortState 0-1
implement consumption of vt:lpwstr custom properties
2017-01-03 06:42:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
implement consumption of vt:lpwstr custom properties
2017-01-03 06:42:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "dataConsolidate")) // CT_DataConsolidate 0-1
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
}
else if (current_worksheet_element == qn("spreadsheetml", "customSheetViews")) // CT_CustomSheetViews 0-1
{
skip_remaining_content(current_worksheet_element);
}
else if (current_worksheet_element == qn("spreadsheetml", "mergeCells")) // CT_MergeCells 0-1
{
auto count = std::stoull(parser().attribute("count"));
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(qn("spreadsheetml", "mergeCells")))
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_start_element(qn("spreadsheetml", "mergeCell"), xml::content::simple);
ws.merge_cells(range_reference(parser().attribute("ref")));
expect_end_element(qn("spreadsheetml", "mergeCell"));
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
count--;
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
}
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (count != 0)
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
throw invalid_file("sizes don't match");
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
}
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "phoneticPr")) // CT_PhoneticPr 0-1
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
Add serialisation of worksheet phonetic properties
2018-06-23 08:15:15 +08:00
phonetic_pr phonetic_properties(parser().attribute<std::uint32_t>("fontId"));
if (parser().attribute_present("type"))
{
phonetic_properties.type(phonetic_pr::type_from_string(parser().attribute("type")));
}
if (parser().attribute_present("alignment"))
{
phonetic_properties.alignment(phonetic_pr::alignment_from_string(parser().attribute("alignment")));
}
current_worksheet_->phonetic_properties_.set(phonetic_properties);
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "conditionalFormatting")) // CT_ConditionalFormatting 0+
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "dataValidations")) // CT_DataValidations 0-1
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "hyperlinks")) // CT_Hyperlinks 0-1
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
Add serialisation of worksheet phonetic properties
2018-06-23 08:15:15 +08:00
while (in_element(current_worksheet_element))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
improve hyperlinks and style round tripping
2018-03-21 21:03:37 +08:00
// CT_Hyperlink
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_start_element(qn("spreadsheetml", "hyperlink"), xml::content::simple);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto cell = ws.cell(parser().attribute("ref"));
prevent exception from being thrown when a view doesn't contain window attributes
2017-06-15 03:45:01 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present(qn("r", "id")))
prevent exception from being thrown when a view doesn't contain window attributes
2017-06-15 03:45:01 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto hyperlink_rel_id = parser().attribute(qn("r", "id"));
auto hyperlink_rel = std::find_if(hyperlinks.begin(), hyperlinks.end(),
[&](const relationship &r) { return r.id() == hyperlink_rel_id; });
if (hyperlink_rel != hyperlinks.end())
{
improve hyperlinks and style round tripping
2018-03-21 21:03:37 +08:00
auto url = hyperlink_rel->target().path().string();
if (cell.has_value())
{
cell.hyperlink(url, cell.value<std::string>());
}
else
{
cell.hyperlink(url);
}
}
}
else if (parser().attribute_present("location"))
{
auto hyperlink = hyperlink_impl();
auto location = parser().attribute("location");
hyperlink.relationship = relationship("", relationship_type::hyperlink,
uri(""), uri(location), target_mode::internal);
if (parser().attribute_present("display"))
{
hyperlink.display = parser().attribute("display");
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
improve hyperlinks and style round tripping
2018-03-21 21:03:37 +08:00
if (parser().attribute_present("tooltip"))
{
hyperlink.tooltip = parser().attribute("tooltip");
}
cell.d_->hyperlink_ = hyperlink;
prevent exception from being thrown when a view doesn't contain window attributes
2017-06-15 03:45:01 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(qn("spreadsheetml", "hyperlink"));
}
}
else if (current_worksheet_element == qn("spreadsheetml", "printOptions")) // CT_PrintOptions 0-1
{
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
print_options opts;
if (parser().attribute_present("gridLines"))
{
opts.print_grid_lines.set(parser().attribute<bool>("gridLines"));
}
if (parser().attribute_present("gridLinesSet"))
{
opts.print_grid_lines.set(parser().attribute<bool>("gridLinesSet"));
}
if (parser().attribute_present("headings"))
{
opts.print_grid_lines.set(parser().attribute<bool>("headings"));
}
if (parser().attribute_present("horizontalCentered"))
{
opts.print_grid_lines.set(parser().attribute<bool>("horizontalCentered"));
}
if (parser().attribute_present("verticalCentered"))
{
opts.print_grid_lines.set(parser().attribute<bool>("verticalCentered"));
}
ws.d_->print_options_.set(opts);
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
}
else if (current_worksheet_element == qn("spreadsheetml", "pageMargins")) // CT_PageMargins 0-1
{
page_margins margins;
margins.top(parser().attribute<double>("top"));
margins.bottom(parser().attribute<double>("bottom"));
margins.left(parser().attribute<double>("left"));
margins.right(parser().attribute<double>("right"));
margins.header(parser().attribute<double>("header"));
margins.footer(parser().attribute<double>("footer"));
ws.page_margins(margins);
}
else if (current_worksheet_element == qn("spreadsheetml", "pageSetup")) // CT_PageSetup 0-1
{
Basic pageSetup persistence -- NOTE: The struct page_setup doesn't currently reflect the attributes of the pageSetup element
2018-06-24 08:34:56 +08:00
page_setup setup;
if (parser().attribute_present("orientation"))
{
setup.orientation_.set(parser().attribute<orientation>("orientation"));
}
if (parser().attribute_present("horizontalDpi"))
{
setup.horizontal_dpi_.set(parser().attribute<std::size_t>("horizontalDpi"));
}
if (parser().attribute_present("verticalDpi"))
{
setup.vertical_dpi_.set(parser().attribute<std::size_t>("verticalDpi"));
}
ws.page_setup(setup);
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
}
else if (current_worksheet_element == qn("spreadsheetml", "headerFooter")) // CT_HeaderFooter 0-1
{
header_footer hf;
hf.align_with_margins(
!parser().attribute_present("alignWithMargins") || is_true(parser().attribute("alignWithMargins")));
hf.scale_with_doc(
!parser().attribute_present("alignWithMargins") || is_true(parser().attribute("alignWithMargins")));
auto different_odd_even =
parser().attribute_present("differentOddEven") && is_true(parser().attribute("differentOddEven"));
auto different_first =
parser().attribute_present("differentFirst") && is_true(parser().attribute("differentFirst"));
optional<std::array<optional<rich_text>, 3>> odd_header;
optional<std::array<optional<rich_text>, 3>> odd_footer;
optional<std::array<optional<rich_text>, 3>> even_header;
optional<std::array<optional<rich_text>, 3>> even_footer;
optional<std::array<optional<rich_text>, 3>> first_header;
optional<std::array<optional<rich_text>, 3>> first_footer;
using xlnt::detail::decode_header_footer;
while (in_element(current_worksheet_element))
{
auto current_hf_element = expect_start_element(xml::content::simple);
if (current_hf_element == qn("spreadsheetml", "oddHeader"))
prevent exception from being thrown when a view doesn't contain window attributes
2017-06-15 03:45:01 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
odd_header = decode_header_footer(read_text());
prevent exception from being thrown when a view doesn't contain window attributes
2017-06-15 03:45:01 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_hf_element == qn("spreadsheetml", "oddFooter"))
prevent exception from being thrown when a view doesn't contain window attributes
2017-06-15 03:45:01 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
odd_footer = decode_header_footer(read_text());
prevent exception from being thrown when a view doesn't contain window attributes
2017-06-15 03:45:01 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_hf_element == qn("spreadsheetml", "evenHeader"))
prevent exception from being thrown when a view doesn't contain window attributes
2017-06-15 03:45:01 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
even_header = decode_header_footer(read_text());
}
else if (current_hf_element == qn("spreadsheetml", "evenFooter"))
{
even_footer = decode_header_footer(read_text());
}
else if (current_hf_element == qn("spreadsheetml", "firstHeader"))
{
first_header = decode_header_footer(read_text());
}
else if (current_hf_element == qn("spreadsheetml", "firstFooter"))
{
first_footer = decode_header_footer(read_text());
}
else
{
unexpected_element(current_hf_element);
prevent exception from being thrown when a view doesn't contain window attributes
2017-06-15 03:45:01 +08:00
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(current_hf_element);
}
for (std::size_t i = 0; i < 3; ++i)
{
auto loc = i == 0 ? header_footer::location::left
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
: i == 1 ? header_footer::location::center : header_footer::location::right;
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (different_odd_even)
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (odd_header.is_set() && odd_header.get().at(i).is_set() && even_header.is_set()
&& even_header.get().at(i).is_set())
{
hf.odd_even_header(loc, odd_header.get().at(i).get(), even_header.get().at(i).get());
}
if (odd_footer.is_set() && odd_footer.get().at(i).is_set() && even_footer.is_set()
&& even_footer.get().at(i).is_set())
{
hf.odd_even_footer(loc, odd_footer.get().at(i).get(), even_footer.get().at(i).get());
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else
{
if (odd_header.is_set() && odd_header.get().at(i).is_set())
{
hf.header(loc, odd_header.get().at(i).get());
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (odd_footer.is_set() && odd_footer.get().at(i).is_set())
{
hf.footer(loc, odd_footer.get().at(i).get());
}
}
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (different_first)
{
}
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
ws.header_footer(hf);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "rowBreaks")) // CT_PageBreak 0-1
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto count = parser().attribute_present("count") ? parser().attribute<std::size_t>("count") : 0;
auto manual_break_count = parser().attribute_present("manualBreakCount")
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
? parser().attribute<std::size_t>("manualBreakCount")
: 0;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(qn("spreadsheetml", "rowBreaks")))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_start_element(qn("spreadsheetml", "brk"), xml::content::simple);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("id"))
{
ws.page_break_at_row(parser().attribute<row_t>("id"));
--count;
}
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("man") && is_true(parser().attribute("man")))
{
--manual_break_count;
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
skip_attributes({"min", "max", "pt"});
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(qn("spreadsheetml", "brk"));
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "colBreaks")) // CT_PageBreak 0-1
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto count = parser().attribute_present("count") ? parser().attribute<std::size_t>("count") : 0;
auto manual_break_count = parser().attribute_present("manualBreakCount")
? parser().attribute<std::size_t>("manualBreakCount")
: 0;
while (in_element(qn("spreadsheetml", "colBreaks")))
{
expect_start_element(qn("spreadsheetml", "brk"), xml::content::simple);
if (parser().attribute_present("id"))
{
ws.page_break_at_column(parser().attribute<column_t::index_t>("id"));
--count;
}
if (parser().attribute_present("man") && is_true(parser().attribute("man")))
{
--manual_break_count;
}
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
skip_attributes({"min", "max", "pt"});
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(qn("spreadsheetml", "brk"));
}
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "customProperties")) // CT_CustomProperties 0-1
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "cellWatches")) // CT_CellWatches 0-1
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "ignoredErrors")) // CT_IgnoredErrors 0-1
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "smartTags")) // CT_SmartTags 0-1
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "drawing")) // CT_Drawing 0-1
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "legacyDrawing"))
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_worksheet_element);
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_worksheet_element == qn("spreadsheetml", "extLst"))
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
{
extLst element round tripped
2018-06-25 19:12:35 +08:00
ext_list extensions(parser(), current_worksheet_element.namespace_());
ext_list parsing for worksheets
2018-06-24 17:25:58 +08:00
ws.d_->extension_list_.set(extensions);
get workbook.xml up to spec, closes #92
2016-12-11 03:46:21 +08:00
}
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
else
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
unexpected_element(current_worksheet_element);
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
}
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(current_worksheet_element);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(qn("spreadsheetml", "worksheet"));
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (manifest.has_relationship(sheet_path, xlnt::relationship_type::comments))
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
{
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
auto comments_part = manifest.canonicalize({workbook_rel, sheet_rel,
manifest.relationship(sheet_path, xlnt::relationship_type::comments)});
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto receive = xml::parser::receive_default;
auto comments_part_streambuf = archive_->open(comments_part);
std::istream comments_part_stream(comments_part_streambuf.get());
xml::parser parser(comments_part_stream, comments_part.string(), receive);
parser_ = &parser;
a little refactoring
2016-08-05 13:52:05 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
read_comments(ws);
a little refactoring
2016-08-05 13:52:05 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (manifest.has_relationship(sheet_path, xlnt::relationship_type::vml_drawing))
{
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
auto vml_drawings_part = manifest.canonicalize({workbook_rel, sheet_rel,
manifest.relationship(sheet_path, xlnt::relationship_type::vml_drawing)});
a little refactoring
2016-08-05 13:52:05 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto vml_drawings_part_streambuf = archive_->open(comments_part);
std::istream vml_drawings_part_stream(comments_part_streambuf.get());
xml::parser vml_parser(vml_drawings_part_stream, vml_drawings_part.string(), receive);
parser_ = &vml_parser;
a little refactoring
2016-08-05 13:52:05 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
read_vml_drawings(ws);
}
}
a little refactoring
2016-08-05 13:52:05 +08:00
start cleaning up code
2017-06-25 21:29:45 +08:00
return ws;
a little refactoring
2016-08-05 13:52:05 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
xml::parser &xlsx_consumer::parser()
a little refactoring
2016-08-05 13:52:05 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
return *parser_;
a little refactoring
2016-08-05 13:52:05 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
bool xlsx_consumer::has_cell()
a little refactoring
2016-08-05 13:52:05 +08:00
{
use memoization to replace cached static qnames
2017-09-09 06:03:56 +08:00
return in_element(qn("spreadsheetml", "row"))
|| in_element(qn("spreadsheetml", "sheetData"));
a little refactoring
2016-08-05 13:52:05 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
std::vector<relationship> xlsx_consumer::read_relationships(const path &part)
a little refactoring
2016-08-05 13:52:05 +08:00
{
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
const auto part_rels_path = part.parent().append("_rels").append(part.filename() + ".rels").relative_to(path("/"));
a little refactoring
2016-08-05 13:52:05 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
std::vector<xlnt::relationship> relationships;
if (!archive_->has_file(part_rels_path)) return relationships;
a little refactoring
2016-08-05 13:52:05 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto rels_streambuf = archive_->open(part_rels_path);
std::istream rels_stream(rels_streambuf.get());
xml::parser parser(rels_stream, part_rels_path.string());
parser_ = &parser;
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_start_element(qn("relationships", "Relationships"), xml::content::complex);
a little refactoring
2016-08-05 13:52:05 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(qn("relationships", "Relationships")))
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_start_element(qn("relationships", "Relationship"), xml::content::simple);
a little refactoring
2016-08-05 13:52:05 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
const auto target_mode = parser.attribute_present("TargetMode")
? parser.attribute<xlnt::target_mode>("TargetMode")
: xlnt::target_mode::internal;
auto target = xlnt::uri(parser.attribute("Target"));
a little refactoring
2016-08-05 13:52:05 +08:00
clarify target_mode namespace
2017-07-03 10:17:14 +08:00
if (target.path().is_absolute() && target_mode == xlnt::target_mode::internal)
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
{
target = uri(target.path().relative_to(path(part.string()).resolve(path("/"))).string());
}
a little refactoring
2016-08-05 13:52:05 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
relationships.emplace_back(parser.attribute("Id"),
parser.attribute<xlnt::relationship_type>("Type"),
xlnt::uri(part.string()), target, target_mode);
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(qn("relationships", "Relationship"));
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
}
a little refactoring
2016-08-05 13:52:05 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(qn("relationships", "Relationships"));
parser_ = nullptr;
a little refactoring
2016-08-05 13:52:05 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
return relationships;
a little refactoring
2016-08-05 13:52:05 +08:00
}
start cleaning up code
2017-06-25 21:29:45 +08:00
void xlsx_consumer::read_part(const std::vector<relationship> &rel_chain)
a little refactoring
2016-08-05 13:52:05 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
const auto &manifest = target_.manifest();
const auto part_path = manifest.canonicalize(rel_chain);
auto part_streambuf = archive_->open(part_path);
std::istream part_stream(part_streambuf.get());
xml::parser parser(part_stream, part_path.string());
parser_ = &parser;
a little refactoring
2016-08-05 13:52:05 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
switch (rel_chain.back().type())
{
case relationship_type::core_properties:
read_core_properties();
break;
clang-format all source files, fix broken test helpers--lots of cleanup necessary as a result [ci skip]
2016-12-24 23:04:57 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::extended_properties:
read_extended_properties();
break;
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::custom_properties:
read_custom_properties();
break;
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::office_document:
start cleaning up code
2017-06-25 21:29:45 +08:00
read_office_document(manifest.content_type(part_path));
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
break;
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::connections:
read_connections();
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::custom_xml_mappings:
read_custom_xml_mappings();
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::external_workbook_references:
read_external_workbook_references();
break;
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::pivot_table:
read_pivot_table();
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::shared_workbook_revision_headers:
read_shared_workbook_revision_headers();
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::volatile_dependencies:
read_volatile_dependencies();
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::shared_string_table:
read_shared_string_table();
break;
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::stylesheet:
read_stylesheet();
break;
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::theme:
read_theme();
break;
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::chartsheet:
read_chartsheet(rel_chain.back().id());
break;
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::dialogsheet:
read_dialogsheet(rel_chain.back().id());
break;
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::worksheet:
start cleaning up code
2017-06-25 21:29:45 +08:00
read_worksheet(rel_chain.back().id());
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
break;
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::thumbnail:
read_image(part_path);
break;
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::calculation_chain:
read_calculation_chain();
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::hyperlink:
break;
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::comments:
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::vml_drawing:
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::unknown:
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::printer_settings:
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::custom_property:
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::drawings:
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::pivot_table_cache_definition:
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::pivot_table_cache_records:
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::query_table:
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::shared_workbook:
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::revision_log:
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::shared_workbook_user_data:
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::single_cell_table_definitions:
break;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
case relationship_type::table_definition:
break;
case relationship_type::image:
read_image(part_path);
break;
}
parser_ = nullptr;
}
void xlsx_consumer::populate_workbook(bool streaming)
{
start cleaning up code
2017-06-25 21:29:45 +08:00
streaming_ = streaming;
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
target_.clear();
read_content_types();
const auto root_path = path("/");
for (const auto &package_rel : read_relationships(root_path))
{
manifest().register_relationship(package_rel);
}
for (auto package_rel : manifest().relationships(root_path))
{
if (package_rel.type() == relationship_type::office_document)
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
// Read the workbook after all the other package parts
continue;
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
start cleaning up code
2017-06-25 21:29:45 +08:00
read_part({package_rel});
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
for (const auto &relationship_source_string : archive_->files())
{
for (const auto &part_rel : read_relationships(path(relationship_source_string)))
{
manifest().register_relationship(part_rel);
}
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
read_part({manifest().relationship(root_path,
relationship_type::office_document)});
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
// Package Parts
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
void xlsx_consumer::read_content_types()
{
auto &manifest = target_.manifest();
auto content_types_streambuf = archive_->open(path("[Content_Types].xml"));
std::istream content_types_stream(content_types_streambuf.get());
xml::parser parser(content_types_stream, "[Content_Types].xml");
parser_ = &parser;
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_start_element(qn("content-types", "Types"), xml::content::complex);
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(qn("content-types", "Types")))
{
auto current_element = expect_start_element(xml::content::complex);
if (current_element == qn("content-types", "Default"))
{
auto extension = parser.attribute("Extension");
auto content_type = parser.attribute("ContentType");
manifest.register_default_type(extension, content_type);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_element == qn("content-types", "Override"))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto part_name = parser.attribute("PartName");
auto content_type = parser.attribute("ContentType");
manifest.register_override_type(path(part_name), content_type);
}
else
{
unexpected_element(current_element);
}
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(current_element);
}
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(qn("content-types", "Types"));
}
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
void xlsx_consumer::read_core_properties()
{
//qn("extended-properties", "Properties");
//qn("custom-properties", "Properties");
expect_start_element(qn("core-properties", "coreProperties"), xml::content::complex);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(qn("core-properties", "coreProperties")))
{
const auto property_element = expect_start_element(xml::content::simple);
const auto prop = detail::from_string<core_property>(property_element.name());
if (prop == core_property::created || prop == core_property::modified)
{
skip_attribute(qn("xsi", "type"));
}
target_.core_property(prop, read_text());
expect_end_element(property_element);
}
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(qn("core-properties", "coreProperties"));
}
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
void xlsx_consumer::read_extended_properties()
{
expect_start_element(qn("extended-properties", "Properties"), xml::content::complex);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(qn("extended-properties", "Properties")))
{
const auto property_element = expect_start_element(xml::content::mixed);
const auto prop = detail::from_string<extended_property>(property_element.name());
target_.extended_property(prop, read_variant());
expect_end_element(property_element);
}
expect_end_element(qn("extended-properties", "Properties"));
}
void xlsx_consumer::read_custom_properties()
{
expect_start_element(qn("custom-properties", "Properties"), xml::content::complex);
while (in_element(qn("custom-properties", "Properties")))
{
const auto property_element = expect_start_element(xml::content::complex);
const auto prop = parser().attribute("name");
const auto format_id = parser().attribute("fmtid");
const auto property_id = parser().attribute("pid");
target_.custom_property(prop, read_variant());
expect_end_element(property_element);
}
expect_end_element(qn("custom-properties", "Properties"));
}
start cleaning up code
2017-06-25 21:29:45 +08:00
void xlsx_consumer::read_office_document(const std::string &content_type) // CT_Workbook
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
{
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
if (content_type !=
"application/vnd."
"openxmlformats-officedocument.spreadsheetml.sheet.main+xml"
&& content_type !=
"application/vnd."
"openxmlformats-officedocument.spreadsheetml.template.main+xml")
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
{
throw xlnt::invalid_file(content_type);
}
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
start fixing serialization for #230
2017-09-28 20:55:16 +08:00
target_.d_->calculation_properties_.clear();
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_start_element(qn("workbook", "workbook"), xml::content::complex);
skip_attribute(qn("mc", "Ignorable"));
while (in_element(qn("workbook", "workbook")))
{
auto current_workbook_element = expect_start_element(xml::content::complex);
if (current_workbook_element == qn("workbook", "fileVersion")) // CT_FileVersion 0-1
{
detail::workbook_impl::file_version_t file_version;
if (parser().attribute_present("appName"))
{
file_version.app_name = parser().attribute("appName");
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("lastEdited"))
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
file_version.last_edited = parser().attribute<std::size_t>("lastEdited");
}
if (parser().attribute_present("lowestEdited"))
{
file_version.lowest_edited = parser().attribute<std::size_t>("lowestEdited");
}
if (parser().attribute_present("lowestEdited"))
{
file_version.rup_build = parser().attribute<std::size_t>("rupBuild");
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_attribute("codeName");
target_.d_->file_version_ = file_version;
}
else if (current_workbook_element == qn("workbook", "fileSharing")) // CT_FileSharing 0-1
{
skip_remaining_content(current_workbook_element);
}
implement abspath and archid flags, fixes some serialization problems
2018-05-29 11:13:57 +08:00
else if (current_workbook_element == qn("mc", "AlternateContent"))
{
while (in_element(qn("mc", "AlternateContent")))
{
auto alternate_content_element = expect_start_element(xml::content::complex);
if (alternate_content_element == qn("mc", "Choice")
&& parser().attribute_present("Requires")
&& parser().attribute("Requires") == "x15")
{
auto x15_element = expect_start_element(xml::content::simple);
if (x15_element == qn("x15ac", "absPath"))
{
target_.d_->abs_path_ = parser().attribute("url");
}
skip_remaining_content(x15_element);
expect_end_element(x15_element);
}
skip_remaining_content(alternate_content_element);
expect_end_element(alternate_content_element);
}
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_workbook_element == qn("workbook", "workbookPr")) // CT_WorkbookPr 0-1
{
target_.base_date(parser().attribute_present("date1904") // optional, bool=false
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
&& is_true(parser().attribute("date1904"))
? calendar::mac_1904
: calendar::windows_1900);
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_attribute("showObjects"); // optional, ST_Objects="all"
skip_attribute("showBorderUnselectedTables"); // optional, bool=true
skip_attribute("filterPrivacy"); // optional, bool=false
skip_attribute("promptedSolutions"); // optional, bool=false
skip_attribute("showInkAnnotation"); // optional, bool=true
skip_attribute("backupFile"); // optional, bool=false
skip_attribute("saveExternalLinkValues"); // optional, bool=true
skip_attribute("updateLinks"); // optional, ST_UpdateLinks="userSet"
skip_attribute("codeName"); // optional, string
skip_attribute("hidePivotFieldList"); // optional, bool=false
skip_attribute("showPivotChartFilter"); // optional, bool=false
skip_attribute("allowRefreshQuery"); // optional, bool=false
skip_attribute("publishItems"); // optional, bool=false
skip_attribute("checkCompatibility"); // optional, bool=false
skip_attribute("autoCompressPictures"); // optional, bool=true
skip_attribute("refreshAllConnections"); // optional, bool=false
skip_attribute("defaultThemeVersion"); // optional, uint
skip_attribute("dateCompatibility"); // optional, bool (undocumented)
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_workbook_element == qn("workbook", "workbookProtection")) // CT_WorkbookProtection 0-1
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_workbook_element);
}
else if (current_workbook_element == qn("workbook", "bookViews")) // CT_BookViews 0-1
{
while (in_element(qn("workbook", "bookViews")))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_start_element(qn("workbook", "workbookView"), xml::content::simple);
improve hyperlinks and style round tripping
2018-03-21 21:03:37 +08:00
skip_attributes({"firstSheet", "showHorizontalScroll",
"showSheetTabs", "showVerticalScroll"});
implement garbage collection to remove unreferenced formats and constituent parts
2016-11-08 10:11:30 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
workbook_view view;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("xWindow"))
ignore protectedRanges and make builtinId optional for styles, closes #82
2016-11-15 21:09:17 +08:00
{
fix xwindow bug fix xwindow bug
2017-08-27 13:44:06 +08:00
view.x_window = parser().attribute<int>("xWindow");
ignore protectedRanges and make builtinId optional for styles, closes #82
2016-11-15 21:09:17 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("yWindow"))
ignore protectedRanges and make builtinId optional for styles, closes #82
2016-11-15 21:09:17 +08:00
{
fix xwindow bug fix xwindow bug
2017-08-27 13:44:06 +08:00
view.y_window = parser().attribute<int>("yWindow");
ignore protectedRanges and make builtinId optional for styles, closes #82
2016-11-15 21:09:17 +08:00
}
implement garbage collection to remove unreferenced formats and constituent parts
2016-11-08 10:11:30 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("windowWidth"))
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
view.window_width = parser().attribute<std::size_t>("windowWidth");
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
}
implement garbage collection to remove unreferenced formats and constituent parts
2016-11-08 10:11:30 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("windowHeight"))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
view.window_height = parser().attribute<std::size_t>("windowHeight");
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("tabRatio"))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
view.tab_ratio = parser().attribute<std::size_t>("tabRatio");
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
improve hyperlinks and style round tripping
2018-03-21 21:03:37 +08:00
if (parser().attribute_present("activeTab"))
{
view.active_tab = parser().attribute<std::size_t>("activeTab");
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
target_.view(view);
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_attributes();
expect_end_element(qn("workbook", "workbookView"));
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_workbook_element == qn("workbook", "sheets")) // CT_Sheets 1
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
std::size_t index = 0;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(qn("workbook", "sheets")))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_start_element(qn("spreadsheetml", "sheet"), xml::content::simple);
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto title = parser().attribute("name");
skip_attribute("state");
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
sheet_title_index_map_[title] = index++;
sheet_title_id_map_[title] = parser().attribute<std::size_t>("sheetId");
target_.d_->sheet_title_rel_id_map_[title] = parser().attribute(qn("r", "id"));
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(qn("spreadsheetml", "sheet"));
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_workbook_element == qn("workbook", "functionGroups")) // CT_FunctionGroups 0-1
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(current_workbook_element);
}
else if (current_workbook_element == qn("workbook", "externalReferences")) // CT_ExternalReferences 0-1
{
skip_remaining_content(current_workbook_element);
}
else if (current_workbook_element == qn("workbook", "definedNames")) // CT_DefinedNames 0-1
{
skip_remaining_content(current_workbook_element);
}
else if (current_workbook_element == qn("workbook", "calcPr")) // CT_CalcPr 0-1
{
start fixing serialization for #230
2017-09-28 20:55:16 +08:00
xlnt::calculation_properties calc_props;
if (parser().attribute_present("calcId"))
{
calc_props.calc_id = parser().attribute<std::size_t>("calcId");
}
if (parser().attribute_present("concurrentCalc"))
{
calc_props.concurrent_calc = is_true(parser().attribute("concurrentCalc"));
}
target_.calculation_properties(calc_props);
parser().attribute_map(); // skip remaining
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
else if (current_workbook_element == qn("workbook", "oleSize")) // CT_OleSize 0-1
{
skip_remaining_content(current_workbook_element);
}
else if (current_workbook_element == qn("workbook", "customWorkbookViews")) // CT_CustomWorkbookViews 0-1
{
skip_remaining_content(current_workbook_element);
}
else if (current_workbook_element == qn("workbook", "pivotCaches")) // CT_PivotCaches 0-1
{
skip_remaining_content(current_workbook_element);
}
else if (current_workbook_element == qn("workbook", "smartTagPr")) // CT_SmartTagPr 0-1
{
skip_remaining_content(current_workbook_element);
}
else if (current_workbook_element == qn("workbook", "smartTagTypes")) // CT_SmartTagTypes 0-1
{
skip_remaining_content(current_workbook_element);
}
else if (current_workbook_element == qn("workbook", "webPublishing")) // CT_WebPublishing 0-1
{
skip_remaining_content(current_workbook_element);
}
else if (current_workbook_element == qn("workbook", "fileRecoveryPr")) // CT_FileRecoveryPr 0+
{
skip_remaining_content(current_workbook_element);
}
else if (current_workbook_element == qn("workbook", "webPublishObjects")) // CT_WebPublishObjects 0-1
{
skip_remaining_content(current_workbook_element);
}
else if (current_workbook_element == qn("workbook", "extLst")) // CT_ExtensionList 0-1
{
implement abspath and archid flags, fixes some serialization problems
2018-05-29 11:13:57 +08:00
while (in_element(qn("workbook", "extLst")))
{
auto extension_element = expect_start_element(xml::content::complex);
if (extension_element == qn("workbook", "ext")
&& parser().attribute_present("uri")
&& parser().attribute("uri") == "{7523E5D3-25F3-A5E0-1632-64F254C22452}")
{
auto arch_id_extension_element = expect_start_element(xml::content::simple);
if (arch_id_extension_element == qn("mx", "ArchID"))
{
target_.d_->arch_id_flags_ = parser().attribute<std::size_t>("Flags");
}
skip_remaining_content(arch_id_extension_element);
expect_end_element(arch_id_extension_element);
}
skip_remaining_content(extension_element);
expect_end_element(extension_element);
}
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
}
else
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
unexpected_element(current_workbook_element);
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(current_workbook_element);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(qn("workbook", "workbook"));
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto workbook_rel = manifest().relationship(path("/"), relationship_type::office_document);
auto workbook_path = workbook_rel.target().path();
comment changes anchor() , in element()
2017-02-07 06:00:45 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (manifest().has_relationship(workbook_path, relationship_type::shared_string_table))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
clarify target_mode namespace
2017-07-03 10:17:14 +08:00
read_part({workbook_rel,
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
manifest().relationship(workbook_path,
start cleaning up code
2017-06-25 21:29:45 +08:00
relationship_type::shared_string_table)});
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (manifest().has_relationship(workbook_path, relationship_type::stylesheet))
{
read_part({workbook_rel,
manifest().relationship(workbook_path,
start cleaning up code
2017-06-25 21:29:45 +08:00
relationship_type::stylesheet)});
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (manifest().has_relationship(workbook_path, relationship_type::theme))
{
read_part({workbook_rel,
clarify target_mode namespace
2017-07-03 10:17:14 +08:00
manifest().relationship(workbook_path,
start cleaning up code
2017-06-25 21:29:45 +08:00
relationship_type::theme)});
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
begin work on handling properties correctly
2017-01-15 03:09:01 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
for (auto worksheet_rel : manifest().relationships(workbook_path, relationship_type::worksheet))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
start implementing xlsx2arrow params
2017-07-20 08:21:55 +08:00
auto title = std::find_if(target_.d_->sheet_title_rel_id_map_.begin(),
target_.d_->sheet_title_rel_id_map_.end(),
[&](const std::pair<std::string, std::string> &p) {
return p.second == worksheet_rel.id();
Cleanup from review
2018-06-26 16:32:59 +08:00
})->first;
start implementing xlsx2arrow params
2017-07-20 08:21:55 +08:00
auto id = sheet_title_id_map_[title];
auto index = sheet_title_index_map_[title];
auto insertion_iter = target_.d_->worksheets_.begin();
while (insertion_iter != target_.d_->worksheets_.end() && sheet_title_index_map_[insertion_iter->title_] < index)
{
++insertion_iter;
}
current_worksheet_ = &*target_.d_->worksheets_.emplace(insertion_iter, &target_, id, title);
if (!streaming_)
{
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
read_part({workbook_rel, worksheet_rel});
start implementing xlsx2arrow params
2017-07-20 08:21:55 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
// Write Workbook Relationship Target Parts
optimize format garbage collection and apply style fills to formats correctly, fixes #79, fix cell iteration, closes #73, add third-party licenses to LICENSE.md, update README, fix all clang and msvc warnings
2016-11-10 08:52:18 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
void xlsx_consumer::read_calculation_chain()
{
}
optimize format garbage collection and apply style fills to formats correctly, fixes #79, fix cell iteration, closes #73, add third-party licenses to LICENSE.md, update README, fix all clang and msvc warnings
2016-11-10 08:52:18 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
void xlsx_consumer::read_chartsheet(const std::string & /*title*/)
{
a little refactoring
2016-08-05 13:52:05 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
void xlsx_consumer::read_connections()
a little refactoring
2016-08-05 13:52:05 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
void xlsx_consumer::read_custom_property()
{
}
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
void xlsx_consumer::read_custom_xml_mappings()
{
}
void xlsx_consumer::read_dialogsheet(const std::string & /*title*/)
{
}
void xlsx_consumer::read_external_workbook_references()
{
}
void xlsx_consumer::read_pivot_table()
{
}
void xlsx_consumer::read_shared_string_table()
{
expect_start_element(qn("spreadsheetml", "sst"), xml::content::complex);
skip_attributes({"count"});
bool has_unique_count = false;
std::size_t unique_count = 0;
if (parser().attribute_present("uniqueCount"))
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
has_unique_count = true;
unique_count = parser().attribute<std::size_t>("uniqueCount");
}
auto &strings = target_.shared_strings();
while (in_element(qn("spreadsheetml", "sst")))
{
expect_start_element(qn("spreadsheetml", "si"), xml::content::complex);
strings.push_back(read_rich_text(qn("spreadsheetml", "si")));
expect_end_element(qn("spreadsheetml", "si"));
}
expect_end_element(qn("spreadsheetml", "sst"));
if (has_unique_count && unique_count != strings.size())
{
throw invalid_file("sizes don't match");
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
}
a little refactoring
2016-08-05 13:52:05 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
void xlsx_consumer::read_shared_workbook_revision_headers()
{
}
void xlsx_consumer::read_shared_workbook()
{
}
void xlsx_consumer::read_shared_workbook_user_data()
a little refactoring
2016-08-05 13:52:05 +08:00
{
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
void xlsx_consumer::read_stylesheet()
{
target_.impl().stylesheet_ = detail::stylesheet();
auto &stylesheet = target_.impl().stylesheet_.get();
expect_start_element(qn("spreadsheetml", "styleSheet"), xml::content::complex);
skip_attributes({qn("mc", "Ignorable")});
std::vector<std::pair<style_impl, std::size_t>> styles;
std::vector<std::pair<format_impl, std::size_t>> format_records;
std::vector<std::pair<format_impl, std::size_t>> style_records;
while (in_element(qn("spreadsheetml", "styleSheet")))
{
auto current_style_element = expect_start_element(xml::content::complex);
if (current_style_element == qn("spreadsheetml", "borders"))
{
auto &borders = stylesheet.borders;
auto count = parser().attribute<std::size_t>("count");
while (in_element(qn("spreadsheetml", "borders")))
{
borders.push_back(xlnt::border());
auto &border = borders.back();
expect_start_element(qn("spreadsheetml", "border"), xml::content::complex);
auto diagonal = diagonal_direction::neither;
if (parser().attribute_present("diagonalDown") && parser().attribute("diagonalDown") == "1")
{
diagonal = diagonal_direction::down;
}
if (parser().attribute_present("diagonalUp") && parser().attribute("diagonalUp") == "1")
{
diagonal = diagonal == diagonal_direction::down ? diagonal_direction::both : diagonal_direction::up;
}
if (diagonal != diagonal_direction::neither)
{
border.diagonal(diagonal);
}
while (in_element(qn("spreadsheetml", "border")))
{
auto current_side_element = expect_start_element(xml::content::complex);
xlnt::border::border_property side;
if (parser().attribute_present("style"))
{
side.style(parser().attribute<xlnt::border_style>("style"));
}
if (in_element(current_side_element))
{
expect_start_element(qn("spreadsheetml", "color"), xml::content::complex);
side.color(read_color());
expect_end_element(qn("spreadsheetml", "color"));
}
expect_end_element(current_side_element);
auto side_type = xml::value_traits<xlnt::border_side>::parse(current_side_element.name(), parser());
border.side(side_type, side);
}
a little refactoring
2016-08-05 13:52:05 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(qn("spreadsheetml", "border"));
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (count != borders.size())
{
throw xlnt::exception("border counts don't match");
}
}
else if (current_style_element == qn("spreadsheetml", "fills"))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto &fills = stylesheet.fills;
auto count = parser().attribute<std::size_t>("count");
while (in_element(qn("spreadsheetml", "fills")))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
fills.push_back(xlnt::fill());
auto &new_fill = fills.back();
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_start_element(qn("spreadsheetml", "fill"), xml::content::complex);
auto fill_element = expect_start_element(xml::content::complex);
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (fill_element == qn("spreadsheetml", "patternFill"))
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
xlnt::pattern_fill pattern;
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("patternType"))
{
pattern.type(parser().attribute<xlnt::pattern_fill_type>("patternType"));
while (in_element(qn("spreadsheetml", "patternFill")))
{
auto pattern_type_element = expect_start_element(xml::content::complex);
if (pattern_type_element == qn("spreadsheetml", "fgColor"))
{
pattern.foreground(read_color());
}
else if (pattern_type_element == qn("spreadsheetml", "bgColor"))
{
pattern.background(read_color());
}
else
{
unexpected_element(pattern_type_element);
}
expect_end_element(pattern_type_element);
}
}
new_fill = pattern;
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (fill_element == qn("spreadsheetml", "gradientFill"))
{
xlnt::gradient_fill gradient;
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("type"))
{
gradient.type(parser().attribute<xlnt::gradient_fill_type>("type"));
}
else
{
gradient.type(xlnt::gradient_fill_type::linear);
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(qn("spreadsheetml", "gradientFill")))
{
expect_start_element(qn("spreadsheetml", "stop"), xml::content::complex);
auto position = parser().attribute<double>("position");
expect_start_element(qn("spreadsheetml", "color"), xml::content::complex);
auto color = read_color();
expect_end_element(qn("spreadsheetml", "color"));
expect_end_element(qn("spreadsheetml", "stop"));
gradient.add_stop(position, color);
}
new_fill = gradient;
}
else
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
unexpected_element(fill_element);
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(fill_element);
expect_end_element(qn("spreadsheetml", "fill"));
}
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (count != fills.size())
{
throw xlnt::exception("counts don't match");
}
}
else if (current_style_element == qn("spreadsheetml", "fonts"))
{
auto &fonts = stylesheet.fonts;
auto count = parser().attribute<std::size_t>("count");
improve hyperlinks and style round tripping
2018-03-21 21:03:37 +08:00
if (parser().attribute_present(qn("x14ac", "knownFonts")))
{
target_.enable_known_fonts();
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(qn("spreadsheetml", "fonts")))
{
fonts.push_back(xlnt::font());
auto &new_font = stylesheet.fonts.back();
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_start_element(qn("spreadsheetml", "font"), xml::content::complex);
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(qn("spreadsheetml", "font")))
{
auto font_property_element = expect_start_element(xml::content::simple);
clang-format all source files, fix broken test helpers--lots of cleanup necessary as a result [ci skip]
2016-12-24 23:04:57 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (font_property_element == qn("spreadsheetml", "sz"))
{
new_font.size(parser().attribute<double>("val"));
}
else if (font_property_element == qn("spreadsheetml", "name"))
{
new_font.name(parser().attribute("val"));
}
else if (font_property_element == qn("spreadsheetml", "color"))
{
new_font.color(read_color());
}
else if (font_property_element == qn("spreadsheetml", "family"))
{
new_font.family(parser().attribute<std::size_t>("val"));
}
else if (font_property_element == qn("spreadsheetml", "scheme"))
{
new_font.scheme(parser().attribute("val"));
}
else if (font_property_element == qn("spreadsheetml", "b"))
{
if (parser().attribute_present("val"))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
new_font.bold(is_true(parser().attribute("val")));
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
new_font.bold(true);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
else if (font_property_element == qn("spreadsheetml", "vertAlign"))
{
improve hyperlinks and style round tripping
2018-03-21 21:03:37 +08:00
auto vert_align = parser().attribute("val");
if (vert_align == "superscript")
{
new_font.superscript(true);
}
else if (vert_align == "subscript")
{
new_font.subscript(true);
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
else if (font_property_element == qn("spreadsheetml", "strike"))
{
if (parser().attribute_present("val"))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
new_font.strikethrough(is_true(parser().attribute("val")));
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
else
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
new_font.strikethrough(true);
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
}
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (font_property_element == qn("spreadsheetml", "outline"))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("val"))
{
new_font.outline(is_true(parser().attribute("val")));
}
else
{
new_font.outline(true);
}
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (font_property_element == qn("spreadsheetml", "shadow"))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("val"))
optimize shared strings and handle formula strings correctly
2017-05-10 20:44:25 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
new_font.shadow(is_true(parser().attribute("val")));
optimize shared strings and handle formula strings correctly
2017-05-10 20:44:25 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
new_font.shadow(true);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
else if (font_property_element == qn("spreadsheetml", "i"))
{
if (parser().attribute_present("val"))
clean up cell deserialization for #103
2017-01-01 09:05:10 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
new_font.italic(is_true(parser().attribute("val")));
clean up cell deserialization for #103
2017-01-01 09:05:10 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else
clean up cell deserialization for #103
2017-01-01 09:05:10 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
new_font.italic(true);
clean up cell deserialization for #103
2017-01-01 09:05:10 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
else if (font_property_element == qn("spreadsheetml", "u"))
{
if (parser().attribute_present("val"))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
new_font.underline(parser().attribute<xlnt::font::underline_style>("val"));
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else
clean up cell deserialization for #103
2017-01-01 09:05:10 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
new_font.underline(xlnt::font::underline_style::single);
clean up cell deserialization for #103
2017-01-01 09:05:10 +08:00
}
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (font_property_element == qn("spreadsheetml", "charset"))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("val"))
{
parser().attribute("val");
}
}
else
{
unexpected_element(font_property_element);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(font_property_element);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
fix some xlsx consumption and production
2016-10-14 08:11:02 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(qn("spreadsheetml", "font"));
}
if (count != stylesheet.fonts.size())
{
throw xlnt::exception("counts don't match");
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_style_element == qn("spreadsheetml", "numFmts"))
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto &number_formats = stylesheet.number_formats;
auto count = parser().attribute<std::size_t>("count");
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(qn("spreadsheetml", "numFmts")))
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_start_element(qn("spreadsheetml", "numFmt"), xml::content::simple);
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto format_string = parser().attribute("formatCode");
if (format_string == "GENERAL")
{
format_string = "General";
}
xlnt::number_format nf;
nf.format_string(format_string);
nf.id(parser().attribute<std::size_t>("numFmtId"));
expect_end_element(qn("spreadsheetml", "numFmt"));
number_formats.push_back(nf);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (count != number_formats.size())
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
throw xlnt::exception("counts don't match");
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
}
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_style_element == qn("spreadsheetml", "cellStyles"))
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto count = parser().attribute<std::size_t>("count");
while (in_element(qn("spreadsheetml", "cellStyles")))
parse relationship mode and implement reading hyperlinks, closes #87
2016-11-30 08:05:47 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto &data = *styles.emplace(styles.end());
parse relationship mode and implement reading hyperlinks, closes #87
2016-11-30 08:05:47 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_start_element(qn("spreadsheetml", "cellStyle"), xml::content::simple);
parse relationship mode and implement reading hyperlinks, closes #87
2016-11-30 08:05:47 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
data.first.name = parser().attribute("name");
data.second = parser().attribute<std::size_t>("xfId");
if (parser().attribute_present("builtinId"))
parse relationship mode and implement reading hyperlinks, closes #87
2016-11-30 08:05:47 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
data.first.builtin_id = parser().attribute<std::size_t>("builtinId");
}
fix up comments, hyperlinks, and formulae consumption tests
2017-01-22 08:12:26 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("hidden"))
{
data.first.hidden_style = is_true(parser().attribute("hidden"));
parse relationship mode and implement reading hyperlinks, closes #87
2016-11-30 08:05:47 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("customBuiltin"))
{
data.first.custom_builtin = is_true(parser().attribute("customBuiltin"));
}
expect_end_element(qn("spreadsheetml", "cellStyle"));
}
if (count != styles.size())
{
throw xlnt::exception("counts don't match");
parse relationship mode and implement reading hyperlinks, closes #87
2016-11-30 08:05:47 +08:00
}
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_style_element == qn("spreadsheetml", "cellStyleXfs")
|| current_style_element == qn("spreadsheetml", "cellXfs"))
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto in_style_records = current_style_element.name() == "cellStyleXfs";
auto count = parser().attribute<std::size_t>("count");
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(current_style_element))
{
expect_start_element(qn("spreadsheetml", "xf"), xml::content::complex);
unskip another round-trip test, making progress
2016-09-22 07:04:16 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto &record = *(!in_style_records
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
? format_records.emplace(format_records.end())
: style_records.emplace(style_records.end()));
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
work on round-tripping for #230
2018-04-25 07:43:34 +08:00
if (parser().attribute_present("applyBorder"))
{
record.first.border_applied = is_true(parser().attribute("applyBorder"));
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
record.first.border_id = parser().attribute_present("borderId")
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
? parser().attribute<std::size_t>("borderId")
: 0;
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
work on round-tripping for #230
2018-04-25 07:43:34 +08:00
if (parser().attribute_present("applyFill"))
{
record.first.fill_applied = is_true(parser().attribute("applyFill"));
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
record.first.fill_id = parser().attribute_present("fillId")
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
? parser().attribute<std::size_t>("fillId")
: 0;
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
work on round-tripping for #230
2018-04-25 07:43:34 +08:00
if (parser().attribute_present("applyFont"))
{
record.first.font_applied = is_true(parser().attribute("applyFont"));
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
record.first.font_id = parser().attribute_present("fontId")
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
? parser().attribute<std::size_t>("fontId")
: 0;
organize detail files, start wiring up encryption logic
2017-04-21 02:03:03 +08:00
work on round-tripping for #230
2018-04-25 07:43:34 +08:00
if (parser().attribute_present("applyNumberFormat"))
{
record.first.number_format_applied = is_true(parser().attribute("applyNumberFormat"));
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
record.first.number_format_id = parser().attribute_present("numFmtId")
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
? parser().attribute<std::size_t>("numFmtId")
: 0;
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto apply_alignment_present = parser().attribute_present("applyAlignment");
work on round-tripping for #230
2018-04-25 07:43:34 +08:00
if (apply_alignment_present)
{
record.first.alignment_applied = is_true(parser().attribute("applyAlignment"));
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto apply_protection_present = parser().attribute_present("applyProtection");
work on round-tripping for #230
2018-04-25 07:43:34 +08:00
if (apply_protection_present)
{
record.first.protection_applied = is_true(parser().attribute("applyProtection"));
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
record.first.pivot_button_ = parser().attribute_present("pivotButton")
&& is_true(parser().attribute("pivotButton"));
record.first.quote_prefix_ = parser().attribute_present("quotePrefix")
&& is_true(parser().attribute("quotePrefix"));
continue work on #230, improves style/xf handling
2017-10-27 00:54:54 +08:00
if (parser().attribute_present("xfId"))
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
record.second = parser().attribute<std::size_t>("xfId");
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(qn("spreadsheetml", "xf")))
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto xf_child_element = expect_start_element(xml::content::simple);
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (xf_child_element == qn("spreadsheetml", "alignment"))
{
record.first.alignment_id = stylesheet.alignments.size();
auto &alignment = *stylesheet.alignments.emplace(stylesheet.alignments.end());
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("wrapText"))
{
alignment.wrap(is_true(parser().attribute("wrapText")));
}
if (parser().attribute_present("shrinkToFit"))
{
alignment.shrink(is_true(parser().attribute("shrinkToFit")));
}
if (parser().attribute_present("indent"))
{
alignment.indent(parser().attribute<int>("indent"));
}
if (parser().attribute_present("textRotation"))
{
alignment.rotation(parser().attribute<int>("textRotation"));
}
if (parser().attribute_present("vertical"))
{
alignment.vertical(parser().attribute<xlnt::vertical_alignment>("vertical"));
}
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (parser().attribute_present("horizontal"))
{
alignment.horizontal(parser().attribute<xlnt::horizontal_alignment>("horizontal"));
}
Parse readingOrder
2017-09-13 04:04:52 +08:00
if (parser().attribute_present("readingOrder"))
{
parser().attribute<int>("readingOrder");
}
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (xf_child_element == qn("spreadsheetml", "protection"))
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
record.first.protection_id = stylesheet.protections.size();
auto &protection = *stylesheet.protections.emplace(stylesheet.protections.end());
protection.locked(parser().attribute_present("locked")
&& is_true(parser().attribute("locked")));
protection.hidden(parser().attribute_present("hidden")
&& is_true(parser().attribute("hidden")));
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
unexpected_element(xf_child_element);
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(xf_child_element);
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(qn("spreadsheetml", "xf"));
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if ((in_style_records && count != style_records.size())
|| (!in_style_records && count != format_records.size()))
{
throw xlnt::exception("counts don't match");
}
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_style_element == qn("spreadsheetml", "dxfs"))
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto count = parser().attribute<std::size_t>("count");
std::size_t processed = 0;
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(current_style_element))
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto current_element = expect_start_element(xml::content::mixed);
skip_remaining_content(current_element);
expect_end_element(current_element);
++processed;
}
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (count != processed)
{
throw xlnt::exception("counts don't match");
}
}
else if (current_style_element == qn("spreadsheetml", "tableStyles"))
{
skip_attribute("defaultTableStyle");
skip_attribute("defaultPivotStyle");
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto count = parser().attribute<std::size_t>("count");
std::size_t processed = 0;
clang-format all source files, fix broken test helpers--lots of cleanup necessary as a result [ci skip]
2016-12-24 23:04:57 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(qn("spreadsheetml", "tableStyles")))
{
auto current_element = expect_start_element(xml::content::complex);
skip_remaining_content(current_element);
expect_end_element(current_element);
++processed;
}
if (count != processed)
{
throw xlnt::exception("counts don't match");
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
}
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (current_style_element == qn("spreadsheetml", "extLst"))
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
{
work on hyperlinks, x14 extentions, other round tripping silliness
2018-03-17 09:21:16 +08:00
while (in_element(qn("spreadsheetml", "extLst")))
{
expect_start_element(qn("spreadsheetml", "ext"), xml::content::complex);
const auto uri = parser().attribute("uri");
if (uri == "{EB79DEF2-80B8-43e5-95BD-54CBDDF9020C}") // slicerStyles
{
expect_start_element(qn("x14", "slicerStyles"), xml::content::simple);
stylesheet.default_slicer_style = parser().attribute("defaultSlicerStyle");
expect_end_element(qn("x14", "slicerStyles"));
}
else
{
skip_remaining_content(qn("spreadsheetml", "ext"));
}
expect_end_element(qn("spreadsheetml", "ext"));
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
else if (current_style_element == qn("spreadsheetml", "colors")) // CT_Colors 0-1
{
while (in_element(qn("spreadsheetml", "colors")))
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto colors_child_element = expect_start_element(xml::content::complex);
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (colors_child_element == qn("spreadsheetml", "indexedColors")) // CT_IndexedColors 0-1
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
while (in_element(colors_child_element))
{
expect_start_element(qn("spreadsheetml", "rgbColor"), xml::content::simple);
stylesheet.colors.push_back(read_color());
expect_end_element(qn("spreadsheetml", "rgbColor"));
}
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else if (colors_child_element == qn("spreadsheetml", "mruColors")) // CT_MRUColors
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
skip_remaining_content(colors_child_element);
}
else
{
unexpected_element(colors_child_element);
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(colors_child_element);
finish full header/footer implementation, add support for page breaks, clean up row/column properties interface
2016-12-23 07:57:22 +08:00
}
finally figured out how to decrypt with botan--swapping back out for botan
2016-10-25 10:09:15 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
else
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
unexpected_element(current_style_element);
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
expect_end_element(current_style_element);
}
expect_end_element(qn("spreadsheetml", "styleSheet"));
std::size_t xf_id = 0;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
for (const auto &record : style_records)
{
auto style_iter = std::find_if(styles.begin(), styles.end(),
[&xf_id](const std::pair<style_impl, std::size_t> &s) { return s.second == xf_id; });
++xf_id;
implement reading of cell comments
2016-10-29 22:23:04 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
if (style_iter == styles.end()) continue;
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
auto new_style = stylesheet.create_style(style_iter->first.name);
add failing tests and begin restructuring worksheet reading [ci skip]
2017-06-17 22:53:37 +08:00
continue work on #230, improves style/xf handling
2017-10-27 00:54:54 +08:00
new_style.d_->pivot_button_ = style_iter->first.pivot_button_;
new_style.d_->quote_prefix_ = style_iter->first.quote_prefix_;
new_style.d_->formatting_record_id = style_iter->first.formatting_record_id;
new_style.d_->hidden_style = style_iter->first.hidden_style;
new_style.d_->custom_builtin = style_iter->first.custom_builtin;
new_style.d_->hidden_style = style_iter->first.hidden_style;
new_style.d_->builtin_id = style_iter->first.builtin_id;
new_style.d_->outline_style = style_iter->first.outline_style;
new_style.d_->alignment_applied = record.first.alignment_applied;
new_style.d_->alignment_id = record.first.alignment_id;
new_style.d_->border_applied = record.first.border_applied;
new_style.d_->border_id = record.first.border_id;
new_style.d_->fill_applied = record.first.fill_applied;
new_style.d_->fill_id = record.first.fill_id;
new_style.d_->font_applied = record.first.font_applied;
new_style.d_->font_id = record.first.font_id;
new_style.d_->number_format_applied = record.first.number_format_applied;
new_style.d_->number_format_id = record.first.number_format_id;
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
continue work on #230, improves style/xf handling
2017-10-27 00:54:54 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
std::size_t record_index = 0;
for (const auto &record : format_records)
implement reading of cell comments
2016-10-29 22:23:04 +08:00
{
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
stylesheet.format_impls.push_back(format_impl());
auto &new_format = stylesheet.format_impls.back();
use streams to access zip files and their contents instead of std::stringstream to reduce memory usage, replaces miniz with zlib, closes #66
2016-10-31 03:48:40 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
new_format.id = record_index++;
new_format.parent = &stylesheet;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
++new_format.references;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
new_format.alignment_id = record.first.alignment_id;
new_format.alignment_applied = record.first.alignment_applied;
new_format.border_id = record.first.border_id;
new_format.border_applied = record.first.border_applied;
new_format.fill_id = record.first.fill_id;
new_format.fill_applied = record.first.fill_applied;
new_format.font_id = record.first.font_id;
new_format.font_applied = record.first.font_applied;
new_format.number_format_id = record.first.number_format_id;
new_format.number_format_applied = record.first.number_format_applied;
new_format.protection_id = record.first.protection_id;
new_format.protection_applied = record.first.protection_applied;
new_format.pivot_button_ = record.first.pivot_button_;
new_format.quote_prefix_ = record.first.quote_prefix_;
continue work on #230, improves style/xf handling
2017-10-27 00:54:54 +08:00
Fix bug in cell style assingment There was a bug introduced in version 1.2 in reading styles. As from the Office Open XML documentation:
2017-11-06 18:55:06 +08:00
set_style_by_xfid(styles, record.second, new_format.style);
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
}
}
implement reading of cell comments
2016-10-29 22:23:04 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
void xlsx_consumer::read_theme()
{
auto workbook_rel = manifest().relationship(path("/"),
relationship_type::office_document);
clarify target_mode namespace
2017-07-03 10:17:14 +08:00
auto theme_rel = manifest().relationship(workbook_rel.target().path(),
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
relationship_type::theme);
auto theme_path = manifest().canonicalize({workbook_rel, theme_rel});
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
target_.theme(theme());
if (manifest().has_relationship(theme_path, relationship_type::image))
{
read_part({workbook_rel, theme_rel,
clarify target_mode namespace
2017-07-03 10:17:14 +08:00
manifest().relationship(theme_path,
start cleaning up code
2017-06-25 21:29:45 +08:00
relationship_type::image)});
implement reading of cell comments
2016-10-29 22:23:04 +08:00
}
a little refactoring
2016-08-05 13:52:05 +08:00
}
work out how to handle worksheet rels during streaming parsing
2017-06-21 21:17:06 +08:00
void xlsx_consumer::read_volatile_dependencies()
{
}
a little refactoring
2016-08-05 13:52:05 +08:00
// Sheet Relationship Target Parts
clang-format all source files, fix broken test helpers--lots of cleanup necessary as a result [ci skip]
2016-12-24 23:04:57 +08:00
void xlsx_consumer::read_vml_drawings(worksheet /*ws*/)
clean up comment reading and sketch out vml drawing reading
2016-11-14 00:52:39 +08:00
{
}
implement reading of cell comments
2016-10-29 22:23:04 +08:00
void xlsx_consumer::read_comments(worksheet ws)
a little refactoring
2016-08-05 13:52:05 +08:00
{
implement reading of cell comments
2016-10-29 22:23:04 +08:00
std::vector<std::string> authors;
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
expect_start_element(qn("spreadsheetml", "comments"), xml::content::complex);
comment change skip "mc:Ignorable" attribut and "mc:alternateContent" concern location of the comment "the Ignorable attribute specifies namespaces that can be ignored when they are not understood by the consuming application. Alternate-Content elements specify markup alternatives that can be chosen by an application at run time. For example, Word 2013 can choose only the markup alternative that it recognizes. The complete list of compatibility-rule attributes and alternate-content elements and their details can be found in the specification. " and so to implement
2017-02-25 18:50:45 +08:00
// name space can be ignored
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
skip_attribute(qn("mc", "Ignorable"));
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
expect_start_element(qn("spreadsheetml", "authors"), xml::content::complex);
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
while (in_element(qn("spreadsheetml", "authors")))
implement reading of cell comments
2016-10-29 22:23:04 +08:00
{
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
expect_start_element(qn("spreadsheetml", "author"), xml::content::simple);
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
authors.push_back(read_text());
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
expect_end_element(qn("spreadsheetml", "author"));
implement reading of cell comments
2016-10-29 22:23:04 +08:00
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
expect_end_element(qn("spreadsheetml", "authors"));
expect_start_element(qn("spreadsheetml", "commentList"), xml::content::complex);
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
while (in_element(xml::qname(qn("spreadsheetml", "commentList"))))
implement reading of cell comments
2016-10-29 22:23:04 +08:00
{
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
expect_start_element(qn("spreadsheetml", "comment"), xml::content::complex);
implement reading of cell comments
2016-10-29 22:23:04 +08:00
skip comment "shapeId"
2017-02-07 22:13:34 +08:00
skip_attribute("shapeId");
minor cleanup
2017-02-19 10:33:59 +08:00
auto cell_ref = parser().attribute("ref");
implement reading of cell comments
2016-10-29 22:23:04 +08:00
auto author_id = parser().attribute<std::size_t>("authorId");
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
expect_start_element(qn("spreadsheetml", "text"), xml::content::complex);
implement reading of cell comments
2016-10-29 22:23:04 +08:00
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
ws.cell(cell_ref).comment(comment(read_rich_text(qn("spreadsheetml", "text")), authors.at(author_id)));
implement writing comments, still need to fix comment vml
2016-10-30 04:31:30 +08:00
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
expect_end_element(qn("spreadsheetml", "text"));
only expect alternatecontent if it's present
2017-03-10 10:35:36 +08:00
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
if (in_element(xml::qname(qn("spreadsheetml", "comment"))))
{
expect_start_element(qn("mc", "AlternateContent"), xml::content::complex);
skip_remaining_content(qn("mc", "AlternateContent"));
expect_end_element(qn("mc", "AlternateContent"));
}
only expect alternatecontent if it's present
2017-03-10 10:35:36 +08:00
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
expect_end_element(qn("spreadsheetml", "comment"));
implement reading of cell comments
2016-10-29 22:23:04 +08:00
}
reformat xlsx_consumer.cpp
2016-11-20 06:19:38 +08:00
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
expect_end_element(qn("spreadsheetml", "commentList"));
expect_end_element(qn("spreadsheetml", "comments"));
a little refactoring
2016-08-05 13:52:05 +08:00
}
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
void xlsx_consumer::read_drawings()
a little refactoring
2016-08-05 13:52:05 +08:00
{
}
// Unknown Parts
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
void xlsx_consumer::read_unknown_parts()
a little refactoring
2016-08-05 13:52:05 +08:00
{
}
move parser parameter into a field, document some methods
2016-10-12 11:16:14 +08:00
void xlsx_consumer::read_unknown_relationships()
a little refactoring
2016-08-05 13:52:05 +08:00
{
}
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
void xlsx_consumer::read_image(const xlnt::path &image_path)
{
clang-format all source files, fix broken test helpers--lots of cleanup necessary as a result [ci skip]
2016-12-24 23:04:57 +08:00
auto image_streambuf = archive_->open(image_path);
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
vector_ostreambuf buffer(target_.d_->images_[image_path.string()]);
std::ostream out_stream(&buffer);
clang-format all source files, fix broken test helpers--lots of cleanup necessary as a result [ci skip]
2016-12-24 23:04:57 +08:00
out_stream << image_streambuf.get();
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
}
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
std::string xlsx_consumer::read_text()
{
auto text = std::string();
while (parser().peek() == xml::parser::event_type::characters)
{
parser().next_expect(xml::parser::event_type::characters);
text.append(parser().value());
}
return text;
}
hardcode enum serialization/deserialization, improve metadata property comsumption
2017-01-17 02:05:19 +08:00
variant xlsx_consumer::read_variant()
{
auto value = variant(read_text());
if (in_element(stack_.back()))
{
auto element = expect_start_element(xml::content::mixed);
auto text = read_text();
if (element == qn("vt", "lpwstr") || element == qn("vt", "lpstr"))
{
value = variant(text);
}
if (element == qn("vt", "i4"))
{
value = variant(std::stoi(text));
}
custom-properties bool variant change i4 to bool
2017-01-23 02:34:40 +08:00
if (element == qn("vt", "bool"))
{
recommit "rename some things and fix some formatting"
2017-02-15 05:33:54 +08:00
value = variant(is_true(text));
custom-properties bool variant change i4 to bool
2017-01-23 02:34:40 +08:00
}
hardcode enum serialization/deserialization, improve metadata property comsumption
2017-01-17 02:05:19 +08:00
else if (element == qn("vt", "vector"))
{
auto size = parser().attribute<std::size_t>("size");
auto base_type = parser().attribute("baseType");
std::vector<variant> vector;
for (auto i = std::size_t(0); i < size; ++i)
{
if (base_type == "variant")
{
expect_start_element(qn("vt", "variant"), xml::content::complex);
}
vector.push_back(read_variant());
if (base_type == "variant")
{
expect_end_element(qn("vt", "variant"));
read_text();
}
}
value = variant(vector);
}
expect_end_element(element);
read_text();
}
return value;
}
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
void xlsx_consumer::skip_attributes(const std::vector<std::string> &names)
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
{
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
for (const auto &name : names)
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
{
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
if (parser().attribute_present(name))
{
parser().attribute(name);
}
}
}
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
void xlsx_consumer::skip_attributes(const std::vector<xml::qname> &names)
{
for (const auto &name : names)
{
if (parser().attribute_present(name))
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
{
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
parser().attribute(name);
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
}
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
}
}
void xlsx_consumer::skip_attributes()
{
parser().attribute_map();
}
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
void xlsx_consumer::skip_attribute(const xml::qname &name)
{
if (parser().attribute_present(name))
{
parser().attribute(name);
}
}
void xlsx_consumer::skip_attribute(const std::string &name)
{
if (parser().attribute_present(name))
{
parser().attribute(name);
}
}
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
void xlsx_consumer::skip_remaining_content(const xml::qname &name)
{
// start by assuming we've already parsed the opening tag
skip_attributes();
read_text();
// continue until the closing tag is reached
while (in_element(name))
{
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
auto child_element = expect_start_element(xml::content::mixed);
skip_remaining_content(child_element);
expect_end_element(child_element);
read_text(); // trailing character content (usually whitespace)
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
}
}
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
bool xlsx_consumer::in_element(const xml::qname &name)
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
{
recommit "rename some things and fix some formatting"
2017-02-15 05:33:54 +08:00
return parser().peek() != xml::parser::event_type::end_element
&& stack_.back() == name;
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
}
xml::qname xlsx_consumer::expect_start_element(xml::content content)
{
parser().next_expect(xml::parser::event_type::start_element);
parser().content(content);
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
stack_.push_back(parser().qname());
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
const auto xml_space = qn("xml", "space");
clang-format all source files, fix broken test helpers--lots of cleanup necessary as a result [ci skip]
2016-12-24 23:04:57 +08:00
preserve_space_ = parser().attribute_present(xml_space) ? parser().attribute(xml_space) == "preserve" : false;
handle xml:space, closes #95
2016-12-14 15:23:49 +08:00
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
return stack_.back();
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
}
void xlsx_consumer::expect_start_element(const xml::qname &name, xml::content content)
{
parser().next_expect(xml::parser::event_type::start_element, name);
parser().content(content);
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
stack_.push_back(name);
handle xml:space, closes #95
2016-12-14 15:23:49 +08:00
clean up namespace handling in consumer and producer, improve stylesheet consumption
2017-01-11 09:25:59 +08:00
const auto xml_space = qn("xml", "space");
clang-format all source files, fix broken test helpers--lots of cleanup necessary as a result [ci skip]
2016-12-24 23:04:57 +08:00
preserve_space_ = parser().attribute_present(xml_space) ? parser().attribute(xml_space) == "preserve" : false;
begin cleaning up xml handling in consumer
2016-11-20 05:42:16 +08:00
}
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
void xlsx_consumer::expect_end_element(const xml::qname &name)
skip codeName attribute for #83
2016-11-21 07:36:52 +08:00
{
prevent exception on unhandled attributes
2017-09-10 21:36:53 +08:00
parser().attribute_map();
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
parser().next_expect(xml::parser::event_type::end_element, name);
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
stack_.pop_back();
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
}
rename formatted_text to rich_text to match the spec, also text_run to rich_text_run
2016-12-23 19:51:30 +08:00
rich_text xlsx_consumer::read_rich_text(const xml::qname &parent)
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
{
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
const auto &xmlns = parent.namespace_();
rename formatted_text to rich_text to match the spec, also text_run to rich_text_run
2016-12-23 19:51:30 +08:00
rich_text t;
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
while (in_element(parent))
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
{
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
auto text_element = expect_start_element(xml::content::mixed);
implement abspath and archid flags, fixes some serialization problems
2018-05-29 11:13:57 +08:00
const auto xml_space = qn("xml", "space");
const auto preserve_space = parser().attribute_present(xml_space)
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
? parser().attribute(xml_space) == "preserve"
: false;
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
skip_attributes();
auto text = read_text();
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
if (text_element == xml::qname(xmlns, "t"))
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
{
implement abspath and archid flags, fixes some serialization problems
2018-05-29 11:13:57 +08:00
t.plain_text(text, preserve_space);
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
}
else if (text_element == xml::qname(xmlns, "r"))
{
rename formatted_text to rich_text to match the spec, also text_run to rich_text_run
2016-12-23 19:51:30 +08:00
rich_text_run run;
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
while (in_element(xml::qname(xmlns, "r")))
{
auto run_element = expect_start_element(xml::content::mixed);
auto run_text = read_text();
clang-format all source files, fix broken test helpers--lots of cleanup necessary as a result [ci skip]
2016-12-24 23:04:57 +08:00
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
if (run_element == xml::qname(xmlns, "rPr"))
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
{
prevent share string formatting from being overwritten during consumption
2017-05-09 21:01:01 +08:00
run.second = xlnt::font();
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
while (in_element(xml::qname(xmlns, "rPr")))
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
{
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
auto current_run_property_element = expect_start_element(xml::content::simple);
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
if (current_run_property_element == xml::qname(xmlns, "sz"))
{
continue working through xml problems as a result of fixing xml comparison
2016-12-26 22:38:26 +08:00
run.second.get().size(parser().attribute<double>("val"));
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
}
else if (current_run_property_element == xml::qname(xmlns, "rFont"))
{
rename formatted_text to rich_text to match the spec, also text_run to rich_text_run
2016-12-23 19:51:30 +08:00
run.second.get().name(parser().attribute("val"));
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
}
else if (current_run_property_element == xml::qname(xmlns, "color"))
{
rename formatted_text to rich_text to match the spec, also text_run to rich_text_run
2016-12-23 19:51:30 +08:00
run.second.get().color(read_color());
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
}
else if (current_run_property_element == xml::qname(xmlns, "family"))
{
rename formatted_text to rich_text to match the spec, also text_run to rich_text_run
2016-12-23 19:51:30 +08:00
run.second.get().family(parser().attribute<std::size_t>("val"));
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
}
comment changes anchor() , in element()
2017-02-07 06:00:45 +08:00
else if (current_run_property_element == xml::qname(xmlns, "charset"))
{
run.second.get().charset(parser().attribute<std::size_t>("val"));
}
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
else if (current_run_property_element == xml::qname(xmlns, "scheme"))
{
rename formatted_text to rich_text to match the spec, also text_run to rich_text_run
2016-12-23 19:51:30 +08:00
run.second.get().scheme(parser().attribute("val"));
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
}
else if (current_run_property_element == xml::qname(xmlns, "b"))
{
recommit "rename some things and fix some formatting"
2017-02-15 05:33:54 +08:00
run.second.get().bold(parser().attribute_present("val")
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
? is_true(parser().attribute("val"))
: true);
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
}
comment changes anchor() , in element()
2017-02-07 06:00:45 +08:00
else if (current_run_property_element == xml::qname(xmlns, "i"))
{
recommit "rename some things and fix some formatting"
2017-02-15 05:45:44 +08:00
run.second.get().italic(parser().attribute_present("val")
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
? is_true(parser().attribute("val"))
: true);
comment changes anchor() , in element()
2017-02-07 06:00:45 +08:00
}
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
else if (current_run_property_element == xml::qname(xmlns, "u"))
{
if (parser().attribute_present("val"))
{
rename formatted_text to rich_text to match the spec, also text_run to rich_text_run
2016-12-23 19:51:30 +08:00
run.second.get().underline(parser().attribute<font::underline_style>("val"));
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
}
else
{
rename formatted_text to rich_text to match the spec, also text_run to rich_text_run
2016-12-23 19:51:30 +08:00
run.second.get().underline(font::underline_style::single);
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
}
}
else
{
unexpected_element(current_run_property_element);
}
expect_end_element(current_run_property_element);
read_text();
}
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
}
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
else if (run_element == xml::qname(xmlns, "t"))
{
rename formatted_text to rich_text to match the spec, also text_run to rich_text_run
2016-12-23 19:51:30 +08:00
run.first = run_text;
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
}
else
{
unexpected_element(run_element);
}
read_text();
expect_end_element(run_element);
read_text();
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
}
clang-format all source files, fix broken test helpers--lots of cleanup necessary as a result [ci skip]
2016-12-24 23:04:57 +08:00
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
t.add_run(run);
}
else if (text_element == xml::qname(xmlns, "rPh"))
{
skip_remaining_content(text_element);
}
else if (text_element == xml::qname(xmlns, "phoneticPr"))
{
skip_remaining_content(text_element);
}
else
{
unexpected_element(text_element);
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
}
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
read_text();
expect_end_element(text_element);
}
clean up xml parsing, fix numbers xlsx decryption, unskip some tests
2016-11-25 21:13:55 +08:00
return t;
skip codeName attribute for #83
2016-11-21 07:36:52 +08:00
}
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
xlnt::color xlsx_consumer::read_color()
{
xlnt::color result;
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
if (parser().attribute_present("auto") && is_true(parser().attribute("auto")))
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
{
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
result.auto_(true);
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
return result;
}
if (parser().attribute_present("rgb"))
{
result = xlnt::rgb_color(parser().attribute("rgb"));
}
else if (parser().attribute_present("theme"))
{
result = xlnt::theme_color(parser().attribute<std::size_t>("theme"));
}
else if (parser().attribute_present("indexed"))
{
result = xlnt::indexed_color(parser().attribute<std::size_t>("indexed"));
}
if (parser().attribute_present("tint"))
{
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
result.tint(parser().attribute("tint", 0.0));
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
}
return result;
}
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
manifest &xlsx_consumer::manifest()
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
{
rename getters and setters to the property name, many breaking changes\!
2016-12-02 21:37:50 +08:00
return target_.manifest();
continue cleaning up xlsx_consumer
2016-11-30 07:31:06 +08:00
}
a little refactoring
2016-08-05 13:52:05 +08:00
} // namespace detail
Serialisation of sheetPr and printOptions elements
2018-06-24 10:01:27 +08:00
} // namespace xlnt
Reference in New Issue Copy Permalink