mirror of
https://github.com/tfussell/xlnt.git
synced 2024-03-22 13:11:17 +08:00
268 lines
7.2 KiB
C++
268 lines
7.2 KiB
C++
#include <xlnt/s11n/excel_serializer.hpp>
|
|
#include <xlnt/s11n/manifest_serializer.hpp>
|
|
#include <xlnt/workbook/manifest.hpp>
|
|
#include <xlnt/workbook/workbook.hpp>
|
|
|
|
namespace {
|
|
|
|
std::string::size_type find_string_in_string(const std::string &string, const std::string &substring)
|
|
{
|
|
std::string::size_type possible_match_index = string.find(substring.at(0));
|
|
|
|
while(possible_match_index != std::string::npos)
|
|
{
|
|
if(string.substr(possible_match_index, substring.size()) == substring)
|
|
{
|
|
return possible_match_index;
|
|
}
|
|
|
|
possible_match_index = string.find(substring.at(0), possible_match_index + 1);
|
|
}
|
|
|
|
return possible_match_index;
|
|
}
|
|
|
|
xlnt::workbook load_workbook(xlnt::zip_file &archive, bool guess_types, bool data_only)
|
|
{
|
|
xlnt::workbook wb;
|
|
|
|
wb.set_guess_types(guess_types);
|
|
wb.set_data_only(data_only);
|
|
|
|
auto content_types = xlnt::read_content_types(archive);
|
|
auto type = xlnt::determine_document_type(content_types);
|
|
|
|
if(type != "excel")
|
|
{
|
|
throw xlnt::invalid_file_exception("");
|
|
}
|
|
|
|
wb.clear();
|
|
|
|
auto workbook_relationships = read_relationships(archive, "xl/workbook.xml");
|
|
|
|
for(auto relationship : workbook_relationships)
|
|
{
|
|
wb.create_relationship(relationship.get_id(), relationship.get_target_uri(), relationship.get_type());
|
|
}
|
|
|
|
pugi::xml_document doc;
|
|
doc.load(archive.read("xl/workbook.xml").c_str());
|
|
|
|
auto root_node = doc.child("workbook");
|
|
|
|
auto workbook_pr_node = root_node.child("workbookPr");
|
|
wb.get_properties().excel_base_date = (workbook_pr_node.attribute("date1904") != nullptr && workbook_pr_node.attribute("date1904").as_int() != 0) ? xlnt::calendar::mac_1904 : xlnt::calendar::windows_1900;
|
|
|
|
auto sheets_node = root_node.child("sheets");
|
|
|
|
xlnt::shared_strings_reader shared_strings_reader_;
|
|
auto shared_strings = shared_strings_reader_.read_strings(archive);
|
|
|
|
xlnt::style_reader style_reader_(wb);
|
|
style_reader_.read_styles(archive);
|
|
|
|
for(const auto &border_ : style_reader_.get_borders())
|
|
{
|
|
wb.add_border(border_);
|
|
}
|
|
|
|
for(const auto &fill_ : style_reader_.get_fills())
|
|
{
|
|
wb.add_fill(fill_);
|
|
}
|
|
|
|
for(const auto &font_ : style_reader_.get_fonts())
|
|
{
|
|
wb.add_font(font_);
|
|
}
|
|
|
|
for(const auto &number_format_ : style_reader_.get_number_formats())
|
|
{
|
|
wb.add_number_format(number_format_);
|
|
}
|
|
|
|
for(auto &color_rgb : style_reader_.get_colors())
|
|
{
|
|
wb.add_color(xlnt::color(xlnt::color::type::rgb, color_rgb));
|
|
}
|
|
|
|
for(const auto &style : style_reader_.get_styles())
|
|
{
|
|
wb.add_style(style);
|
|
}
|
|
|
|
for(auto sheet_node : sheets_node.children("sheet"))
|
|
{
|
|
auto rel = wb.get_relationship(sheet_node.attribute("r:id").as_string());
|
|
auto ws = wb.create_sheet(sheet_node.attribute("name").as_string(), rel);
|
|
|
|
xlnt::read_worksheet(ws, archive, rel, shared_strings);
|
|
}
|
|
|
|
return wb;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
namespace xlnt {
|
|
|
|
std::string excel_reader::CentralDirectorySignature()
|
|
{
|
|
return "\x50\x4b\x05\x06";
|
|
}
|
|
|
|
std::string excel_reader::repair_central_directory(const std::string &original)
|
|
{
|
|
auto pos = find_string_in_string(original, CentralDirectorySignature());
|
|
|
|
if(pos != std::string::npos)
|
|
{
|
|
return original.substr(0, pos + 22);
|
|
}
|
|
|
|
return original;
|
|
}
|
|
|
|
workbook excel_reader::load_workbook(std::istream &stream, bool guess_types, bool data_only)
|
|
{
|
|
std::vector<std::uint8_t> bytes((std::istream_iterator<char>(stream)),
|
|
std::istream_iterator<char>());
|
|
|
|
return load_workbook(bytes, guess_types, data_only);
|
|
}
|
|
|
|
workbook excel_reader::load_workbook(const std::string &filename, bool guess_types, bool data_only)
|
|
{
|
|
xlnt::zip_file archive;
|
|
|
|
try
|
|
{
|
|
archive.load(filename);
|
|
}
|
|
catch(std::runtime_error)
|
|
{
|
|
throw invalid_file_exception(filename);
|
|
}
|
|
|
|
return ::load_workbook(archive, guess_types, data_only);
|
|
}
|
|
|
|
xlnt::workbook excel_reader::load_workbook(const std::vector<std::uint8_t> &bytes, bool guess_types, bool data_only)
|
|
{
|
|
xlnt::zip_file archive;
|
|
archive.load(bytes);
|
|
|
|
return ::load_workbook(archive, guess_types, data_only);
|
|
}
|
|
|
|
excel_writer::excel_writer(workbook &wb) : wb_(wb)
|
|
{
|
|
}
|
|
|
|
void excel_writer::save(const std::string &filename, bool as_template)
|
|
{
|
|
zip_file archive;
|
|
write_data(archive, as_template);
|
|
archive.save(filename);
|
|
}
|
|
|
|
void excel_writer::write_data(zip_file &archive, bool as_template)
|
|
{
|
|
archive.writestr(constants::ArcRootRels, write_root_rels(wb_));
|
|
archive.writestr(constants::ArcWorkbookRels, write_workbook_rels(wb_));
|
|
archive.writestr(constants::ArcApp, write_properties_app(wb_));
|
|
archive.writestr(constants::ArcCore, write_properties_core(wb_.get_properties()));
|
|
|
|
if(wb_.has_loaded_theme())
|
|
{
|
|
archive.writestr(constants::ArcTheme, wb_.get_loaded_theme());
|
|
}
|
|
else
|
|
{
|
|
archive.writestr(constants::ArcTheme, write_theme());
|
|
}
|
|
|
|
archive.writestr(constants::ArcWorkbook, write_workbook(wb_));
|
|
|
|
auto shared_strings = extract_all_strings(wb_);
|
|
|
|
write_charts(archive);
|
|
write_images(archive);
|
|
write_shared_strings(archive, shared_strings);
|
|
write_worksheets(archive, shared_strings);
|
|
write_chartsheets(archive);
|
|
write_external_links(archive);
|
|
|
|
style_writer style_writer_(wb_);
|
|
archive.writestr(constants::ArcStyles, style_writer_.write_table());
|
|
|
|
auto manifest = write_content_types(wb_, as_template);
|
|
archive.writestr(constants::ArcContentTypes, manifest);
|
|
}
|
|
|
|
void excel_writer::write_shared_strings(xlnt::zip_file &archive, const std::vector<std::string> &shared_strings)
|
|
{
|
|
archive.writestr(constants::ArcSharedString, ::xlnt::write_shared_strings(shared_strings));
|
|
}
|
|
|
|
void excel_writer::write_images(zip_file &/*archive*/)
|
|
{
|
|
|
|
}
|
|
|
|
void excel_writer::write_charts(zip_file &/*archive*/)
|
|
{
|
|
|
|
}
|
|
|
|
void excel_writer::write_chartsheets(zip_file &/*archive*/)
|
|
{
|
|
|
|
}
|
|
|
|
void excel_writer::write_worksheets(zip_file &archive, const std::vector<std::string> &shared_strings)
|
|
{
|
|
std::size_t index = 0;
|
|
|
|
for(auto ws : wb_)
|
|
{
|
|
for(auto relationship : wb_.get_relationships())
|
|
{
|
|
if(relationship.get_type() == relationship::type::worksheet &&
|
|
workbook::index_from_ws_filename(relationship.get_target_uri()) == index)
|
|
{
|
|
archive.writestr(relationship.get_target_uri(), write_worksheet(ws, shared_strings));
|
|
break;
|
|
}
|
|
}
|
|
|
|
index++;
|
|
}
|
|
}
|
|
|
|
void excel_writer::write_external_links(zip_file &/*archive*/)
|
|
{
|
|
|
|
}
|
|
|
|
bool save_workbook(workbook &wb, const std::string &filename, bool as_template)
|
|
{
|
|
excel_writer writer(wb);
|
|
writer.save(filename, as_template);
|
|
return true;
|
|
}
|
|
|
|
std::vector<std::uint8_t> save_virtual_workbook(xlnt::workbook &wb, bool as_template)
|
|
{
|
|
zip_file archive;
|
|
excel_writer writer(wb);
|
|
writer.write_data(archive, as_template);
|
|
std::vector<std::uint8_t> buffer;
|
|
archive.save(buffer);
|
|
|
|
return buffer;
|
|
}
|
|
|
|
} // namespace xlnt
|