Painfully merge branch 'master' of git.ucc.asn.au:ipdf/code

Conflicts:
	src/document.cpp

diff --combined src/document.cpp
index ffe3b8a,22e4235..6e022df
--- 1/src/document.cpp
--- 2/src/document.cpp
+++ b/src/document.cpp
@@@ -184,8 -184,6 +184,8 @@@ QuadTreeIndex Document::GenQuadChild(Qu
                }
        }
        m_quadtree.nodes[new_index].object_end = m_objects.bounds.size();
 +      // No objects are dirty.
 +      m_quadtree.nodes[new_index].object_dirty = m_objects.bounds.size();
        switch (type)
        {
                case QTC_TOP_LEFT:
@@@ -206,80 -204,6 +206,80 @@@
        return new_index;
  }
  
 +void Document::OverlayQuadChildren(QuadTreeIndex orig_parent, QuadTreeIndex parent, QuadTreeNodeChildren type)
 +{
 +      QuadTreeIndex new_index = m_quadtree.nodes.size();
 +      Debug("-------------- Generating Quadtree Node %d (orig %d parent %d, type %d) ----------------------", new_index, orig_parent, parent, type);
 +      m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, orig_parent, type, 0, 0, -1});
 +
 +      m_quadtree.nodes[new_index].object_begin = m_objects.bounds.size();
 +      for (unsigned i = m_quadtree.nodes[parent].object_dirty; i < m_quadtree.nodes[parent].object_end; ++i)
 +      {
 +              if (IntersectsQuadChild(m_objects.bounds[i], type))
 +              {
 +                      m_count += ClipObjectToQuadChild(i, type);
 +              }
 +      }
 +      m_quadtree.nodes[new_index].object_end = m_objects.bounds.size();
 +      QuadTreeIndex orig_node = -1;
 +      switch (type)
 +      {
 +              case QTC_TOP_LEFT:
 +                      orig_node = m_quadtree.nodes[orig_parent].top_left = new_index;
 +                      break;
 +              case QTC_TOP_RIGHT:
 +                      orig_node = m_quadtree.nodes[orig_parent].top_right = new_index;
 +                      break;
 +              case QTC_BOTTOM_LEFT:
 +                      orig_node = m_quadtree.nodes[orig_parent].bottom_left = new_index;
 +                      break;
 +              case QTC_BOTTOM_RIGHT:
 +                      orig_node = m_quadtree.nodes[orig_parent].bottom_right = new_index;
 +                      break;
 +              default:
 +                      Fatal("Tried to overlay a QuadTree child of invalid type!");
 +      }
 +      if (orig_node == -1)
 +              Fatal("Tried to overlay a QuadTree child that didn't exist!");
 +
 +      // Add us to the node's overlay linked list.
 +      QuadTreeIndex prev_overlay = orig_node;
 +      while (m_quadtree.nodes[prev_overlay].next_overlay != -1);
 +      m_quadtree.nodes[prev_overlay].next_overlay = new_index;
 +
 +      // Recurse into any extant children.
 +      if (m_quadtree.nodes[orig_node].top_left != -1)
 +              OverlayQuadChildren(orig_node, new_index, QTC_TOP_LEFT);
 +      if (m_quadtree.nodes[orig_node].top_right != -1)
 +              OverlayQuadChildren(orig_node, new_index, QTC_TOP_RIGHT);
 +      if (m_quadtree.nodes[orig_node].bottom_left != -1)
 +              OverlayQuadChildren(orig_node, new_index, QTC_BOTTOM_LEFT);
 +      if (m_quadtree.nodes[orig_node].bottom_right != -1)
 +              OverlayQuadChildren(orig_node, new_index, QTC_BOTTOM_RIGHT);
 +
 +      m_quadtree.nodes[new_index].object_dirty = m_quadtree.nodes[new_index].object_end;
 +}
 +
 +void Document::PropagateQuadChanges(QuadTreeIndex node)
 +{
 +      for(QuadTreeIndex overlay = node; overlay != -1; overlay = m_quadtree.nodes[overlay].next_overlay)
 +      {
 +              // We don't care about clean overlays.
 +              if (m_quadtree.nodes[overlay].object_dirty == m_quadtree.nodes[overlay].object_end) continue;
 +              // Recurse into any extant children.
 +              if (m_quadtree.nodes[node].top_left != -1)
 +                      OverlayQuadChildren(node, overlay, QTC_TOP_LEFT);
 +              if (m_quadtree.nodes[node].top_right != -1)
 +                      OverlayQuadChildren(node, overlay, QTC_TOP_RIGHT);
 +              if (m_quadtree.nodes[node].bottom_left != -1)
 +                      OverlayQuadChildren(node, overlay, QTC_BOTTOM_LEFT);
 +              if (m_quadtree.nodes[node].bottom_right != -1)
 +                      OverlayQuadChildren(node, overlay, QTC_BOTTOM_RIGHT);
 +
 +              m_quadtree.nodes[overlay].object_dirty = m_quadtree.nodes[overlay].object_end;
 +      }
 +}
 +
  // Reparent a quadtree node, making it the "type" child of a new node.
  QuadTreeIndex Document::GenQuadParent(QuadTreeIndex child, QuadTreeNodeChildren type)
  {
@@@ -298,7 -222,6 +298,7 @@@
                }
        }
        m_quadtree.nodes[new_index].object_end = m_objects.bounds.size();
 +      m_quadtree.nodes[new_index].object_dirty = m_objects.bounds.size();
        switch (type)
        {
                case QTC_TOP_LEFT:
@@@ -417,34 -340,24 +417,34 @@@ unsigned Document::Add(ObjectType type
  #ifndef QUADTREE_DISABLED
        if (qti != -1)
        {
 -              while (m_quadtree.nodes[qti].next_overlay != -1)
 +              QuadTreeIndex new_qti = qti;
 +              while (m_quadtree.nodes[new_qti].next_overlay != -1)
                {
 -                      if (m_count == m_quadtree.nodes[qti].object_end+1)
 +                      if (m_count == m_quadtree.nodes[new_qti].object_end+1)
                        {
 -                              m_quadtree.nodes[qti].object_end++;
 +                              m_quadtree.nodes[new_qti].object_end++;
                                goto done;
                        }
 -                      qti = m_quadtree.nodes[qti].next_overlay;
 +                      new_qti = m_quadtree.nodes[new_qti].next_overlay;
 +              }
 +              {
 +                      QuadTreeIndex overlay = m_quadtree.nodes.size();
 +                      Debug("Adding new overlay, nqti = %d, overlay = %d", new_qti, overlay);
 +                      m_quadtree.nodes.push_back(m_quadtree.nodes[qti]);
 +                      m_quadtree.nodes[overlay].object_begin = m_count;
 +                      // All objects are dirty.
 +                      m_quadtree.nodes[overlay].object_dirty = m_count;
 +                      m_quadtree.nodes[overlay].object_end = m_count+1;
 +                      m_quadtree.nodes[overlay].next_overlay = -1;
 +                      m_quadtree.nodes[new_qti].next_overlay = overlay;
 +                      new_qti = overlay;
                }
- done:
 -              QuadTreeIndex overlay = m_quadtree.nodes.size();
 -              m_quadtree.nodes.push_back(m_quadtree.nodes[qti]);
 -              m_quadtree.nodes[overlay].object_begin = m_count;
 -              m_quadtree.nodes[overlay].object_end = m_count+1;
 -              m_quadtree.nodes[qti].next_overlay = overlay;
++done: // matches is not amused, but sulix is nice and moved it inside the #ifdef for him.
 +              m_count++;
 +              PropagateQuadChanges(qti);
        }
 -done: // matches is not amused
  #endif
 -      return (m_count++); // Why can't we just use the size of types or something?
 +      return m_count; // Why can't we just use the size of types or something?
  }
  
  unsigned Document::AddBezierData(const Bezier & bezier)