mirror of
https://github.com/tfussell/xlnt.git
synced 2024-03-22 13:11:17 +08:00
2089 lines
53 KiB
C++
2089 lines
53 KiB
C++
#include <algorithm>
|
|
#include <array>
|
|
#include <cassert>
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
#include <iostream>
|
|
#include <locale>
|
|
#include <sstream>
|
|
|
|
#include "xlnt.h"
|
|
#include "../third-party/pugixml/src/pugixml.hpp"
|
|
|
|
namespace xlnt {
|
|
|
|
#ifdef _WIN32
|
|
#include <Windows.h>
|
|
#include <Shlwapi.h>
|
|
void file::copy(const std::string &source, const std::string &destination, bool overwrite)
|
|
{
|
|
assert(source.size() + 1 < MAX_PATH);
|
|
assert(destination.size() + 1 < MAX_PATH);
|
|
|
|
std::wstring source_wide(source.begin(), source.end());
|
|
std::wstring destination_wide(destination.begin(), destination.end());
|
|
|
|
BOOL result = CopyFile(source_wide.c_str(), destination_wide.c_str(), !overwrite);
|
|
|
|
if(result == 0)
|
|
{
|
|
switch(GetLastError())
|
|
{
|
|
case ERROR_ACCESS_DENIED: throw std::runtime_error("Access is denied");
|
|
case ERROR_ENCRYPTION_FAILED: throw std::runtime_error("The specified file could not be encrypted");
|
|
case ERROR_FILE_NOT_FOUND: throw std::runtime_error("The source file wasn't found");
|
|
default:
|
|
if(!overwrite)
|
|
{
|
|
throw std::runtime_error("The destination file already exists");
|
|
}
|
|
throw std::runtime_error("Unknown error");
|
|
}
|
|
}
|
|
}
|
|
|
|
bool file::exists(const std::string &path)
|
|
{
|
|
std::wstring path_wide(path.begin(), path.end());
|
|
return PathFileExists(path_wide.c_str()) && !PathIsDirectory(path_wide.c_str());
|
|
}
|
|
|
|
#else
|
|
|
|
#include <sys/stat.h>
|
|
void file::copy(const std::string &source, const std::string &destination, bool overwrite)
|
|
{
|
|
if(!overwrite && exists(destination))
|
|
{
|
|
throw std::runtime_error("destination file already exists and overwrite==false");
|
|
}
|
|
|
|
std::ifstream src(source, std::ios::binary);
|
|
std::ofstream dst(destination, std::ios::binary);
|
|
|
|
dst << src.rdbuf();
|
|
}
|
|
|
|
bool file::exists(const std::string &path)
|
|
{
|
|
struct stat fileAtt;
|
|
|
|
if (stat(path.c_str(), &fileAtt) != 0)
|
|
{
|
|
throw std::runtime_error("stat failed");
|
|
}
|
|
|
|
return S_ISREG(fileAtt.st_mode);
|
|
}
|
|
|
|
#endif //_WIN32
|
|
|
|
|
|
zip_file::zip_file(const std::string &filename, file_mode mode, file_access access)
|
|
: zip_file_(nullptr),
|
|
unzip_file_(nullptr),
|
|
current_state_(state::closed),
|
|
filename_(filename),
|
|
modified_(false),
|
|
// mode_(mode),
|
|
access_(access)
|
|
{
|
|
switch(mode)
|
|
{
|
|
case file_mode::open:
|
|
read_all();
|
|
break;
|
|
case file_mode::open_or_create:
|
|
if(file_exists(filename))
|
|
{
|
|
read_all();
|
|
}
|
|
else
|
|
{
|
|
flush(true);
|
|
}
|
|
break;
|
|
case file_mode::create:
|
|
flush(true);
|
|
break;
|
|
case file_mode::create_new:
|
|
if(file_exists(filename))
|
|
{
|
|
throw std::runtime_error("file exists");
|
|
}
|
|
flush(true);
|
|
break;
|
|
case file_mode::truncate:
|
|
if((int)access & (int)file_access::read)
|
|
{
|
|
throw std::runtime_error("cannot read from file opened with file_mode truncate");
|
|
}
|
|
flush(true);
|
|
break;
|
|
case file_mode::append:
|
|
read_all();
|
|
break;
|
|
}
|
|
}
|
|
|
|
zip_file::~zip_file()
|
|
{
|
|
change_state(state::closed);
|
|
}
|
|
|
|
std::string zip_file::get_file_contents(const std::string &filename)
|
|
{
|
|
return files_[filename];
|
|
}
|
|
|
|
void zip_file::set_file_contents(const std::string &filename, const std::string &contents)
|
|
{
|
|
if(!has_file(filename) || files_[filename] != contents)
|
|
{
|
|
modified_ = true;
|
|
}
|
|
|
|
files_[filename] = contents;
|
|
}
|
|
|
|
void zip_file::delete_file(const std::string &filename)
|
|
{
|
|
files_.erase(filename);
|
|
}
|
|
|
|
bool zip_file::has_file(const std::string &filename)
|
|
{
|
|
return files_.find(filename) != files_.end();
|
|
}
|
|
|
|
void zip_file::flush(bool force_write)
|
|
{
|
|
if(modified_ || force_write)
|
|
{
|
|
write_all();
|
|
}
|
|
}
|
|
|
|
void zip_file::read_all()
|
|
{
|
|
if(!((int)access_ & (int)file_access::read))
|
|
{
|
|
throw std::runtime_error("don't have read access");
|
|
}
|
|
|
|
change_state(state::read);
|
|
|
|
int result = unzGoToFirstFile(unzip_file_);
|
|
|
|
std::array<char, 1000> file_name_buffer = {{'\0'}};
|
|
std::vector<char> file_buffer;
|
|
|
|
while(result == UNZ_OK)
|
|
{
|
|
unz_file_info file_info;
|
|
file_name_buffer.fill('\0');
|
|
|
|
result = unzGetCurrentFileInfo(unzip_file_, &file_info, file_name_buffer.data(),
|
|
static_cast<uLong>(file_name_buffer.size()), nullptr, 0, nullptr, 0);
|
|
|
|
if(result != UNZ_OK)
|
|
{
|
|
throw result;
|
|
}
|
|
|
|
result = unzOpenCurrentFile(unzip_file_);
|
|
|
|
if(result != UNZ_OK)
|
|
{
|
|
throw result;
|
|
}
|
|
|
|
if(file_buffer.size() < file_info.uncompressed_size + 1)
|
|
{
|
|
file_buffer.resize(file_info.uncompressed_size + 1);
|
|
}
|
|
file_buffer[file_info.uncompressed_size] = '\0';
|
|
|
|
result = unzReadCurrentFile(unzip_file_, file_buffer.data(), file_info.uncompressed_size);
|
|
|
|
if(result != static_cast<int>(file_info.uncompressed_size))
|
|
{
|
|
throw result;
|
|
}
|
|
|
|
std::string current_filename(file_name_buffer.begin(), file_name_buffer.begin() + file_info.size_filename);
|
|
std::string contents(file_buffer.begin(), file_buffer.begin() + file_info.uncompressed_size);
|
|
|
|
if(current_filename.back() != '/')
|
|
{
|
|
files_[current_filename] = contents;
|
|
}
|
|
else
|
|
{
|
|
directories_.push_back(current_filename);
|
|
}
|
|
|
|
result = unzCloseCurrentFile(unzip_file_);
|
|
|
|
if(result != UNZ_OK)
|
|
{
|
|
throw result;
|
|
}
|
|
|
|
result = unzGoToNextFile(unzip_file_);
|
|
}
|
|
}
|
|
|
|
void zip_file::write_all()
|
|
{
|
|
if(!((int)access_ & (int)file_access::write))
|
|
{
|
|
throw std::runtime_error("don't have write access");
|
|
}
|
|
|
|
change_state(state::write, false);
|
|
|
|
for(auto file : files_)
|
|
{
|
|
write_to_zip(file.first, file.second, true);
|
|
}
|
|
|
|
modified_ = false;
|
|
}
|
|
|
|
std::string zip_file::read_from_zip(const std::string &filename)
|
|
{
|
|
if(!((int)access_ & (int)file_access::read))
|
|
{
|
|
throw std::runtime_error("don't have read access");
|
|
}
|
|
|
|
change_state(state::read);
|
|
|
|
auto result = unzLocateFile(unzip_file_, filename.c_str(), 1);
|
|
|
|
if(result != UNZ_OK)
|
|
{
|
|
throw result;
|
|
}
|
|
|
|
result = unzOpenCurrentFile(unzip_file_);
|
|
|
|
if(result != UNZ_OK)
|
|
{
|
|
throw result;
|
|
}
|
|
|
|
unz_file_info file_info;
|
|
std::array<char, 1000> file_name_buffer;
|
|
std::array<char, 1000> extra_field_buffer;
|
|
std::array<char, 1000> comment_buffer;
|
|
|
|
unzGetCurrentFileInfo(unzip_file_, &file_info,
|
|
file_name_buffer.data(), static_cast<uLong>(file_name_buffer.size()),
|
|
extra_field_buffer.data(), static_cast<uLong>(extra_field_buffer.size()),
|
|
comment_buffer.data(), static_cast<uLong>(comment_buffer.size()));
|
|
|
|
std::vector<char> file_buffer(file_info.uncompressed_size + 1, '\0');
|
|
result = unzReadCurrentFile(unzip_file_, file_buffer.data(), file_info.uncompressed_size);
|
|
|
|
if(result != static_cast<int>(file_info.uncompressed_size))
|
|
{
|
|
throw result;
|
|
}
|
|
|
|
result = unzCloseCurrentFile(unzip_file_);
|
|
|
|
if(result != UNZ_OK)
|
|
{
|
|
throw result;
|
|
}
|
|
|
|
return std::string(file_buffer.begin(), file_buffer.end());
|
|
}
|
|
|
|
void zip_file::write_to_zip(const std::string &filename, const std::string &content, bool append)
|
|
{
|
|
if(!((int)access_ & (int)file_access::write))
|
|
{
|
|
throw std::runtime_error("don't have write access");
|
|
}
|
|
|
|
change_state(state::write, append);
|
|
|
|
zip_fileinfo file_info;
|
|
|
|
int result = zipOpenNewFileInZip(zip_file_, filename.c_str(), &file_info, nullptr, 0, nullptr, 0, nullptr, Z_DEFLATED, Z_DEFAULT_COMPRESSION);
|
|
|
|
if(result != UNZ_OK)
|
|
{
|
|
throw result;
|
|
}
|
|
|
|
result = zipWriteInFileInZip(zip_file_, content.data(), static_cast<int>(content.size()));
|
|
|
|
if(result != UNZ_OK)
|
|
{
|
|
throw result;
|
|
}
|
|
|
|
result = zipCloseFileInZip(zip_file_);
|
|
|
|
if(result != UNZ_OK)
|
|
{
|
|
throw result;
|
|
}
|
|
}
|
|
|
|
void zip_file::change_state(state new_state, bool append)
|
|
{
|
|
if(new_state == current_state_ && append)
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch(new_state)
|
|
{
|
|
case state::closed:
|
|
if(current_state_ == state::write)
|
|
{
|
|
stop_write();
|
|
}
|
|
else if(current_state_ == state::read)
|
|
{
|
|
stop_read();
|
|
}
|
|
break;
|
|
case state::read:
|
|
if(current_state_ == state::write)
|
|
{
|
|
stop_write();
|
|
}
|
|
start_read();
|
|
break;
|
|
case state::write:
|
|
if(current_state_ == state::read)
|
|
{
|
|
stop_read();
|
|
}
|
|
if(current_state_ != state::write)
|
|
{
|
|
start_write(append);
|
|
}
|
|
break;
|
|
default:
|
|
throw std::runtime_error("bad enum");
|
|
}
|
|
|
|
current_state_ = new_state;
|
|
}
|
|
|
|
bool zip_file::file_exists(const std::string& name)
|
|
{
|
|
std::ifstream f(name.c_str());
|
|
return f.good();
|
|
}
|
|
|
|
void zip_file::start_read()
|
|
{
|
|
if(unzip_file_ != nullptr || zip_file_ != nullptr)
|
|
{
|
|
throw std::runtime_error("bad state");
|
|
}
|
|
|
|
unzip_file_ = unzOpen(filename_.c_str());
|
|
|
|
if(unzip_file_ == nullptr)
|
|
{
|
|
throw std::runtime_error("bad or non-existant file");
|
|
}
|
|
}
|
|
|
|
void zip_file::stop_read()
|
|
{
|
|
if(unzip_file_ == nullptr)
|
|
{
|
|
throw std::runtime_error("bad state");
|
|
}
|
|
|
|
int result = unzClose(unzip_file_);
|
|
|
|
if(result != UNZ_OK)
|
|
{
|
|
throw result;
|
|
}
|
|
|
|
unzip_file_ = nullptr;
|
|
}
|
|
|
|
void zip_file::start_write(bool append)
|
|
{
|
|
if(unzip_file_ != nullptr || zip_file_ != nullptr)
|
|
{
|
|
throw std::runtime_error("bad state");
|
|
}
|
|
|
|
int append_status;
|
|
|
|
if(append)
|
|
{
|
|
if(!file_exists(filename_))
|
|
{
|
|
throw std::runtime_error("can't append to non-existent file");
|
|
}
|
|
append_status = APPEND_STATUS_ADDINZIP;
|
|
}
|
|
else
|
|
{
|
|
append_status = APPEND_STATUS_CREATE;
|
|
}
|
|
|
|
zip_file_ = zipOpen(filename_.c_str(), append_status);
|
|
|
|
if(zip_file_ == nullptr)
|
|
{
|
|
if(append)
|
|
{
|
|
throw std::runtime_error("couldn't append to zip file");
|
|
}
|
|
else
|
|
{
|
|
throw std::runtime_error("couldn't create zip file");
|
|
}
|
|
}
|
|
}
|
|
|
|
void zip_file::stop_write()
|
|
{
|
|
if(zip_file_ == nullptr)
|
|
{
|
|
throw std::runtime_error("bad state");
|
|
}
|
|
|
|
flush();
|
|
|
|
int result = zipClose(zip_file_, nullptr);
|
|
|
|
if(result != UNZ_OK)
|
|
{
|
|
throw result;
|
|
}
|
|
|
|
zip_file_ = nullptr;
|
|
}
|
|
|
|
const xlnt::color xlnt::color::black(0);
|
|
const xlnt::color xlnt::color::white(1);
|
|
|
|
struct cell_struct
|
|
{
|
|
cell_struct(worksheet_struct *ws, int column, int row)
|
|
: type(cell::type::null), parent_worksheet(ws),
|
|
column(column), row(row),
|
|
hyperlink_rel("hyperlink")
|
|
{
|
|
|
|
}
|
|
|
|
std::string to_string() const;
|
|
|
|
cell::type type;
|
|
|
|
union
|
|
{
|
|
long double numeric_value;
|
|
bool bool_value;
|
|
};
|
|
|
|
|
|
std::string error_value;
|
|
tm date_value;
|
|
std::string string_value;
|
|
std::string formula_value;
|
|
worksheet_struct *parent_worksheet;
|
|
int column;
|
|
int row;
|
|
style style;
|
|
relationship hyperlink_rel;
|
|
bool merged;
|
|
};
|
|
|
|
const std::unordered_map<std::string, int> cell::ErrorCodes =
|
|
{
|
|
{"#NULL!", 0},
|
|
{"#DIV/0!", 1},
|
|
{"#VALUE!", 2},
|
|
{"#REF!", 3},
|
|
{"#NAME?", 4},
|
|
{"#NUM!", 5},
|
|
{"#N/A!", 6}
|
|
};
|
|
|
|
cell::cell() : root_(nullptr)
|
|
{
|
|
}
|
|
|
|
cell::cell(worksheet &worksheet, const std::string &column, int row) : root_(nullptr)
|
|
{
|
|
cell self = worksheet.cell(column + std::to_string(row));
|
|
root_ = self.root_;
|
|
}
|
|
|
|
|
|
cell::cell(worksheet &worksheet, const std::string &column, int row, const std::string &initial_value) : root_(nullptr)
|
|
{
|
|
cell self = worksheet.cell(column + std::to_string(row));
|
|
root_ = self.root_;
|
|
*this = initial_value;
|
|
}
|
|
|
|
cell::cell(cell_struct *root) : root_(root)
|
|
{
|
|
}
|
|
|
|
std::string cell::get_value() const
|
|
{
|
|
switch(root_->type)
|
|
{
|
|
case type::string:
|
|
return root_->string_value;
|
|
case type::numeric:
|
|
return std::to_string(root_->numeric_value);
|
|
case type::formula:
|
|
return root_->formula_value;
|
|
case type::error:
|
|
return root_->error_value;
|
|
case type::null:
|
|
return "";
|
|
case type::date:
|
|
return "00:00:00";
|
|
case type::boolean:
|
|
return root_->bool_value ? "TRUE" : "FALSE";
|
|
default:
|
|
throw std::runtime_error("bad enum");
|
|
}
|
|
}
|
|
|
|
int cell::get_row() const
|
|
{
|
|
return root_->row;
|
|
}
|
|
|
|
std::string cell::get_column() const
|
|
{
|
|
return get_column_letter(root_->column + 1);
|
|
}
|
|
|
|
std::vector<std::string> split_string(const std::string &string, char delim = ' ')
|
|
{
|
|
std::stringstream ss(string);
|
|
std::string part;
|
|
std::vector<std::string> parts;
|
|
while(std::getline(ss, part, delim))
|
|
{
|
|
parts.push_back(part);
|
|
}
|
|
return parts;
|
|
}
|
|
|
|
cell::type cell::data_type_for_value(const std::string &value)
|
|
{
|
|
if(value.empty())
|
|
{
|
|
return type::null;
|
|
}
|
|
|
|
if(value[0] == '=')
|
|
{
|
|
return type::formula;
|
|
}
|
|
else if(value[0] == '0')
|
|
{
|
|
if(value.length() > 1)
|
|
{
|
|
if(value[1] == '.' || (value.length() > 2 && (value[1] == 'e' || value[1] == 'E')))
|
|
{
|
|
auto first_non_number = std::find_if(value.begin() + 2, value.end(),
|
|
[](char c) { return !std::isdigit(c, std::locale::classic()); });
|
|
if(first_non_number == value.end())
|
|
{
|
|
return type::numeric;
|
|
}
|
|
}
|
|
auto split = split_string(value, ':');
|
|
if(split.size() == 2 || split.size() == 3)
|
|
{
|
|
for(auto part : split)
|
|
{
|
|
try
|
|
{
|
|
std::stoi(part);
|
|
}
|
|
catch(std::invalid_argument)
|
|
{
|
|
return type::string;
|
|
}
|
|
}
|
|
return type::date;
|
|
}
|
|
else
|
|
{
|
|
return type::string;
|
|
}
|
|
}
|
|
return type::numeric;
|
|
}
|
|
else if(value[0] == '#')
|
|
{
|
|
return type::error;
|
|
}
|
|
else
|
|
{
|
|
char *p;
|
|
strtod(value.c_str(), &p);
|
|
if(*p != 0)
|
|
{
|
|
static const std::vector<std::string> possible_booleans = {"TRUE", "true", "FALSE", "false"};
|
|
if(std::find(possible_booleans.begin(), possible_booleans.end(), value) != possible_booleans.end())
|
|
{
|
|
return type::boolean;
|
|
}
|
|
return type::string;
|
|
}
|
|
else
|
|
{
|
|
return type::numeric;
|
|
}
|
|
}
|
|
}
|
|
|
|
void cell::set_explicit_value(const std::string &value, type data_type)
|
|
{
|
|
root_->type = data_type;
|
|
switch(data_type)
|
|
{
|
|
case type::formula: root_->formula_value = value; return;
|
|
case type::date: root_->date_value.tm_hour = std::stoi(value); return;
|
|
case type::error: root_->error_value = value; return;
|
|
case type::boolean: root_->bool_value = value == "true"; return;
|
|
case type::null: return;
|
|
case type::numeric: root_->numeric_value = std::stod(value); return;
|
|
case type::string: root_->string_value = value; return;
|
|
}
|
|
}
|
|
|
|
void cell::set_hyperlink(const std::string &hyperlink)
|
|
{
|
|
root_->hyperlink_rel = worksheet(root_->parent_worksheet).create_relationship(hyperlink);
|
|
}
|
|
|
|
void cell::set_merged(bool merged)
|
|
{
|
|
root_->merged = merged;
|
|
}
|
|
|
|
bool cell::bind_value()
|
|
{
|
|
root_->type = type::null;
|
|
return true;
|
|
}
|
|
|
|
bool cell::bind_value(int value)
|
|
{
|
|
root_->type = type::numeric;
|
|
root_->numeric_value = value;
|
|
return true;
|
|
}
|
|
|
|
bool cell::bind_value(double value)
|
|
{
|
|
root_->type = type::numeric;
|
|
root_->numeric_value = value;
|
|
return true;
|
|
}
|
|
|
|
bool cell::bind_value(const std::string &value)
|
|
{
|
|
//Given a value, infer type and display options.
|
|
root_->type = data_type_for_value(value);
|
|
return true;
|
|
}
|
|
|
|
bool cell::bind_value(const char *value)
|
|
{
|
|
return bind_value(std::string(value));
|
|
}
|
|
|
|
bool cell::bind_value(bool value)
|
|
{
|
|
root_->type = type::boolean;
|
|
root_->bool_value = value;
|
|
return true;
|
|
}
|
|
|
|
bool cell::bind_value(const tm &value)
|
|
{
|
|
root_->type = type::date;
|
|
root_->date_value = value;
|
|
return true;
|
|
}
|
|
|
|
coordinate cell::coordinate_from_string(const std::string &coord_string)
|
|
{
|
|
// Convert a coordinate string like 'B12' to a tuple ('B', 12)
|
|
bool column_part = true;
|
|
coordinate result;
|
|
|
|
for(auto character : coord_string)
|
|
{
|
|
char upper = std::toupper(character, std::locale::classic());
|
|
|
|
if(std::isalpha(character, std::locale::classic()))
|
|
{
|
|
if(column_part)
|
|
{
|
|
result.column.append(1, upper);
|
|
}
|
|
else
|
|
{
|
|
std::string msg = "Invalid cell coordinates (" + coord_string + ")";
|
|
throw std::runtime_error(msg);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(column_part)
|
|
{
|
|
column_part = false;
|
|
}
|
|
else if(!(std::isdigit(character, std::locale::classic()) || character == '$'))
|
|
{
|
|
std::string msg = "Invalid cell coordinates (" + coord_string + ")";
|
|
throw std::runtime_error(msg);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string row_string = coord_string.substr(result.column.length());
|
|
if(row_string[0] == '$')
|
|
{
|
|
row_string = row_string.substr(1);
|
|
}
|
|
result.row = std::stoi(row_string);
|
|
|
|
if(result.row < 1)
|
|
{
|
|
std::string msg = "Invalid cell coordinates (" + coord_string + ")";
|
|
throw std::runtime_error(msg);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
int cell::column_index_from_string(const std::string &column_string)
|
|
{
|
|
if(column_string.length() > 3 || column_string.empty())
|
|
{
|
|
throw std::runtime_error("column must be one to three characters");
|
|
}
|
|
|
|
int column_index = 0;
|
|
int place = 1;
|
|
|
|
for(int i = static_cast<int>(column_string.length()) - 1; i >= 0; i--)
|
|
{
|
|
if(!std::isalpha(column_string[i], std::locale::classic()))
|
|
{
|
|
throw std::runtime_error("column must contain only letters in the range A-Z");
|
|
}
|
|
|
|
column_index += (std::toupper(column_string[i], std::locale::classic()) - 'A' + 1) * place;
|
|
place *= 26;
|
|
}
|
|
|
|
return column_index;
|
|
}
|
|
|
|
// Convert a column number into a column letter (3 -> 'C')
|
|
// Right shift the column col_idx by 26 to find column letters in reverse
|
|
// order.These numbers are 1 - based, and can be converted to ASCII
|
|
// ordinals by adding 64.
|
|
std::string cell::get_column_letter(int column_index)
|
|
{
|
|
// these indicies corrospond to A->ZZZ and include all allowed
|
|
// columns
|
|
if(column_index < 1 || column_index > 18278)
|
|
{
|
|
auto msg = "Column index out of bounds: " + std::to_string(column_index);
|
|
throw std::runtime_error(msg);
|
|
}
|
|
|
|
auto temp = column_index;
|
|
std::string column_letter = "";
|
|
|
|
while(temp > 0)
|
|
{
|
|
int quotient = temp / 26, remainder = temp % 26;
|
|
|
|
// check for exact division and borrow if needed
|
|
if(remainder == 0)
|
|
{
|
|
quotient -= 1;
|
|
remainder = 26;
|
|
}
|
|
|
|
column_letter = std::string(1, char(remainder + 64)) + column_letter;
|
|
temp = quotient;
|
|
}
|
|
|
|
return column_letter;
|
|
}
|
|
|
|
bool cell::is_date() const
|
|
{
|
|
return root_->type == type::date;
|
|
}
|
|
|
|
std::string cell::get_address() const
|
|
{
|
|
return get_column_letter(root_->column + 1) + std::to_string(root_->row + 1);
|
|
}
|
|
|
|
std::string cell::get_coordinate() const
|
|
{
|
|
return get_address();
|
|
}
|
|
|
|
std::string cell::get_hyperlink_rel_id() const
|
|
{
|
|
return root_->hyperlink_rel.get_id();
|
|
}
|
|
|
|
bool cell::operator==(std::nullptr_t) const
|
|
{
|
|
return root_ == nullptr;
|
|
}
|
|
|
|
bool cell::operator==(const std::string &comparand) const
|
|
{
|
|
return root_->type == cell::type::string && root_->string_value == comparand;
|
|
}
|
|
|
|
bool cell::operator==(const char *comparand) const
|
|
{
|
|
return *this == std::string(comparand);
|
|
}
|
|
|
|
bool cell::operator==(const tm &comparand) const
|
|
{
|
|
return root_->type == cell::type::date && root_->date_value.tm_hour == comparand.tm_hour;
|
|
}
|
|
|
|
bool operator==(const char *comparand, const xlnt::cell &cell)
|
|
{
|
|
return cell == comparand;
|
|
}
|
|
|
|
bool operator==(const std::string &comparand, const xlnt::cell &cell)
|
|
{
|
|
return cell == comparand;
|
|
}
|
|
|
|
bool operator==(const tm &comparand, const xlnt::cell &cell)
|
|
{
|
|
return cell == comparand;
|
|
}
|
|
|
|
style &cell::get_style()
|
|
{
|
|
return root_->style;
|
|
}
|
|
|
|
const style &cell::get_style() const
|
|
{
|
|
return root_->style;
|
|
}
|
|
|
|
std::string cell::absolute_coordinate(const std::string &absolute_address)
|
|
{
|
|
// Convert a coordinate to an absolute coordinate string (B12 -> $B$12)
|
|
auto colon_index = absolute_address.find(':');
|
|
if(colon_index != std::string::npos)
|
|
{
|
|
return absolute_coordinate(absolute_address.substr(0, colon_index)) + ":"
|
|
+ absolute_coordinate(absolute_address.substr(colon_index + 1));
|
|
}
|
|
else
|
|
{
|
|
auto coord = coordinate_from_string(absolute_address);
|
|
return std::string("$") + coord.column + "$" + std::to_string(coord.row);
|
|
}
|
|
}
|
|
|
|
xlnt::cell::type cell::get_data_type() const
|
|
{
|
|
return root_->type;
|
|
}
|
|
|
|
xlnt::cell cell::get_offset(int column_offset, int row_offset)
|
|
{
|
|
return worksheet(root_->parent_worksheet).cell(root_->row + row_offset, root_->column + column_offset);
|
|
}
|
|
|
|
cell &cell::operator=(const cell &rhs)
|
|
{
|
|
root_ = rhs.root_;
|
|
return *this;
|
|
}
|
|
|
|
cell &cell::operator=(int value)
|
|
{
|
|
root_->type = type::numeric;
|
|
root_->numeric_value = value;
|
|
return *this;
|
|
}
|
|
|
|
cell &cell::operator=(double value)
|
|
{
|
|
root_->type = type::numeric;
|
|
root_->numeric_value = value;
|
|
return *this;
|
|
}
|
|
|
|
cell &cell::operator=(bool value)
|
|
{
|
|
root_->type = type::boolean;
|
|
root_->bool_value = value;
|
|
return *this;
|
|
}
|
|
|
|
cell &cell::operator=(const std::string &value)
|
|
{
|
|
root_->type = data_type_for_value(value);
|
|
|
|
switch(root_->type)
|
|
{
|
|
case type::date:
|
|
root_->date_value = std::tm();
|
|
break;
|
|
case type::formula:
|
|
root_->formula_value = value;
|
|
break;
|
|
case type::numeric:
|
|
root_->numeric_value = std::stod(value);
|
|
break;
|
|
case type::boolean:
|
|
root_->bool_value = value == "TRUE" || value == "true";
|
|
break;
|
|
case type::error:
|
|
root_->error_value = value;
|
|
break;
|
|
case type::string:
|
|
root_->string_value = value;
|
|
break;
|
|
case type::null:
|
|
break;
|
|
default:
|
|
throw std::runtime_error("bad enum");
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
cell &cell::operator=(const char *value)
|
|
{
|
|
return *this = std::string(value);
|
|
}
|
|
|
|
cell &cell::operator=(const tm &value)
|
|
{
|
|
root_->type = type::date;
|
|
root_->date_value = value;
|
|
return *this;
|
|
}
|
|
|
|
std::string cell::to_string() const
|
|
{
|
|
return root_->to_string();
|
|
}
|
|
|
|
struct worksheet_struct
|
|
{
|
|
worksheet_struct(workbook &parent_workbook, const std::string &title)
|
|
: parent_(parent_workbook), title_(title), freeze_panes_(nullptr)
|
|
{
|
|
|
|
}
|
|
|
|
void garbage_collect()
|
|
{
|
|
std::vector<std::string> null_cell_keys;
|
|
|
|
for(auto key_cell_pair : cell_map_)
|
|
{
|
|
if(key_cell_pair.second.get_data_type() == cell::type::null)
|
|
{
|
|
null_cell_keys.push_back(key_cell_pair.first);
|
|
}
|
|
}
|
|
|
|
while(!null_cell_keys.empty())
|
|
{
|
|
cell_map_.erase(null_cell_keys.back());
|
|
null_cell_keys.pop_back();
|
|
}
|
|
}
|
|
|
|
std::list<cell> get_cell_collection()
|
|
{
|
|
std::list<xlnt::cell> cells;
|
|
for(auto cell : cell_map_)
|
|
{
|
|
cells.push_front(xlnt::cell(cell.second));
|
|
}
|
|
return cells;
|
|
}
|
|
|
|
std::string get_title() const
|
|
{
|
|
return title_;
|
|
}
|
|
|
|
void set_title(const std::string &title)
|
|
{
|
|
title_ = title;
|
|
}
|
|
|
|
cell get_freeze_panes() const
|
|
{
|
|
return freeze_panes_;
|
|
}
|
|
|
|
void set_freeze_panes(cell top_left_cell)
|
|
{
|
|
freeze_panes_ = top_left_cell;
|
|
}
|
|
|
|
void set_freeze_panes(const std::string &top_left_coordinate)
|
|
{
|
|
freeze_panes_ = cell(top_left_coordinate);
|
|
}
|
|
|
|
void unfreeze_panes()
|
|
{
|
|
freeze_panes_ = xlnt::cell(nullptr);
|
|
}
|
|
|
|
xlnt::cell cell(const std::string &coordinate)
|
|
{
|
|
if(cell_map_.find(coordinate) == cell_map_.end())
|
|
{
|
|
auto coord = xlnt::cell::coordinate_from_string(coordinate);
|
|
cell_struct *cell = new xlnt::cell_struct(this, xlnt::cell::column_index_from_string(coord.column) - 1, coord.row - 1);
|
|
cell_map_[coordinate] = xlnt::cell(cell);
|
|
}
|
|
|
|
return cell_map_[coordinate];
|
|
}
|
|
|
|
xlnt::cell cell(int row, int column)
|
|
{
|
|
return cell(xlnt::cell::get_column_letter(column + 1) + std::to_string(row + 1));
|
|
}
|
|
|
|
int get_highest_row() const
|
|
{
|
|
int highest = 0;
|
|
for(auto cell : cell_map_)
|
|
{
|
|
highest = (std::max)(highest, cell.second.get_row());
|
|
}
|
|
return highest;
|
|
}
|
|
|
|
int get_highest_column() const
|
|
{
|
|
int highest = 0;
|
|
for(auto cell : cell_map_)
|
|
{
|
|
highest = (std::max)(highest, xlnt::cell::column_index_from_string(cell.second.get_column()));
|
|
}
|
|
return highest;
|
|
}
|
|
|
|
std::string calculate_dimension() const
|
|
{
|
|
int width = (std::max)(1, get_highest_column());
|
|
std::string width_letter = xlnt::cell::get_column_letter(width);
|
|
int height = get_highest_row() + 1;
|
|
return "A1:" + width_letter + std::to_string(height);
|
|
}
|
|
|
|
xlnt::range range(const std::string &range_string, int row_offset, int column_offset)
|
|
{
|
|
xlnt::range r;
|
|
|
|
auto colon_index = range_string.find(':');
|
|
|
|
if(colon_index != std::string::npos)
|
|
{
|
|
auto min_range = range_string.substr(0, colon_index);
|
|
auto max_range = range_string.substr(colon_index + 1);
|
|
auto min_coord = xlnt::cell::coordinate_from_string(min_range);
|
|
auto max_coord = xlnt::cell::coordinate_from_string(max_range);
|
|
|
|
if(column_offset != 0)
|
|
{
|
|
min_coord.column = xlnt::cell::get_column_letter(xlnt::cell::column_index_from_string(min_coord.column) + column_offset);
|
|
max_coord.column = xlnt::cell::get_column_letter(xlnt::cell::column_index_from_string(max_coord.column) + column_offset);
|
|
}
|
|
|
|
std::unordered_map<int, std::string> column_cache;
|
|
|
|
for(int i = xlnt::cell::column_index_from_string(min_coord.column);
|
|
i <= xlnt::cell::column_index_from_string(max_coord.column); i++)
|
|
{
|
|
column_cache[i] = xlnt::cell::get_column_letter(i);
|
|
}
|
|
for(int row = min_coord.row + row_offset; row <= max_coord.row + row_offset; row++)
|
|
{
|
|
r.push_back(std::vector<xlnt::cell>());
|
|
for(int column = xlnt::cell::column_index_from_string(min_coord.column) + column_offset;
|
|
column <= xlnt::cell::column_index_from_string(max_coord.column) + column_offset; column++)
|
|
{
|
|
std::string coordinate = column_cache[column] + std::to_string(row);
|
|
r.back().push_back(cell(coordinate));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
r.push_back(std::vector<xlnt::cell>());
|
|
r.back().push_back(cell(range_string));
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
relationship create_relationship(const std::string &relationship_type)
|
|
{
|
|
relationships_.push_back(relationship(relationship_type));
|
|
return relationships_.back();
|
|
}
|
|
|
|
//void add_chart(chart chart);
|
|
|
|
void merge_cells(const std::string &range_string)
|
|
{
|
|
bool first = true;
|
|
for(auto row : range(range_string, 0, 0))
|
|
{
|
|
for(auto cell : row)
|
|
{
|
|
cell.set_merged(true);
|
|
if(!first)
|
|
{
|
|
cell.bind_value();
|
|
}
|
|
first = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void merge_cells(int start_row, int start_column, int end_row, int end_column)
|
|
{
|
|
auto range_string = xlnt::cell::get_column_letter(start_column + 1) + std::to_string(start_row + 1) + ":"
|
|
+ xlnt::cell::get_column_letter(end_column + 1) + std::to_string(end_row + 1);
|
|
merge_cells(range_string);
|
|
}
|
|
|
|
void unmerge_cells(const std::string &range_string)
|
|
{
|
|
bool first = true;
|
|
for(auto row : range(range_string, 0, 0))
|
|
{
|
|
for(auto cell : row)
|
|
{
|
|
cell.set_merged(false);
|
|
if(!first)
|
|
{
|
|
cell.bind_value();
|
|
}
|
|
first = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void unmerge_cells(int start_row, int start_column, int end_row, int end_column)
|
|
{
|
|
auto range_string = xlnt::cell::get_column_letter(start_column + 1) + std::to_string(start_row + 1) + ":"
|
|
+ xlnt::cell::get_column_letter(end_column + 1) + std::to_string(end_row + 1);
|
|
merge_cells(range_string);
|
|
}
|
|
|
|
void append(const std::vector<std::string> &cells)
|
|
{
|
|
int row = get_highest_row();
|
|
if(!cell_map_.empty())
|
|
{
|
|
row += 1;
|
|
}
|
|
int column = 0;
|
|
for(auto cell : cells)
|
|
{
|
|
this->cell(row, column++) = cell;
|
|
}
|
|
}
|
|
|
|
void append(const std::unordered_map<std::string, std::string> &cells)
|
|
{
|
|
int row = get_highest_row();
|
|
for(auto cell : cells)
|
|
{
|
|
int column = xlnt::cell::column_index_from_string(cell.second);
|
|
this->cell(row, column) = cell.second;
|
|
}
|
|
}
|
|
|
|
void append(const std::unordered_map<int, std::string> &cells)
|
|
{
|
|
int row = get_highest_row();
|
|
for(auto cell : cells)
|
|
{
|
|
this->cell(row, cell.first) = cell.second;
|
|
}
|
|
}
|
|
|
|
xlnt::range rows()
|
|
{
|
|
return range(calculate_dimension(), 0, 0);
|
|
}
|
|
|
|
xlnt::range columns()
|
|
{
|
|
throw std::runtime_error("not implemented");
|
|
}
|
|
|
|
void operator=(const worksheet_struct &other) = delete;
|
|
|
|
workbook &parent_;
|
|
std::string title_;
|
|
xlnt::cell freeze_panes_;
|
|
std::unordered_map<std::string, xlnt::cell> cell_map_;
|
|
std::vector<relationship> relationships_;
|
|
page_setup page_setup_;
|
|
};
|
|
|
|
worksheet::worksheet(worksheet_struct *root) : root_(root)
|
|
{
|
|
}
|
|
|
|
worksheet::worksheet(workbook &parent)
|
|
{
|
|
*this = parent.create_sheet();
|
|
}
|
|
|
|
page_setup &worksheet::get_page_setup()
|
|
{
|
|
return root_->page_setup_;
|
|
}
|
|
|
|
std::string worksheet::to_string() const
|
|
{
|
|
return "<Worksheet \"" + root_->title_ + "\">";
|
|
}
|
|
|
|
workbook &worksheet::get_parent() const
|
|
{
|
|
return root_->parent_;
|
|
}
|
|
|
|
void worksheet::garbage_collect()
|
|
{
|
|
root_->garbage_collect();
|
|
}
|
|
|
|
std::list<cell> worksheet::get_cell_collection()
|
|
{
|
|
return root_->get_cell_collection();
|
|
}
|
|
|
|
std::string worksheet::get_title() const
|
|
{
|
|
if(root_ == nullptr)
|
|
{
|
|
throw std::runtime_error("null worksheet");
|
|
}
|
|
return root_->title_;
|
|
}
|
|
|
|
void worksheet::set_title(const std::string &title)
|
|
{
|
|
root_->title_ = title;
|
|
}
|
|
|
|
cell worksheet::get_freeze_panes() const
|
|
{
|
|
return root_->freeze_panes_;
|
|
}
|
|
|
|
void worksheet::set_freeze_panes(xlnt::cell top_left_cell)
|
|
{
|
|
root_->set_freeze_panes(top_left_cell);
|
|
}
|
|
|
|
void worksheet::set_freeze_panes(const std::string &top_left_coordinate)
|
|
{
|
|
root_->set_freeze_panes(top_left_coordinate);
|
|
}
|
|
|
|
void worksheet::unfreeze_panes()
|
|
{
|
|
root_->unfreeze_panes();
|
|
}
|
|
|
|
xlnt::cell worksheet::cell(const std::string &coordinate)
|
|
{
|
|
return root_->cell(coordinate);
|
|
}
|
|
|
|
xlnt::cell worksheet::cell(int row, int column)
|
|
{
|
|
return root_->cell(row, column);
|
|
}
|
|
|
|
int worksheet::get_highest_row() const
|
|
{
|
|
return root_->get_highest_row();
|
|
}
|
|
|
|
int worksheet::get_highest_column() const
|
|
{
|
|
return root_->get_highest_column();
|
|
}
|
|
|
|
std::string worksheet::calculate_dimension() const
|
|
{
|
|
return root_->calculate_dimension();
|
|
}
|
|
|
|
range worksheet::range(const std::string &range_string, int row_offset, int column_offset)
|
|
{
|
|
return root_->range(range_string, row_offset, column_offset);
|
|
}
|
|
|
|
range worksheet::range(const std::string &range_string)
|
|
{
|
|
return root_->range(range_string, 0, 0);
|
|
}
|
|
|
|
std::vector<relationship> worksheet::get_relationships()
|
|
{
|
|
return root_->relationships_;
|
|
}
|
|
|
|
relationship worksheet::create_relationship(const std::string &relationship_type)
|
|
{
|
|
return root_->create_relationship(relationship_type);
|
|
}
|
|
|
|
//void worksheet::add_chart(chart chart);
|
|
|
|
void worksheet::merge_cells(const std::string &range_string)
|
|
{
|
|
root_->merge_cells(range_string);
|
|
}
|
|
|
|
void worksheet::merge_cells(int start_row, int start_column, int end_row, int end_column)
|
|
{
|
|
root_->merge_cells(start_row, start_column, end_row, end_column);
|
|
}
|
|
|
|
void worksheet::unmerge_cells(const std::string &range_string)
|
|
{
|
|
root_->unmerge_cells(range_string);
|
|
}
|
|
|
|
void worksheet::unmerge_cells(int start_row, int start_column, int end_row, int end_column)
|
|
{
|
|
root_->unmerge_cells(start_row, start_column, end_row, end_column);
|
|
}
|
|
|
|
void worksheet::append(const std::vector<std::string> &cells)
|
|
{
|
|
root_->append(cells);
|
|
}
|
|
|
|
void worksheet::append(const std::unordered_map<std::string, std::string> &cells)
|
|
{
|
|
root_->append(cells);
|
|
}
|
|
|
|
void worksheet::append(const std::unordered_map<int, std::string> &cells)
|
|
{
|
|
root_->append(cells);
|
|
}
|
|
|
|
xlnt::range worksheet::rows() const
|
|
{
|
|
return root_->rows();
|
|
}
|
|
|
|
xlnt::range worksheet::columns() const
|
|
{
|
|
return root_->columns();
|
|
}
|
|
|
|
bool worksheet::operator==(const worksheet &other) const
|
|
{
|
|
return root_ == other.root_;
|
|
}
|
|
|
|
bool worksheet::operator!=(const worksheet &other) const
|
|
{
|
|
return root_ != other.root_;
|
|
}
|
|
|
|
bool worksheet::operator==(std::nullptr_t) const
|
|
{
|
|
return root_ == nullptr;
|
|
}
|
|
|
|
bool worksheet::operator!=(std::nullptr_t) const
|
|
{
|
|
return root_ != nullptr;
|
|
}
|
|
|
|
|
|
void worksheet::operator=(const worksheet &other)
|
|
{
|
|
root_ = other.root_;
|
|
}
|
|
|
|
cell worksheet::operator[](const std::string &address)
|
|
{
|
|
return cell(address);
|
|
}
|
|
|
|
std::string write_content_types(const std::pair<std::unordered_map<std::string, std::string>, std::unordered_map<std::string, std::string>> &content_types)
|
|
{
|
|
/*std::set<std::string> seen;
|
|
|
|
pugi::xml_node root;
|
|
|
|
if(wb.has_vba_archive())
|
|
{
|
|
root = fromstring(wb.get_vba_archive().read(ARC_CONTENT_TYPES));
|
|
|
|
for(auto elem : root.findall("{" + CONTYPES_NS + "}Override"))
|
|
{
|
|
seen.insert(elem.attrib["PartName"]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
root = Element("{" + CONTYPES_NS + "}Types");
|
|
|
|
for(auto content_type : static_content_types_config)
|
|
{
|
|
if(setting_type == "Override")
|
|
{
|
|
tag = "{" + CONTYPES_NS + "}Override";
|
|
attrib = {"PartName": "/" + name};
|
|
}
|
|
else
|
|
{
|
|
tag = "{" + CONTYPES_NS + "}Default";
|
|
attrib = {"Extension": name};
|
|
}
|
|
|
|
attrib["ContentType"] = content_type;
|
|
SubElement(root, tag, attrib);
|
|
}
|
|
}
|
|
|
|
int drawing_id = 1;
|
|
int chart_id = 1;
|
|
int comments_id = 1;
|
|
int sheet_id = 0;
|
|
|
|
for(auto sheet : wb)
|
|
{
|
|
std::string name = "/xl/worksheets/sheet" + std::to_string(sheet_id) + ".xml";
|
|
|
|
if(seen.find(name) == seen.end())
|
|
{
|
|
SubElement(root, "{" + CONTYPES_NS + "}Override", {{"PartName", name},
|
|
{"ContentType", "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"}});
|
|
}
|
|
|
|
if(sheet._charts || sheet._images)
|
|
{
|
|
name = "/xl/drawings/drawing" + drawing_id + ".xml";
|
|
|
|
if(seen.find(name) == seen.end())
|
|
{
|
|
SubElement(root, "{%s}Override" % CONTYPES_NS, {"PartName" : name,
|
|
"ContentType" : "application/vnd.openxmlformats-officedocument.drawing+xml"});
|
|
}
|
|
|
|
drawing_id += 1;
|
|
|
|
for(auto chart : sheet._charts)
|
|
{
|
|
name = "/xl/charts/chart%d.xml" % chart_id;
|
|
|
|
if(seen.find(name) == seen.end())
|
|
{
|
|
SubElement(root, "{%s}Override" % CONTYPES_NS, {"PartName" : name,
|
|
"ContentType" : "application/vnd.openxmlformats-officedocument.drawingml.chart+xml"});
|
|
}
|
|
|
|
chart_id += 1;
|
|
|
|
if(chart._shapes)
|
|
{
|
|
name = "/xl/drawings/drawing%d.xml" % drawing_id;
|
|
|
|
if(seen.find(name) == seen.end())
|
|
{
|
|
SubElement(root, "{%s}Override" % CONTYPES_NS, {"PartName" : name,
|
|
"ContentType" : "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml"});
|
|
}
|
|
|
|
drawing_id += 1;
|
|
}
|
|
}
|
|
}
|
|
if(sheet.get_comment_count() > 0)
|
|
{
|
|
SubElement(root, "{%s}Override" % CONTYPES_NS,
|
|
{"PartName": "/xl/comments%d.xml" % comments_id,
|
|
"ContentType" : "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml"});
|
|
comments_id += 1;
|
|
}
|
|
}*/
|
|
|
|
pugi::xml_document doc;
|
|
auto root_node = doc.append_child("Types");
|
|
root_node.append_attribute("xmlns").set_value("http://schemas.openxmlformats.org/package/2006/content-types");
|
|
|
|
for(auto default_type : content_types.first)
|
|
{
|
|
auto xml_node = root_node.append_child("Default");
|
|
xml_node.append_attribute("Extension").set_value(default_type.first.c_str());
|
|
xml_node.append_attribute("ContentType").set_value(default_type.second.c_str());
|
|
}
|
|
|
|
for(auto override_type : content_types.second)
|
|
{
|
|
auto theme_node = root_node.append_child("Override");
|
|
theme_node.append_attribute("PartName").set_value(override_type.first.c_str());
|
|
theme_node.append_attribute("ContentType").set_value(override_type.second.c_str());
|
|
}
|
|
|
|
std::stringstream ss;
|
|
doc.save(ss);
|
|
return ss.str();
|
|
}
|
|
|
|
std::string write_relationships(const std::unordered_map<std::string, std::pair<std::string, std::string>> &relationships)
|
|
{
|
|
pugi::xml_document doc;
|
|
auto root_node = doc.append_child("Relationships");
|
|
root_node.append_attribute("xmlns").set_value("http://schemas.openxmlformats.org/package/2006/relationships");
|
|
|
|
for(auto relationship : relationships)
|
|
{
|
|
auto app_props_node = root_node.append_child("Relationship");
|
|
app_props_node.append_attribute("Id").set_value(relationship.first.c_str());
|
|
app_props_node.append_attribute("Type").set_value(relationship.second.first.c_str());
|
|
app_props_node.append_attribute("Target").set_value(relationship.second.second.c_str());
|
|
}
|
|
|
|
std::stringstream ss;
|
|
doc.save(ss);
|
|
return ss.str();
|
|
}
|
|
|
|
std::string write_worksheet(worksheet ws)
|
|
{
|
|
pugi::xml_document doc;
|
|
auto root_node = doc.append_child("worksheet");
|
|
root_node.append_attribute("xmlns").set_value("http://schemas.openxmlformats.org/spreadsheetml/2006/main");
|
|
root_node.append_attribute("xmlns:r").set_value("http://schemas.openxmlformats.org/officeDocument/2006/relationships");
|
|
auto dimension_node = root_node.append_child("dimension");
|
|
int width = (std::max)(1, ws.get_highest_column());
|
|
std::string width_letter = xlnt::cell::get_column_letter(width);
|
|
int height = (std::max)(1, ws.get_highest_row());
|
|
auto dimension = width_letter + std::to_string(height);
|
|
dimension_node.append_attribute("ref").set_value(dimension.c_str());
|
|
auto sheet_views_node = root_node.append_child("sheetViews");
|
|
auto sheet_view_node = sheet_views_node.append_child("sheetView");
|
|
sheet_view_node.append_attribute("tabSelected").set_value(1);
|
|
sheet_view_node.append_attribute("workbookViewId").set_value(0);
|
|
|
|
auto selection_node = sheet_view_node.append_child("selection");
|
|
|
|
std::string active_cell = "B2";
|
|
selection_node.append_attribute("activeCell").set_value(active_cell.c_str());
|
|
selection_node.append_attribute("sqref").set_value(active_cell.c_str());
|
|
|
|
auto sheet_format_pr_node = root_node.append_child("sheetFormatPr");
|
|
sheet_format_pr_node.append_attribute("defaultRowHeight").set_value(15);
|
|
|
|
auto sheet_data_node = root_node.append_child("sheetData");
|
|
for(auto row : ws.rows())
|
|
{
|
|
if(row.empty())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
int min = (int)row.size();
|
|
int max = 0;
|
|
bool any_non_null = false;
|
|
|
|
for(auto cell : row)
|
|
{
|
|
min = (std::min)(min, cell::column_index_from_string(cell.get_column()));
|
|
max = (std::max)(max, cell::column_index_from_string(cell.get_column()));
|
|
|
|
if(cell.get_data_type() != cell::type::null)
|
|
{
|
|
any_non_null = true;
|
|
}
|
|
}
|
|
|
|
if(!any_non_null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
auto row_node = sheet_data_node.append_child("row");
|
|
row_node.append_attribute("r").set_value(row.front().get_row() + 1);
|
|
|
|
row_node.append_attribute("spans").set_value((std::to_string(min) + ":" + std::to_string(max)).c_str());
|
|
row_node.append_attribute("x14ac:dyDescent").set_value(0.25);
|
|
|
|
for(auto cell : row)
|
|
{
|
|
if(cell.get_data_type() != cell::type::null)
|
|
{
|
|
auto cell_node = row_node.append_child("c");
|
|
cell_node.append_attribute("r").set_value(cell.get_address().c_str());
|
|
auto value_node = cell_node.append_child("v");
|
|
value_node.text().set(cell.get_value().c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
auto page_margins_node = root_node.append_child("pageMargins");
|
|
page_margins_node.append_attribute("left").set_value(0.7);
|
|
page_margins_node.append_attribute("right").set_value(0.7);
|
|
page_margins_node.append_attribute("top").set_value(0.75);
|
|
page_margins_node.append_attribute("bottom").set_value(0.75);
|
|
page_margins_node.append_attribute("header").set_value(0.3);
|
|
page_margins_node.append_attribute("footer").set_value(0.3);
|
|
std::stringstream ss;
|
|
doc.save(ss);
|
|
return ss.str();
|
|
}
|
|
|
|
std::string create_temporary_file()
|
|
{
|
|
return "a.temp";
|
|
}
|
|
|
|
void delete_temporary_file(const std::string &filename)
|
|
{
|
|
std::remove(filename.c_str());
|
|
}
|
|
|
|
void read_worksheet(worksheet ws, const std::string &content)
|
|
{
|
|
pugi::xml_document doc;
|
|
doc.load(content.c_str());
|
|
|
|
auto root_node = doc.child("worksheet");
|
|
auto dimension_node = root_node.child("dimension");
|
|
std::string dimension = dimension_node.attribute("ref").as_string();
|
|
ws.range(dimension);
|
|
}
|
|
|
|
std::unordered_map<std::string, std::pair<std::string, std::string>> read_relationships(const std::string &content)
|
|
{
|
|
pugi::xml_document doc;
|
|
doc.load(content.c_str());
|
|
|
|
auto root_node = doc.child("Relationships");
|
|
|
|
std::unordered_map<std::string, std::pair<std::string, std::string>> relationships;
|
|
|
|
for(auto relationship : root_node.children("Relationship"))
|
|
{
|
|
std::string id = relationship.attribute("Id").as_string();
|
|
std::string type = relationship.attribute("Type").as_string();
|
|
std::string target = relationship.attribute("Target").as_string();
|
|
relationships[id] = std::make_pair(type, target);
|
|
}
|
|
|
|
return relationships;
|
|
}
|
|
|
|
std::pair<std::unordered_map<std::string, std::string>, std::unordered_map<std::string, std::string>> read_content_types(const std::string &content)
|
|
{
|
|
pugi::xml_document doc;
|
|
doc.load(content.c_str());
|
|
|
|
auto root_node = doc.child("Types");
|
|
|
|
std::unordered_map<std::string, std::string> default_types;
|
|
|
|
for(auto child : root_node.children("Default"))
|
|
{
|
|
default_types[child.attribute("Extension").as_string()] = child.attribute("ContentType").as_string();
|
|
}
|
|
|
|
std::unordered_map<std::string, std::string> override_types;
|
|
|
|
for(auto child : root_node.children("Override"))
|
|
{
|
|
override_types[child.attribute("PartName").as_string()] = child.attribute("ContentType").as_string();
|
|
}
|
|
|
|
return std::make_pair(default_types, override_types);
|
|
}
|
|
|
|
workbook::workbook(optimized optimized)
|
|
: optimized_write_(optimized==optimized::write),
|
|
optimized_read_(optimized==optimized::read),
|
|
active_sheet_index_(0)
|
|
{
|
|
if(!optimized_write_)
|
|
{
|
|
auto ws = create_sheet();
|
|
ws.set_title("Sheet1");
|
|
}
|
|
}
|
|
|
|
worksheet workbook::get_sheet_by_name(const std::string &name)
|
|
{
|
|
auto match = std::find_if(worksheets_.begin(), worksheets_.end(), [&](const worksheet &w) { return w.get_title() == name; });
|
|
if(match != worksheets_.end())
|
|
{
|
|
return worksheet(*match);
|
|
}
|
|
return worksheet(nullptr);
|
|
}
|
|
|
|
worksheet workbook::get_active_sheet()
|
|
{
|
|
return worksheets_[active_sheet_index_];
|
|
}
|
|
|
|
worksheet workbook::create_sheet()
|
|
{
|
|
std::string title = "Sheet1";
|
|
int index = 1;
|
|
while(get_sheet_by_name(title) != nullptr)
|
|
{
|
|
title = "Sheet" + std::to_string(++index);
|
|
}
|
|
auto *worksheet = new worksheet_struct(*this, title);
|
|
worksheets_.push_back(worksheet);
|
|
return get_sheet_by_name(title);
|
|
}
|
|
|
|
void workbook::create_named_range(const std::string &/*range_string*/, worksheet /*ws*/, const std::string &/*name*/)
|
|
{
|
|
|
|
}
|
|
|
|
void workbook::load(const std::string &filename)
|
|
{
|
|
zip_file f(filename, file_mode::open);
|
|
//auto core_properties = read_core_properties();
|
|
//auto app_properties = read_app_properties();
|
|
auto root_relationships = read_relationships(f.get_file_contents("_rels/.rels"));
|
|
auto workbook_relationships = read_relationships(f.get_file_contents("xl/_rels/workbook.xml.rels"));
|
|
auto content_types = read_content_types(f.get_file_contents("[Content_Types].xml"));
|
|
|
|
pugi::xml_document doc;
|
|
doc.load(f.get_file_contents("xl/workbook.xml").c_str());
|
|
|
|
auto root_node = doc.child("workbook");
|
|
auto sheets_node = root_node.child("sheets");
|
|
|
|
while(!worksheets_.empty())
|
|
{
|
|
remove_sheet(worksheets_.front());
|
|
}
|
|
|
|
for(auto sheet_node : sheets_node.children("sheet"))
|
|
{
|
|
auto relation_id = sheet_node.attribute("r:id").as_string();
|
|
auto ws = create_sheet(sheet_node.attribute("name").as_string());
|
|
std::string sheet_filename("xl/");
|
|
sheet_filename += workbook_relationships[relation_id].second;
|
|
read_worksheet(ws, f.get_file_contents(sheet_filename));
|
|
}
|
|
}
|
|
|
|
void workbook::remove_sheet(worksheet ws)
|
|
{
|
|
auto match_iter = std::find(worksheets_.begin(), worksheets_.end(), ws);
|
|
if(match_iter == worksheets_.end())
|
|
{
|
|
throw std::runtime_error("worksheet not owned by this workbook");
|
|
}
|
|
delete match_iter->root_;
|
|
worksheets_.erase(match_iter);
|
|
}
|
|
|
|
worksheet workbook::create_sheet(std::size_t index)
|
|
{
|
|
auto ws = create_sheet();
|
|
if(index != worksheets_.size())
|
|
{
|
|
std::swap(worksheets_[index], worksheets_.back());
|
|
}
|
|
return ws;
|
|
}
|
|
|
|
worksheet workbook::create_sheet(const std::string &title)
|
|
{
|
|
if(title.length() > 31)
|
|
{
|
|
throw bad_sheet_title(title);
|
|
}
|
|
|
|
if(std::find_if(title.begin(), title.end(),
|
|
[](char c) { return !(std::isalpha(c, std::locale::classic())
|
|
|| std::isdigit(c, std::locale::classic())); }) != title.end())
|
|
{
|
|
throw bad_sheet_title(title);
|
|
}
|
|
|
|
if(get_sheet_by_name(title) != nullptr)
|
|
{
|
|
throw std::runtime_error("sheet exists");
|
|
}
|
|
auto *worksheet = new worksheet_struct(*this, title);
|
|
worksheets_.push_back(worksheet);
|
|
return get_sheet_by_name(title);
|
|
}
|
|
|
|
std::vector<worksheet>::iterator workbook::begin()
|
|
{
|
|
return worksheets_.begin();
|
|
}
|
|
|
|
std::vector<worksheet>::iterator workbook::end()
|
|
{
|
|
return worksheets_.end();
|
|
}
|
|
|
|
std::vector<std::string> workbook::get_sheet_names() const
|
|
{
|
|
std::vector<std::string> names;
|
|
for(auto &ws : worksheets_)
|
|
{
|
|
names.push_back(ws.get_title());
|
|
}
|
|
return names;
|
|
}
|
|
|
|
worksheet workbook::operator[](const std::string &name)
|
|
{
|
|
return get_sheet_by_name(name);
|
|
}
|
|
|
|
worksheet workbook::operator[](int index)
|
|
{
|
|
return worksheets_[index];
|
|
}
|
|
|
|
|
|
void workbook::save(const std::string &filename)
|
|
{
|
|
zip_file f(filename, file_mode::create, file_access::write);
|
|
|
|
std::pair<std::unordered_map<std::string, std::string>, std::unordered_map<std::string, std::string>> content_types =
|
|
{
|
|
{
|
|
{"rels", "application/vnd.openxmlformats-package.relationships+xml"},
|
|
{"xml", "application/xml"}
|
|
},
|
|
{
|
|
{"/xl/styles.xml", "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"},
|
|
{"/xl/workbook.xml", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"},
|
|
{"/docProps/app.xml", "application/vnd.openxmlformats-officedocument.extended-properties+xml"},
|
|
{"/xl/worksheets/sheet1.xml", "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"},
|
|
{"/docProps/core.xml", "application/vnd.openxmlformats-package.core-properties+xml"},
|
|
{"/xl/theme/theme1.xml", "application/vnd.openxmlformats-officedocument.theme+xml"}
|
|
}
|
|
};
|
|
|
|
f.set_file_contents("[Content_Types].xml", write_content_types(content_types));
|
|
|
|
std::unordered_map<std::string, std::pair<std::string, std::string>> root_rels =
|
|
{
|
|
{"rId3", {"http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties", "docProps/app.xml"}},
|
|
{"rId2", {"http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties", "docProps/core.xml"}},
|
|
{"rId1", {"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument", "xl/workbook.xml"}}
|
|
};
|
|
f.set_file_contents("_rels/.rels", write_relationships(root_rels));
|
|
|
|
std::unordered_map<std::string, std::pair<std::string, std::string>> workbook_rels =
|
|
{
|
|
{"rId1", {"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet", "worksheets/sheet1.xml"}},
|
|
{"rId2", {"http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles", "styles.xml"}},
|
|
{"rId3", {"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme", "theme/theme1.xml"}}
|
|
};
|
|
f.set_file_contents("xl/_rels/workbook.xml.rels", write_relationships(workbook_rels));
|
|
|
|
pugi::xml_document doc;
|
|
auto root_node = doc.append_child("workbook");
|
|
root_node.append_attribute("xmlns").set_value("http://schemas.openxmlformats.org/spreadsheetml/2006/main");
|
|
root_node.append_attribute("xmlns:r").set_value("http://schemas.openxmlformats.org/officeDocument/2006/relationships");
|
|
auto sheets_node = root_node.append_child("sheets");
|
|
|
|
int i = 0;
|
|
for(auto ws : *this)
|
|
{
|
|
auto sheet_node = sheets_node.append_child("sheet");
|
|
sheet_node.append_attribute("name").set_value(ws.get_title().c_str());
|
|
sheet_node.append_attribute("sheetId").set_value(std::to_string(i + 1).c_str());
|
|
sheet_node.append_attribute("r:id").set_value((std::string("rId") + std::to_string(i + 1)).c_str());
|
|
std::string filename = "xl/worksheets/sheet";
|
|
f.set_file_contents(filename + std::to_string(i + 1) + ".xml", write_worksheet(ws));
|
|
i++;
|
|
}
|
|
|
|
std::stringstream ss;
|
|
doc.save(ss);
|
|
|
|
f.set_file_contents("xl/workbook.xml", ss.str());
|
|
}
|
|
|
|
std::string cell_struct::to_string() const
|
|
{
|
|
return "<Cell " + parent_worksheet->title_ + "." + xlnt::cell::get_column_letter(column + 1) + std::to_string(row + 1) + ">";
|
|
}
|
|
|
|
bool workbook::operator==(const workbook &rhs) const
|
|
{
|
|
if(optimized_write_ == rhs.optimized_write_
|
|
&& optimized_read_ == rhs.optimized_read_
|
|
&& guess_types_ == rhs.guess_types_
|
|
&& data_only_ == rhs.data_only_
|
|
&& active_sheet_index_ == rhs.active_sheet_index_
|
|
&& encoding_ == rhs.encoding_)
|
|
{
|
|
if(worksheets_.size() != rhs.worksheets_.size())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for(std::size_t i = 0; i < worksheets_.size(); i++)
|
|
{
|
|
if(worksheets_[i] != rhs.worksheets_[i])
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/*
|
|
if(named_ranges_.size() != rhs.named_ranges_.size())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for(int i = 0; i < named_ranges_.size(); i++)
|
|
{
|
|
if(named_ranges_[i] != rhs.named_ranges_[i])
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if(relationships_.size() != rhs.relationships_.size())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for(int i = 0; i < relationships_.size(); i++)
|
|
{
|
|
if(relationships_[i] != rhs.relationships_[i])
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if(drawings_.size() != rhs.drawings_.size())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for(int i = 0; i < drawings_.size(); i++)
|
|
{
|
|
if(drawings_[i] != rhs.drawings_[i])
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
*/
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void sheet_protection::set_password(const std::string &password)
|
|
{
|
|
hashed_password_ = hash_password(password);
|
|
}
|
|
|
|
template< typename T >
|
|
std::string int_to_hex(T i)
|
|
{
|
|
std::stringstream stream;
|
|
stream << std::hex << i;
|
|
return stream.str();
|
|
}
|
|
|
|
std::string sheet_protection::hash_password(const std::string &plaintext_password)
|
|
{
|
|
int password = 0x0000;
|
|
int i = 1;
|
|
|
|
for(auto character : plaintext_password)
|
|
{
|
|
int value = character << i;
|
|
int rotated_bits = value >> 15;
|
|
value &= 0x7fff;
|
|
password ^= (value | rotated_bits);
|
|
i++;
|
|
}
|
|
|
|
password ^= plaintext_password.size();
|
|
password ^= 0xCE4B;
|
|
|
|
std::string hashed = int_to_hex(password);
|
|
std::transform(hashed.begin(), hashed.end(), hashed.begin(), [](char c){ return std::toupper(c, std::locale::classic()); });
|
|
return hashed;
|
|
}
|
|
|
|
int string_table::operator[](const std::string &/*key*/) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void string_table_builder::add(const std::string &/*string*/)
|
|
{
|
|
|
|
}
|
|
|
|
}
|