src/document.cpp

   1 #include "document.h"
   2 #include "bezier.h"
   3 #include <cstdio>
   4
   5 using namespace IPDF;
   6 using namespace std;
   7
   8 //TODO: Make this work for variable sized Reals
   9
  10 // Loads an std::vector<T> of size num_elements from a file.
  11 template<typename T>
  12 static void LoadStructVector(FILE *src_file, size_t num_elems, std::vector<T>& dest)
  13 {
  14         size_t structsread = 0;
  15         dest.resize(num_elems);
  16         structsread = fread(dest.data(), sizeof(T), num_elems, src_file);
  17         if (structsread != num_elems)
  18                 Fatal("Only read %u structs (expected %u)!", structsread, num_elems);
  19 }
  20
  21 // Saves an std::vector<T> to a file. Size must be saves separately.
  22 template<typename T>
  23 static void SaveStructVector(FILE *dst_file, std::vector<T>& src)
  24 {
  25         size_t written = 0;
  26         written = fwrite(src.data(), sizeof(T), src.size(), dst_file);
  27         if (written != src.size())
  28                 Fatal("Only wrote %u structs (expected %u)!", written, src.size());
  29 }
  30
  31 static void WriteChunkHeader(FILE *dst_file, DocChunkTypes type, uint32_t size)
  32 {
  33         size_t written = 0;
  34         written = fwrite(&type, sizeof(type), 1, dst_file);
  35         if (written != 1)
  36                 Fatal("Could not write Chunk header! (ID)");
  37         written = fwrite(&size, sizeof(size), 1, dst_file);
  38         if (written != 1)
  39                 Fatal("Could not write Chunk header (size)!");
  40 }
  41
  42 static bool ReadChunkHeader(FILE *src_file, DocChunkTypes& type, uint32_t& size)
  43 {
  44         if (fread(&type, sizeof(DocChunkTypes), 1, src_file) != 1)
  45                 return false;
  46         if (fread(&size, sizeof(uint32_t), 1, src_file) != 1)
  47                 return false;
  48         return true;
  49 }
  50
  51 void Document::Save(const string & filename)
  52 {
  53         Debug("Saving document to file \"%s\"...", filename.c_str());
  54         FILE * file = fopen(filename.c_str(), "w");
  55         if (file == NULL)
  56                 Fatal("Couldn't open file \"%s\" - %s", filename.c_str(), strerror(errno));
  57
  58         size_t written;
  59         Debug("Number of objects (%u)...", ObjectCount());
  60         WriteChunkHeader(file, CT_NUMOBJS, sizeof(m_count));
  61         written = fwrite(&m_count, sizeof(m_count), 1, file);
  62         if (written != 1)
  63                 Fatal("Failed to write number of objects!");
  64
  65         Debug("Object types...");
  66         WriteChunkHeader(file, CT_OBJTYPES, m_objects.types.size() * sizeof(ObjectType));
  67         SaveStructVector<ObjectType>(file, m_objects.types);
  68
  69         Debug("Object bounds...");
  70         WriteChunkHeader(file, CT_OBJBOUNDS, m_objects.bounds.size() * sizeof(Rect));
  71         SaveStructVector<Rect>(file, m_objects.bounds);
  72
  73         Debug("Object data indices...");
  74         WriteChunkHeader(file, CT_OBJINDICES, m_objects.data_indices.size() * sizeof(unsigned));
  75         SaveStructVector<unsigned>(file, m_objects.data_indices);
  76
  77         Debug("Bezier data...");
  78         WriteChunkHeader(file, CT_OBJBEZIERS, m_objects.beziers.size() * sizeof(uint8_t));
  79         SaveStructVector<Bezier>(file, m_objects.beziers);
  80
  81         int err = fclose(file);
  82         if (err != 0)
  83                 Fatal("Failed to close file \"%s\" - %s", filename.c_str(), strerror(err));
  84
  85         Debug("Successfully saved %u objects to \"%s\"", ObjectCount(), filename.c_str());
  86 }
  87
  88 #ifndef QUADTREE_DISABLED
  89
  90 void Document::GenBaseQuadtree()
  91 {
  92         m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, 1, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QTC_UNKNOWN, 0, 1});
  93         m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QTC_UNKNOWN, 1, ObjectCount()});
  94         m_quadtree.root_id = 0;
  95 }
  96
  97 QuadTreeIndex Document::GenQuadNode(QuadTreeIndex parent, QuadTreeNodeChildren type)
  98 {
  99         QuadTreeIndex new_index = m_quadtree.nodes.size();
 100         m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, parent, type, 0, 0});
 101
 102         m_quadtree.nodes[new_index].object_begin = m_objects.bounds.size();
 103         for (unsigned i = m_quadtree.nodes[parent].object_begin; i < m_quadtree.nodes[parent].object_end; ++i)
 104         {
 105                 if (ContainedInQuadChild(m_objects.bounds[i], type))
 106                 {
 107                         m_objects.bounds.push_back(TransformToQuadChild(m_objects.bounds[i], type));
 108                         m_objects.types.push_back(m_objects.types[i]);
 109                         m_objects.data_indices.push_back(m_objects.data_indices[i]);
 110                 }
 111         }
 112         m_quadtree.nodes[new_index].object_end = m_objects.bounds.size();
 113         switch (type)
 114         {
 115                 case QTC_TOP_LEFT:
 116                         m_quadtree.nodes[parent].top_left = new_index;
 117                         break;
 118                 case QTC_TOP_RIGHT:
 119                         m_quadtree.nodes[parent].top_right = new_index;
 120                         break;
 121                 case QTC_BOTTOM_LEFT:
 122                         m_quadtree.nodes[parent].bottom_left = new_index;
 123                         break;
 124                 case QTC_BOTTOM_RIGHT:
 125                         m_quadtree.nodes[parent].bottom_right = new_index;
 126                         break;
 127                 default:
 128                         Fatal("Tried to add a QuadTree child of invalid type!");
 129         }
 130         return new_index;
 131 }
 132
 133 #endif
 134
 135 void Document::Load(const string & filename)
 136 {
 137         m_objects.bounds.clear();
 138         m_count = 0;
 139         if (filename == "")
 140         {
 141                 Debug("Loaded empty document.");
 142                 return;
 143         }
 144         Debug("Loading document from file \"%s\"", filename.c_str());
 145         FILE * file = fopen(filename.c_str(), "r");
 146         if (file == NULL)
 147                 Fatal("Couldn't open file \"%s\"", filename.c_str(), strerror(errno));
 148
 149         size_t read;
 150
 151         DocChunkTypes chunk_type;
 152         uint32_t chunk_size;
 153         while (ReadChunkHeader(file, chunk_type, chunk_size))
 154         {
 155                 switch(chunk_type)
 156                 {
 157                 case CT_NUMOBJS:
 158                         read = fread(&m_count, sizeof(m_count), 1, file);
 159                         if (read != 1)
 160                                 Fatal("Failed to read number of objects!");
 161                         Debug("Number of objects: %u", ObjectCount());
 162                         break;
 163                 case CT_OBJTYPES:
 164                         Debug("Object types...");
 165                         LoadStructVector<ObjectType>(file, chunk_size/sizeof(ObjectType), m_objects.types);
 166                         break;
 167                 case CT_OBJBOUNDS:
 168                         Debug("Object bounds...");
 169                         LoadStructVector<Rect>(file, chunk_size/sizeof(Rect), m_objects.bounds);
 170                         break;
 171                 case CT_OBJINDICES:
 172                         Debug("Object data indices...");
 173                         LoadStructVector<unsigned>(file, chunk_size/sizeof(unsigned), m_objects.data_indices);
 174                         break;
 175                 case CT_OBJBEZIERS:
 176                         Debug("Bezier data...");
 177                         LoadStructVector<Bezier>(file, chunk_size/sizeof(Bezier), m_objects.beziers);
 178                         break;
 179                 }
 180         }
 181         Debug("Successfully loaded %u objects from \"%s\"", ObjectCount(), filename.c_str());
 182 #ifndef QUADTREE_DISABLED
 183         if (m_quadtree.root_id == QUADTREE_EMPTY)
 184         {
 185                 GenBaseQuadtree();
 186         }
 187 #endif
 188 }
 189
 190 void Document::Add(ObjectType type, const Rect & bounds, unsigned data_index)
 191 {
 192         m_objects.types.push_back(type);
 193         m_objects.bounds.push_back(bounds);
 194         m_objects.data_indices.push_back(data_index);
 195         ++m_count; // Why can't we just use the size of types or something?
 196 }
 197
 198 unsigned Document::AddBezierData(const Bezier & bezier)
 199 {
 200         m_objects.beziers.push_back(bezier);
 201         return m_objects.beziers.size()-1;
 202 }
 203
 204
 205 void Document::DebugDumpObjects()
 206 {
 207         Debug("Objects for Document %p are:", this);
 208         for (unsigned id = 0; id < ObjectCount(); ++id)
 209         {
 210                 Debug("%u. \tType: %u\tBounds: %s", id, m_objects.types[id], m_objects.bounds[id].Str().c_str());
 211         }
 212 }
 213
 214 bool Document::operator==(const Document & equ) const
 215 {
 216         return (ObjectCount() == equ.ObjectCount()
 217                 && memcmp(m_objects.bounds.data(), equ.m_objects.bounds.data(), ObjectCount() * sizeof(Rect)) == 0
 218                 && memcmp(m_objects.data_indices.data(), equ.m_objects.data_indices.data(), ObjectCount() * sizeof(unsigned)) == 0
 219                 && memcmp(m_objects.beziers.data(), equ.m_objects.beziers.data(), m_objects.beziers.size() * sizeof(Bezier)) == 0);
 220 }