X-Git-Url: https://git.ucc.asn.au/?p=ipdf%2Fcode.git;a=blobdiff_plain;f=src%2Fdocument.cpp;h=921763a827590e89d5a3d8cbfd6a830387e417ea;hp=3c1a4ab20020be09316fa57400b34fdd62406315;hb=ee5287fabfb214e8f7b483cde424108270525fd7;hpb=428f1eb86a616d95dbb72ff08a3d09771d5c47e6 diff --git a/src/document.cpp b/src/document.cpp index 3c1a4ab..921763a 100644 --- a/src/document.cpp +++ b/src/document.cpp @@ -1,10 +1,53 @@ #include "document.h" - +#include "bezier.h" #include using namespace IPDF; using namespace std; +//TODO: Make this work for variable sized Reals + +// Loads an std::vector of size num_elements from a file. +template +static void LoadStructVector(FILE *src_file, size_t num_elems, std::vector& dest) +{ + size_t structsread = 0; + dest.resize(num_elems); + structsread = fread(dest.data(), sizeof(T), num_elems, src_file); + if (structsread != num_elems) + Fatal("Only read %u structs (expected %u)!", structsread, num_elems); +} + +// Saves an std::vector to a file. Size must be saves separately. +template +static void SaveStructVector(FILE *dst_file, std::vector& src) +{ + size_t written = 0; + written = fwrite(src.data(), sizeof(T), src.size(), dst_file); + if (written != src.size()) + Fatal("Only wrote %u structs (expected %u)!", written, src.size()); +} + +static void WriteChunkHeader(FILE *dst_file, DocChunkTypes type, uint32_t size) +{ + size_t written = 0; + written = fwrite(&type, sizeof(type), 1, dst_file); + if (written != 1) + Fatal("Could not write Chunk header! (ID)"); + written = fwrite(&size, sizeof(size), 1, dst_file); + if (written != 1) + Fatal("Could not write Chunk header (size)!"); +} + +static bool ReadChunkHeader(FILE *src_file, DocChunkTypes& type, uint32_t& size) +{ + if (fread(&type, sizeof(DocChunkTypes), 1, src_file) != 1) + return false; + if (fread(&size, sizeof(uint32_t), 1, src_file) != 1) + return false; + return true; +} + void Document::Save(const string & filename) { Debug("Saving document to file \"%s\"...", filename.c_str()); @@ -14,14 +57,26 @@ void Document::Save(const string & filename) size_t written; Debug("Number of objects (%u)...", ObjectCount()); + WriteChunkHeader(file, CT_NUMOBJS, sizeof(m_count)); written = fwrite(&m_count, sizeof(m_count), 1, file); if (written != 1) Fatal("Failed to write number of objects!"); + Debug("Object types..."); + WriteChunkHeader(file, CT_OBJTYPES, m_objects.types.size() * sizeof(ObjectType)); + SaveStructVector(file, m_objects.types); + Debug("Object bounds..."); - written = fwrite(m_objects.bounds.data(), sizeof(Rect), m_objects.bounds.size(), file); - if (written != ObjectCount()) - Fatal("Only wrote %u objects!", written); + WriteChunkHeader(file, CT_OBJBOUNDS, m_objects.bounds.size() * sizeof(Rect)); + SaveStructVector(file, m_objects.bounds); + + Debug("Object data indices..."); + WriteChunkHeader(file, CT_OBJINDICES, m_objects.data_indices.size() * sizeof(unsigned)); + SaveStructVector(file, m_objects.data_indices); + + Debug("Bezier data..."); + WriteChunkHeader(file, CT_OBJBEZIERS, m_objects.beziers.size() * sizeof(uint8_t)); + SaveStructVector(file, m_objects.beziers); int err = fclose(file); if (err != 0) @@ -45,37 +100,68 @@ void Document::Load(const string & filename) Fatal("Couldn't open file \"%s\"", filename.c_str(), strerror(errno)); size_t read; - read = fread(&m_count, sizeof(m_count), 1, file); - if (read != 1) - Fatal("Failed to read number of objects!"); - Debug("Number of objects: %u", ObjectCount()); - m_objects.bounds.resize(ObjectCount()); - - Debug("Object bounds..."); - read = fread(m_objects.bounds.data(), sizeof(Rect), m_objects.bounds.size(), file); - if (read != ObjectCount()) - Fatal("Only read %u objects!", read); - + DocChunkTypes chunk_type; + uint32_t chunk_size; + while (ReadChunkHeader(file, chunk_type, chunk_size)) + { + switch(chunk_type) + { + case CT_NUMOBJS: + read = fread(&m_count, sizeof(m_count), 1, file); + if (read != 1) + Fatal("Failed to read number of objects!"); + Debug("Number of objects: %u", ObjectCount()); + break; + case CT_OBJTYPES: + Debug("Object types..."); + LoadStructVector(file, chunk_size/sizeof(ObjectType), m_objects.types); + break; + case CT_OBJBOUNDS: + Debug("Object bounds..."); + LoadStructVector(file, chunk_size/sizeof(Rect), m_objects.bounds); + break; + case CT_OBJINDICES: + Debug("Object data indices..."); + LoadStructVector(file, chunk_size/sizeof(unsigned), m_objects.data_indices); + break; + case CT_OBJBEZIERS: + Debug("Bezier data..."); + LoadStructVector(file, chunk_size/sizeof(Bezier), m_objects.beziers); + break; + } + } Debug("Successfully loaded %u objects from \"%s\"", ObjectCount(), filename.c_str()); } -void Document::Add(Real x, Real y, Real w, Real h) +void Document::Add(ObjectType type, const Rect & bounds, unsigned data_index) { - m_objects.bounds.push_back(Rect(x, y, w, h)); - m_count++; + m_objects.types.push_back(type); + m_objects.bounds.push_back(bounds); + m_objects.data_indices.push_back(data_index); + ++m_count; // Why can't we just use the size of types or something? } +unsigned Document::AddBezierData(const Bezier & bezier) +{ + m_objects.beziers.push_back(bezier); + return m_objects.beziers.size()-1; +} + + void Document::DebugDumpObjects() { Debug("Objects for Document %p are:", this); for (unsigned id = 0; id < ObjectCount(); ++id) { - Debug("%u.\t%s", id, m_objects.bounds[id].Str().c_str()); + Debug("%u. \tType: %u\tBounds: %s", id, m_objects.types[id], m_objects.bounds[id].Str().c_str()); } } bool Document::operator==(const Document & equ) const { - return (ObjectCount() == equ.ObjectCount() && memcmp(m_objects.bounds.data(), equ.m_objects.bounds.data(), ObjectCount() * sizeof(Rect)) == 0); + return (ObjectCount() == equ.ObjectCount() + && memcmp(m_objects.bounds.data(), equ.m_objects.bounds.data(), ObjectCount() * sizeof(Rect)) == 0 + && memcmp(m_objects.data_indices.data(), equ.m_objects.data_indices.data(), ObjectCount() * sizeof(unsigned)) == 0 + && memcmp(m_objects.beziers.data(), equ.m_objects.beziers.data(), m_objects.beziers.size() * sizeof(Bezier)) == 0); }