#include "document.h"
#include "bezier.h"
+#include "profiler.h"
#include <cstdio>
#include <fstream>
#include "../contrib/pugixml-1.4/src/pugixml.cpp"
+#include "transformationtype.h"
#include "stb_truetype.h"
void Document::GenBaseQuadtree()
{
- m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QTC_UNKNOWN, 0, ObjectCount()});
+ m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QTC_UNKNOWN, 0, ObjectCount(), -1});
m_quadtree.root_id = 0;
- GenQuadChild(0, QTC_TOP_LEFT);
}
int Document::ClipObjectToQuadChild(int object_id, QuadTreeNodeChildren type)
{
+ PROFILE_SCOPE("Document::ClipObjectToQuadChild");
switch (m_objects.types[object_id])
{
case RECT_FILLED:
case RECT_OUTLINE:
+ case PATH:
{
Rect obj_bounds = TransformToQuadChild(m_objects.bounds[object_id], type);
if (obj_bounds.x < 0)
Rect new_bounds = TransformToQuadChild(m_objects.bounds[object_id], type);
Bezier new_curve_data = new_curves[i].ToAbsolute(TransformToQuadChild(m_objects.bounds[object_id],type));
new_bounds = new_curve_data.SolveBounds();
+ Debug("New bounds: %s", new_bounds.Str().c_str());
new_curve_data = new_curve_data.ToRelative(new_bounds);
unsigned index = AddBezierData(new_curve_data);
m_objects.bounds.push_back(new_bounds);
}
QuadTreeIndex Document::GenQuadChild(QuadTreeIndex parent, QuadTreeNodeChildren type)
{
+ PROFILE_SCOPE("Document::GenQuadChild()");
QuadTreeIndex new_index = m_quadtree.nodes.size();
- m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, parent, type, 0, 0});
+ Debug("-------------- Generating Quadtree Node %d (parent %d, type %d) ----------------------", new_index, parent, type);
+ m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, parent, type, 0, 0, -1, true});
m_quadtree.nodes[new_index].object_begin = m_objects.bounds.size();
- for (unsigned i = m_quadtree.nodes[parent].object_begin; i < m_quadtree.nodes[parent].object_end; ++i)
+ for (QuadTreeIndex overlay = parent; overlay != -1; overlay = m_quadtree.nodes[overlay].next_overlay)
{
- if (IntersectsQuadChild(m_objects.bounds[i], type))
+ for (unsigned i = m_quadtree.nodes[overlay].object_begin; i < m_quadtree.nodes[overlay].object_end; ++i)
{
- m_count += ClipObjectToQuadChild(i, type);
+ if (IntersectsQuadChild(m_objects.bounds[i], type))
+ {
+ m_count += ClipObjectToQuadChild(i, type);
+ }
}
}
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:
default:
Fatal("Tried to add a QuadTree child of invalid type!");
}
+ m_document_dirty = true;
return new_index;
}
+void Document::OverlayQuadChildren(QuadTreeIndex orig_parent, QuadTreeIndex parent, QuadTreeNodeChildren type)
+{
+ PROFILE_SCOPE("Document::OverlayQuadChildren()");
+ 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, true});
+
+ 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;
+ break;
+ case QTC_TOP_RIGHT:
+ orig_node = m_quadtree.nodes[orig_parent].top_right;
+ break;
+ case QTC_BOTTOM_LEFT:
+ orig_node = m_quadtree.nodes[orig_parent].bottom_left;
+ break;
+ case QTC_BOTTOM_RIGHT:
+ orig_node = m_quadtree.nodes[orig_parent].bottom_right;
+ 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) prev_overlay = m_quadtree.nodes[prev_overlay].next_overlay;
+ Debug("- Original node %d, Previous overlay %d, new overlay %d", orig_node, prev_overlay, new_index);
+ 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;
+ m_quadtree.nodes[new_index].next_overlay = -1;
+ m_document_dirty = true;
+}
+
+void Document::OverlayQuadParent(QuadTreeIndex orig_child, QuadTreeIndex child, QuadTreeNodeChildren type)
+{
+ PROFILE_SCOPE("Document::OverlayQuadParent()");
+ QuadTreeIndex new_index = m_quadtree.nodes.size();
+ m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, -1, QTC_UNKNOWN, 0, 0, -1, true});
+
+ m_quadtree.nodes[new_index].object_begin = m_objects.bounds.size();
+ m_quadtree.nodes[new_index].object_dirty = m_objects.bounds.size();
+ for (QuadTreeIndex overlay = child; overlay != -1; overlay = m_quadtree.nodes[overlay].next_overlay)
+ {
+ for (unsigned i = m_quadtree.nodes[overlay].object_begin; i < m_quadtree.nodes[overlay].object_end; ++i)
+ {
+ Rect new_bounds = TransformFromQuadChild(m_objects.bounds[i], type);
+ // If the object is too small to be seen, discard it.
+ if (!new_bounds.w || !new_bounds.h) continue;
+ m_objects.bounds.push_back(new_bounds);
+ m_objects.types.push_back(m_objects.types[i]);
+ m_objects.data_indices.push_back(m_objects.data_indices[i]);
+ m_count++;
+ }
+ }
+ m_quadtree.nodes[new_index].object_end = m_objects.bounds.size();
+ QuadTreeIndex orig_node = m_quadtree.nodes[orig_child].parent;
+ 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) prev_overlay = m_quadtree.nodes[prev_overlay].next_overlay;
+ m_quadtree.nodes[prev_overlay].next_overlay = new_index;
+ Debug("OverlayQuadParent(%d, %d, %d) = %d", orig_child, child, type, new_index);
+
+ // Recurse into any extant parent.
+ if (m_quadtree.nodes[orig_node].parent != -1)
+ OverlayQuadParent(orig_node, new_index, m_quadtree.nodes[orig_node].child_type);
+
+ m_quadtree.nodes[new_index].object_dirty = m_quadtree.nodes[new_index].object_end;
+ m_quadtree.nodes[new_index].next_overlay = -1;
+ m_document_dirty = true;
+}
+
+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 our parent, should we have any.
+ if (m_quadtree.nodes[node].parent != -1)
+ OverlayQuadParent(node, overlay, m_quadtree.nodes[node].child_type);
+ // 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)
{
QuadTreeIndex new_index = m_quadtree.nodes.size();
- m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, -1, QTC_UNKNOWN, 0, 0});
+ m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, -1, QTC_UNKNOWN, 0, 0, -1, true});
m_quadtree.nodes[new_index].object_begin = m_objects.bounds.size();
- for (unsigned i = m_quadtree.nodes[child].object_begin; i < m_quadtree.nodes[child].object_end; ++i)
+ for (QuadTreeIndex overlay = child; overlay != -1; overlay = m_quadtree.nodes[overlay].next_overlay)
{
- m_objects.bounds.push_back(TransformFromQuadChild(m_objects.bounds[i], type));
- m_objects.types.push_back(m_objects.types[i]);
- m_objects.data_indices.push_back(m_objects.data_indices[i]);
- m_count++;
+ for (unsigned i = m_quadtree.nodes[overlay].object_begin; i < m_quadtree.nodes[overlay].object_end; ++i)
+ {
+ Rect new_bounds = TransformFromQuadChild(m_objects.bounds[i], type);
+ // If the object is too small to be seen, discard it.
+ if (!new_bounds.w || !new_bounds.h) continue;
+ m_objects.bounds.push_back(new_bounds);
+ m_objects.types.push_back(m_objects.types[i]);
+ m_objects.data_indices.push_back(m_objects.data_indices[i]);
+ m_count++;
+ }
}
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:
Fatal("Tried to add a QuadTree child of invalid type!");
}
return new_index;
+ m_document_dirty = true;
}
#endif
unsigned data_index = AddPathData(path);
Rect bounds = path.SolveBounds(m_objects);
unsigned result = Add(PATH, bounds,data_index);
+ m_objects.paths[data_index].m_index = result;
//Debug("Added path %u -> %u (%u objects) colour {%u,%u,%u,%u}, stroke {%u,%u,%u,%u}", start_index, end_index, (end_index - start_index), fill.r, fill.g, fill.b, fill.a, stroke.r, stroke.g, stroke.b, stroke.a);
return result;
}
Bezier data = bezier.ToRelative(bounds); // Relative
if (data.ToAbsolute(bounds) != bezier)
{
- Warn("%s != %s", data.ToAbsolute(Rect(0,0,1,1)).Str().c_str(),
+ Warn("%s != %s", data.ToAbsolute(bounds).Str().c_str(),
bezier.Str().c_str());
Warn("ToAbsolute on ToRelative does not give original Bezier");
}
unsigned index = AddBezierData(data);
return Add(BEZIER, bounds, index);
}
+// Adds an object to the Document, clipping it to m_clip_rect.
+// Helper function called by Document::Add()
+int Document::AddClip(ObjectType type, const Rect& bounds, unsigned data_index, const Rect& clip_rect)
+{
+ PROFILE_SCOPE("Document::AddAndClip");
+ switch (type)
+ {
+ case RECT_FILLED:
+ case RECT_OUTLINE:
+ case PATH:
+ {
+ Rect obj_bounds = clip_rect.Clip(bounds);
+ m_objects.bounds.push_back(obj_bounds);
+ m_objects.types.push_back(type);
+ m_objects.data_indices.push_back(data_index);
+ return 1;
+ }
+ case BEZIER:
+ {
+ // If we're entirely within the clipping rect, no clipping need occur.
+ if (clip_rect.Contains(bounds))
+ {
+ m_objects.bounds.push_back(bounds);
+ m_objects.types.push_back(type);
+ m_objects.data_indices.push_back(data_index);
+ return 1;
+ }
+ Rect clip_bezier_bounds = TransformRectCoordinates(bounds, clip_rect);
+ std::vector<Bezier> new_curves = m_objects.beziers[data_index].ClipToRectangle(clip_bezier_bounds);
+ for (size_t i = 0; i < new_curves.size(); ++i)
+ {
+ Bezier new_curve_data = new_curves[i].ToAbsolute(bounds);
+ Rect new_bounds = new_curve_data.SolveBounds();
+ new_curve_data = new_curve_data.ToRelative(new_bounds);
+ unsigned index = AddBezierData(new_curve_data);
+ m_objects.bounds.push_back(new_bounds);
+ m_objects.types.push_back(BEZIER);
+ m_objects.data_indices.push_back(index);
+ }
+ return new_curves.size();
+ }
+ default:
+ m_objects.bounds.push_back(bounds);
+ m_objects.types.push_back(type);
+ m_objects.data_indices.push_back(data_index);
+ return 1;
+ }
+ return 0;
+}
-unsigned Document::Add(ObjectType type, const Rect & bounds, unsigned data_index)
+unsigned Document::Add(ObjectType type, const Rect & bounds, unsigned data_index, QuadTreeIndex qti)
{
- m_objects.types.push_back(type);
- m_objects.bounds.push_back(bounds);
- m_objects.data_indices.push_back(data_index);
- return (m_count++); // Why can't we just use the size of types or something?
+ PROFILE_SCOPE("Document::Add");
+ Rect new_bounds = bounds;
+#ifndef QUADTREE_DISABLED
+ int num_added = 1;
+ if (qti == -1) qti = m_current_insert_node;
+ if (qti != -1)
+ {
+ // Move the object to the quadtree node it should be in.
+ m_quadtree.GetCanonicalCoords(qti, new_bounds.x, new_bounds.y, this);
+ Rect cliprect = Rect(0,0,1,1);
+ num_added = AddClip(type, new_bounds, data_index, cliprect);
+ }
+ else
+#endif
+ {
+ m_objects.types.push_back(type);
+ m_objects.bounds.push_back(new_bounds);
+ m_objects.data_indices.push_back(data_index);
+ }
+ m_document_dirty = true;
+#ifndef QUADTREE_DISABLED
+ if (qti != -1)
+ {
+ QuadTreeIndex new_qti = qti;
+ while (m_quadtree.nodes[new_qti].next_overlay != -1)
+ {
+ if (m_count == m_quadtree.nodes[new_qti].object_end+1)
+ {
+ m_quadtree.nodes[new_qti].object_end += num_added;
+ m_quadtree.nodes[new_qti].render_dirty = true;
+ new_qti = -1;
+ break;
+ }
+ new_qti = m_quadtree.nodes[new_qti].next_overlay;
+ }
+ if (new_qti != -1)
+ {
+ QuadTreeIndex overlay = m_quadtree.nodes.size();
+ Debug("Adding new overlay, nqti = %d, overlay = %d", new_qti, overlay);
+ m_quadtree.nodes.push_back(QuadTreeNode{QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, QUADTREE_EMPTY, -1, QTC_UNKNOWN, 0, 0, -1});
+ 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+num_added;
+ m_quadtree.nodes[overlay].next_overlay = -1;
+ m_quadtree.nodes[overlay].render_dirty = true;
+ m_quadtree.nodes[new_qti].next_overlay = overlay;
+ new_qti = overlay;
+ }
+ }
+ m_count += num_added;
+ return m_count-num_added;
+#else // words fail me (still not amused)
+ return (m_count++);
+#endif
+
}
unsigned Document::AddBezierData(const Bezier & bezier)
{
string token("");
while (GetToken(d, token, i, delims) == ",");
- x = strtod(token.c_str(),NULL);
+ x = RealFromStr(token);
if (GetToken(d, token, i, delims) != ",")
{
Fatal("Expected \",\" seperating x,y pair");
}
- y = strtod(GetToken(d, token, i, delims).c_str(),NULL);
+ y = RealFromStr(GetToken(d,token,i,delims));
}
static bool GetKeyValuePair(const string & d, string & key, string & value, unsigned & i, const string & delims = "()[],{}<>;:=")
}
else if (command == "scale")
{
- delta.a = (strtod(GetToken(s,token,i).c_str(), NULL));
+ delta.a = RealFromStr(GetToken(s,token,i));
GetToken(s, token, i);
if (token == ",")
{
- delta.d = (strtod(GetToken(s,token,i).c_str(), NULL));
+ delta.d = RealFromStr(GetToken(s,token,i));
assert(GetToken(s, token, i) == ")");
}
else
c = {255,255,255,255};
else if (colour_str.size() == 7 && colour_str[0] == '#')
{
- Debug("Parse colour string: \"%s\"", colour_str.c_str());
+ //Debug("Parse colour string: \"%s\"", colour_str.c_str());
char comp[3] = {colour_str[1], colour_str[2], '\0'};
c.r = strtoul(comp, NULL, 16);
comp[0] = colour_str[3]; comp[1] = colour_str[4];
comp[0] = colour_str[5]; comp[1] = colour_str[6];
c.b = strtoul(comp, NULL, 16);
c.a = 255;
- Debug("Colour is: %u, %u, %u, %u", c.r, c.g, c.b, c.a);
+ //Debug("Colour is: %u, %u, %u, %u", c.r, c.g, c.b, c.a);
}
return c;
}
{
//Debug("Parse node <%s>", root.name());
-
+
+ // Centre the SVGs
+ if (strcmp(root.name(),"svg") == 0)
+ {
+ Real ww = RealFromStr(root.attribute("width").as_string());
+ Real hh = RealFromStr(root.attribute("height").as_string());
+ parent_transform.e -= parent_transform.a * ww/Real(2);
+ parent_transform.f -= parent_transform.d * hh/Real(2);
+ }
+
for (pugi::xml_node child = root.first_child(); child; child = child.next_sibling())
{
SVGMatrix transform(parent_transform);
//Debug("Path data attribute is \"%s\"", d.c_str());
bool closed = false;
pair<unsigned, unsigned> range = ParseSVGPathData(d, transform, closed);
- if (true)//(closed)
+ if (true && range.first < m_count && range.second < m_count)//(closed)
{
string colour_str("");
if (!result)
Error("Couldn't load \"%s\" - %s", filename.c_str(), result.description());
- Debug("Loaded XML - %s", result.description());
+ Debug("Loaded XML from \"%s\" - %s", filename.c_str(), result.description());
input.close();
// a c e, b d f
- SVGMatrix transform = {bounds.w, 0,bounds.x, 0,bounds.h,bounds.y};
+ SVGMatrix transform = {bounds.w,0 ,bounds.x, 0,bounds.h,bounds.y};
ParseSVGNode(doc_xml, transform);
}
if (command == "m" || command == "M")
{
//Debug("Construct moveto command");
- Real dx = Real(strtod(GetToken(d,token,i,delims).c_str(),NULL));
+ Real dx = RealFromStr(GetToken(d,token,i,delims));
assert(GetToken(d,token,i,delims) == ",");
- Real dy = Real(strtod(GetToken(d,token,i,delims).c_str(),NULL));
+ Real dy = RealFromStr(GetToken(d,token,i,delims));
x[0] = (relative) ? x[0] + dx : dx;
y[0] = (relative) ? y[0] + dy : dy;
else if (command == "c" || command == "C" || command == "q" || command == "Q")
{
//Debug("Construct curveto command");
- Real dx = Real(strtod(GetToken(d,token,i,delims).c_str(),NULL));
+ Real dx = RealFromStr(GetToken(d,token,i,delims));
assert(GetToken(d,token,i,delims) == ",");
- Real dy = Real(strtod(GetToken(d,token,i,delims).c_str(),NULL));
+ Real dy = RealFromStr(GetToken(d,token,i,delims));
x[1] = (relative) ? x[0] + dx : dx;
y[1] = (relative) ? y[0] + dy : dy;
- dx = Real(strtod(GetToken(d,token,i,delims).c_str(),NULL));
+ dx = RealFromStr(GetToken(d,token,i,delims));
assert(GetToken(d,token,i,delims) == ",");
- dy = Real(strtod(GetToken(d,token,i,delims).c_str(),NULL));
+ dy = RealFromStr(GetToken(d,token,i,delims));
x[2] = (relative) ? x[0] + dx : dx;
y[2] = (relative) ? y[0] + dy : dy;
if (command != "q" && command != "Q")
{
- dx = Real(strtod(GetToken(d,token,i,delims).c_str(),NULL));
+ dx = RealFromStr(GetToken(d,token,i,delims));
assert(GetToken(d,token,i,delims) == ",");
- dy = Real(strtod(GetToken(d,token,i,delims).c_str(),NULL));
+ dy = RealFromStr(GetToken(d,token,i,delims));
x[3] = (relative) ? x[0] + dx : dx;
y[3] = (relative) ? y[0] + dy : dy;
}
{
//Debug("Construct lineto command, relative %d", relative);
- Real dx = Real(strtod(GetToken(d,token,i,delims).c_str(),NULL));
- Real dy;
+ Real dx = RealFromStr(GetToken(d,token,i,delims));
+ Real dy = 0;
if (command == "l" || command == "L")
{
assert(GetToken(d,token,i,delims) == ",");
- dy = Real(strtod(GetToken(d,token,i,delims).c_str(),NULL));
+ dy = RealFromStr(GetToken(d,token,i,delims));
}
else if (command == "v" || command == "V")
{
stbtt_FreeShape(font, instructions);
}
+
+void Document::TransformObjectBounds(const SVGMatrix & transform, ObjectType type)
+{
+ #ifdef TRANSFORM_BEZIERS_TO_PATH
+ for (unsigned i = 0; i < m_objects.paths.size(); ++i)
+ {
+ Path & p = m_objects.paths[i];
+ p.m_bounds.x = transform.a * p.m_bounds.x + transform.e;
+ p.m_bounds.y = transform.d * p.m_bounds.y + transform.f;
+ p.m_bounds.w *= transform.a;
+ p.m_bounds.h *= transform.d;
+ }
+ return;
+ #endif
+
+ for (unsigned i = 0; i < m_count; ++i)
+ {
+ if (type == NUMBER_OF_OBJECT_TYPES || m_objects.types[i] == type)
+ {
+ TransformXYPair(m_objects.bounds[i].x, m_objects.bounds[i].y, transform);
+ m_objects.bounds[i].w *= transform.a;
+ m_objects.bounds[i].h *= transform.d;
+ }
+ }
+}
+
+void Document::TranslateObjects(const Real & dx, const Real & dy, ObjectType type)
+{
+ #ifdef TRANSFORM_BEZIERS_TO_PATH
+ for (unsigned i = 0; i < m_objects.paths.size(); ++i)
+ {
+ Path & p = m_objects.paths[i];
+ p.m_bounds.x += dx;
+ p.m_bounds.y += dy;
+ }
+ return;
+ #endif
+
+ for (unsigned i = 0; i < m_count; ++i)
+ {
+ if (type == NUMBER_OF_OBJECT_TYPES || m_objects.types[i] == type)
+ {
+ m_objects.bounds[i].x += dx;
+ m_objects.bounds[i].y += dy;
+ }
+ }
+}
+
+void Document::ScaleObjectsAboutPoint(const Real & x, const Real & y, const Real & scale_amount, ObjectType type)
+{
+ #ifdef TRANSFORM_BEZIERS_TO_PATH
+ for (unsigned i = 0; i < m_objects.paths.size(); ++i)
+ {
+ Path & p = m_objects.paths[i];
+ p.m_bounds.w /= scale_amount;
+ p.m_bounds.h /= scale_amount;
+ p.m_bounds.x -= x;
+ p.m_bounds.x /= scale_amount;
+ p.m_bounds.x += x;
+ p.m_bounds.y -= y;
+ p.m_bounds.y /= scale_amount;
+ p.m_bounds.y += y;
+ }
+ return;
+ #endif
+
+ for (unsigned i = 0; i < m_count; ++i)
+ {
+ if (type != NUMBER_OF_OBJECT_TYPES && m_objects.types[i] != type)
+ continue;
+
+ m_objects.bounds[i].w /= scale_amount;
+ m_objects.bounds[i].h /= scale_amount;
+ //m_objects.bounds[i].x = x + (m_objects.bounds[i].x-x)/scale_amount;
+ //m_objects.bounds[i].y = y + (m_objects.bounds[i].y-x)/scale_amount;
+ m_objects.bounds[i].x -= x;
+ m_objects.bounds[i].x /= scale_amount;
+ m_objects.bounds[i].x += x;
+
+ m_objects.bounds[i].y -= y;
+ m_objects.bounds[i].y /= scale_amount;
+ m_objects.bounds[i].y += y;
+ }
+
+}
+
+