![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: fa06265)
raw | patch | inline | side by side (parent: fa06265)
| author | Jon A. Cruz <jon@joncruz.org> | |
| Sun, 20 Dec 2009 09:40:55 +0000 (01:40 -0800) | ||
| committer | Jon A. Cruz <jon@joncruz.org> | |
| Sun, 20 Dec 2009 09:40:55 +0000 (01:40 -0800) |
31 files changed:
index f883f8c63da48bbb8eb85b1aae0f2fbc23561e45..2e4eba519c77c18b1e35a4b18d4657f017a9434c 100644 (file)
starting = false;
Rect bounds = *(iter->boundsFast());
Coord x = p[X], y = p[Y];
-
+
if(x > bounds.right() || !bounds[Y].contains(y)) continue; //ray doesn't intersect box
-
+
Point final = iter->finalPoint();
Point initial = iter->initialPoint();
Cmp final_to_ray = cmp(final[Y], y);
Cmp initial_to_ray = cmp(initial[Y], y);
-
+
// if y is included, these will have opposite values, giving order.
- Cmp c = cmp(final_to_ray, initial_to_ray);
+ Cmp c = cmp(final_to_ray, initial_to_ray);
if(x < bounds.left()) {
// ray goes through bbox
// winding delta determined by position of endpoints
//Looks like it looped, which means everything's flat
return 0;
}
-
+
cont:(void)0;
}
return wind;
} else if(final_to_ray == EQUAL_TO) goto doh;
}
return res < 0;
-
+
doh:
//Otherwise fallback on area
-
+
Piecewise<D2<SBasis> > pw = p.toPwSb();
double area;
Point centre;
{
const double x0 = gsl_vector_get (x, 0);
const double x1 = gsl_vector_get (x, 1);
-
- Geom::Point dx = ((struct rparams *) params)->A(x0) -
+
+ Geom::Point dx = ((struct rparams *) params)->A(x0) -
((struct rparams *) params)->B(x1);
-
+
gsl_vector_set (f, 0, dx[0]);
gsl_vector_set (f, 1, dx[1]);
-
+
return GSL_SUCCESS;
}
#endif
-static void
+static void
intersect_polish_root (Curve const &A, double &s,
Curve const &B, double &t) {
- int status;
- size_t iter = 0;
std::vector<Point> as, bs;
as = A.pointAndDerivatives(s, 2);
bs = B.pointAndDerivatives(t, 2);
Point F = as[0] - bs[0];
double best = dot(F, F);
-
+
for(int i = 0; i < 4; i++) {
-
+
/**
we want to solve
J*(x1 - x0) = f(x0)
-
+
|dA(s)[0] -dB(t)[0]| (X1 - X0) = A(s) - B(t)
- |dA(s)[1] -dB(t)[1]|
+ |dA(s)[1] -dB(t)[1]|
**/
// We're using the standard transformation matricies, which is numerically rather poor. Much better to solve the equation using elimination.
else if (ns>1) ns=1;
if (nt<0) nt=0;
else if (nt>1) nt=1;
-
+
as = A.pointAndDerivatives(ns, 2);
bs = B.pointAndDerivatives(nt, 2);
F = as[0] - bs[0];
const size_t n = 2;
struct rparams p = {A, B};
gsl_multiroot_function f = {&intersect_polish_f, n, &p};
-
+
double x_init[2] = {s, t};
gsl_vector *x = gsl_vector_alloc (n);
-
+
gsl_vector_set (x, 0, x_init[0]);
gsl_vector_set (x, 1, x_init[1]);
-
+
const gsl_multiroot_fsolver_type *T = gsl_multiroot_fsolver_hybrids;
gsl_multiroot_fsolver *sol = gsl_multiroot_fsolver_alloc (T, 2);
gsl_multiroot_fsolver_set (sol, &f, x);
-
+
+ int status = 0;
+ size_t iter = 0;
do
{
iter++;
status = gsl_multiroot_fsolver_iterate (sol);
-
+
if (status) /* check if solver is stuck */
break;
-
+
status =
gsl_multiroot_test_residual (sol->f, 1e-12);
}
while (status == GSL_CONTINUE && iter < 1000);
-
+
s = gsl_vector_get (sol->x, 0);
t = gsl_vector_get (sol->x, 1);
-
+
gsl_multiroot_fsolver_free (sol);
gsl_vector_free (x);
}
* It passes in the curves, time intervals, and keeps track of depth, while
* returning the results through the Crossings parameter.
*/
-void pair_intersect(Curve const & A, double Al, double Ah,
+void pair_intersect(Curve const & A, double Al, double Ah,
Curve const & B, double Bl, double Bh,
Crossings &ret, unsigned depth = 0) {
// std::cout << depth << "(" << Al << ", " << Ah << ")\n";
OptRect Br = B.boundsLocal(Interval(Bl, Bh));
if (!Br) return;
-
+
if(! Ar->intersects(*Br)) return;
-
+
//Checks the general linearity of the function
- if((depth > 12)) { // || (A.boundsLocal(Interval(Al, Ah), 1).maxExtent() < 0.1
+ if((depth > 12)) { // || (A.boundsLocal(Interval(Al, Ah), 1).maxExtent() < 0.1
//&& B.boundsLocal(Interval(Bl, Bh), 1).maxExtent() < 0.1)) {
double tA, tB, c;
- if(linear_intersect(A.pointAt(Al), A.pointAt(Ah),
- B.pointAt(Bl), B.pointAt(Bh),
+ if(linear_intersect(A.pointAt(Al), A.pointAt(Ah),
+ B.pointAt(Bl), B.pointAt(Bh),
tA, tB, c)) {
tA = tA * (Ah - Al) + Al;
tB = tB * (Bh - Bl) + Bl;
if(depth > 12 || (Ar.maxExtent() < tol && Ar.maxExtent() < tol)) {
double tA, tB, c;
- if(linear_intersect(A.pointAt(Al), A.pointAt(Ah),
- B.pointAt(Bl), B.pointAt(Bh),
+ if(linear_intersect(A.pointAt(Al), A.pointAt(Ah),
+ B.pointAt(Bl), B.pointAt(Bh),
tA, tB, c)) {
tA = tA * (Ah - Al) + Al;
tB = tB * (Bh - Bl) + Bl;
std::vector<double> path_mono_splits(Path const &p) {
std::vector<double> ret;
if(p.empty()) return ret;
-
+
bool pdx=2, pdy=2; //Previous derivative direction
for(unsigned i = 0; i < p.size(); i++) {
std::vector<double> spl = offset_doubles(curve_mono_splits(p[i]), i);
}
/**
- * Applies path_mono_splits to multiple paths, and returns the results such that
+ * Applies path_mono_splits to multiple paths, and returns the results such that
* time-set i corresponds to Path i.
*/
std::vector<std::vector<double> > paths_mono_splits(std::vector<Path> const &ps) {
@@ -541,14 +541,14 @@ CrossingSet MonoCrosser::crossings(std::vector<Path> const &a, std::vector<Path>
if(b.empty()) return CrossingSet(a.size(), Crossings());
CrossingSet results(a.size() + b.size(), Crossings());
if(a.empty()) return results;
-
+
std::vector<std::vector<double> > splits_a = paths_mono_splits(a), splits_b = paths_mono_splits(b);
std::vector<std::vector<Rect> > bounds_a = split_bounds(a, splits_a), bounds_b = split_bounds(b, splits_b);
-
- std::vector<Rect> bounds_a_union, bounds_b_union;
+
+ std::vector<Rect> bounds_a_union, bounds_b_union;
for(unsigned i = 0; i < bounds_a.size(); i++) bounds_a_union.push_back(union_list(bounds_a[i]));
for(unsigned i = 0; i < bounds_b.size(); i++) bounds_b_union.push_back(union_list(bounds_b[i]));
-
+
std::vector<std::vector<unsigned> > cull = sweep_bounds(bounds_a_union, bounds_b_union);
Crossings n;
for(unsigned i = 0; i < cull.size(); i++) {
@@ -556,7 +556,7 @@ CrossingSet MonoCrosser::crossings(std::vector<Path> const &a, std::vector<Path>
unsigned j = cull[i][jx];
unsigned jc = j + a.size();
Crossings res;
-
+
//Sweep of the monotonic portions
std::vector<std::vector<unsigned> > cull2 = sweep_bounds(bounds_a[i], bounds_b[j]);
for(unsigned k = 0; k < cull2.size(); k++) {
@@ -567,9 +567,9 @@ CrossingSet MonoCrosser::crossings(std::vector<Path> const &a, std::vector<Path>
res, .1);
}
}
-
+
for(unsigned k = 0; k < res.size(); k++) { res[k].a = i; res[k].b = jc; }
-
+
merge_crossings(results[i], res, i);
merge_crossings(results[i], res, jc);
}
@@ -583,22 +583,22 @@ CrossingSet MonoCrosser::crossings(std::vector<Path> const &a, std::vector<Path>
CrossingSet crossings_among(std::vector<Path> const &p) {
CrossingSet results(p.size(), Crossings());
if(p.empty()) return results;
-
+
std::vector<std::vector<double> > splits = paths_mono_splits(p);
std::vector<std::vector<Rect> > prs = split_bounds(p, splits);
std::vector<Rect> rs;
for(unsigned i = 0; i < prs.size(); i++) rs.push_back(union_list(prs[i]));
-
+
std::vector<std::vector<unsigned> > cull = sweep_bounds(rs);
-
+
//we actually want to do the self-intersections, so add em in:
for(unsigned i = 0; i < cull.size(); i++) cull[i].push_back(i);
-
+
for(unsigned i = 0; i < cull.size(); i++) {
for(unsigned jx = 0; jx < cull[i].size(); jx++) {
unsigned j = cull[i][jx];
Crossings res;
-
+
//Sweep of the monotonic portions
std::vector<std::vector<unsigned> > cull2 = sweep_bounds(prs[i], prs[j]);
for(unsigned k = 0; k < cull2.size(); k++) {
res, .1);
}
}
-
+
for(unsigned k = 0; k < res.size(); k++) { res[k].a = i; res[k].b = j; }
-
+
merge_crossings(results[i], res, i);
merge_crossings(results[j], res, j);
}
}
-
+
return results;
}
*/
}
/*
-void mono_curve_intersect(Curve const & A, double Al, double Ah,
+void mono_curve_intersect(Curve const & A, double Al, double Ah,
Curve const & B, double Bl, double Bh,
Crossings &ret, unsigned depth=0) {
// std::cout << depth << "(" << Al << ", " << Ah << ")\n";
B0 = B.pointAt(Bl), B1 = B.pointAt(Bh);
//inline code that this implies? (without rect/interval construction)
if(!Rect(A0, A1).intersects(Rect(B0, B1)) || A0 == A1 || B0 == B1) return;
-
+
//Checks the general linearity of the function
- if((depth > 12) || (A.boundsLocal(Interval(Al, Ah), 1).maxExtent() < 0.1
+ if((depth > 12) || (A.boundsLocal(Interval(Al, Ah), 1).maxExtent() < 0.1
&& B.boundsLocal(Interval(Bl, Bh), 1).maxExtent() < 0.1)) {
double tA, tB, c;
if(linear_intersect(A0, A1, B0, B1, tA, tB, c)) {
for(unsigned jx = 0; jx < cull[i].size(); jx++) {
unsigned j = cull[i][jx];
res.clear();
-
+
std::vector<std::vector<unsigned> > cull2 = sweep_bounds(bnds[i], bnds[j]);
for(unsigned k = 0; k < cull2.size(); k++) {
for(unsigned lx = 0; lx < cull2[k].size(); lx++) {
mono_curve_intersect(p[i], spl[i][k-1], spl[i][k], p[j], spl[j][l-1], spl[j][l], res);
}
}
-
+
//if(fabs(int(i)-j) == 1 || fabs(int(i)-j) == p.size()-1) {
Crossings res2;
for(unsigned k = 0; k < res.size(); k++) {
unsigned j = cull[i][jx];
res.clear();
pair_intersect(p[i], 0, 1, p[j], 0, 1, res);
-
+
//if(fabs(int(i)-j) == 1 || fabs(int(i)-j) == p.size()-1) {
Crossings res2;
for(unsigned k = 0; k < res.size(); k++) {
CrossingSet crossings_among(std::vector<Path> const &p) {
CrossingSet results(p.size(), Crossings());
if(p.empty()) return results;
-
+
SimpleCrosser cc;
-
+
std::vector<std::vector<unsigned> > cull = sweep_bounds(bounds(p));
for(unsigned i = 0; i < cull.size(); i++) {
Crossings res = self_crossings(p[i]);
merge_crossings(results[i], res, i);
for(unsigned jx = 0; jx < cull[i].size(); jx++) {
unsigned j = cull[i][jx];
-
+
Crossings res = cc.crossings(p[i], p[j]);
for(unsigned k = 0; k < res.size(); k++) { res[k].a = i; res[k].b = j; }
merge_crossings(results[i], res, i);
diff --git a/src/conn-avoid-ref.cpp b/src/conn-avoid-ref.cpp
index c04ad9e49a4cb2d3a0c122653faf16a986bf721e..b9dc218b4fcc84bfaa48e06df9b81ad0c11cf701 100644 (file)
--- a/src/conn-avoid-ref.cpp
+++ b/src/conn-avoid-ref.cpp
{
_transformed_connection.disconnect();
- // If the document is being destroyed then the router instance
+ // If the document is being destroyed then the router instance
// and the ShapeRefs will have been destroyed with it.
const bool routerInstanceExists = (item->document->router != NULL);
Update the connectors for which
the endpoint has changed.
*/
-
+
gchar ** strarray = g_strsplit(value, "|", 0);
gchar ** iter = strarray;
-
+
while (*iter != NULL) {
ConnectionPoint cp;
Inkscape::SVGIStringStream is(*iter);
{
SPPath* path = SP_PATH(i->data);
SPConnEnd** connEnds = path->connEndPair.getConnEnds();
- for (int ix=0; ix<2; ++ix)
- if (connEnds[ix]->type == ConnPointUserDefined)
- if (updates.find(connEnds[ix]->id) != updates.end())
- if (path->connEndPair.isAutoRoutingConn())
+ for (int ix=0; ix<2; ++ix) {
+ if (connEnds[ix]->type == ConnPointUserDefined) {
+ if (updates.find(connEnds[ix]->id) != updates.end()) {
+ if (path->connEndPair.isAutoRoutingConn()) {
path->connEndPair.tellLibavoidNewEndpoints();
- else
- {
+ } else {
}
- else
- if (deletes.find(connEnds[ix]->id) != deletes.end())
- sp_conn_end_detach(path, ix);
+ }
+ else if (deletes.find(connEnds[ix]->id) != deletes.end()) {
+ sp_conn_end_detach(path, ix);
+ }
+ }
+ }
}
g_slist_free(conns);
// Remove all deleted connection points
void SPAvoidRef::setConnectionPointsAttrUndoable(const gchar* value, const gchar* action)
{
SPDocument* doc = SP_OBJECT_DOCUMENT(item);
-
+
sp_object_setAttribute( SP_OBJECT(item), "inkscape:connection-points", value, 0 );
item->updateRepr();
sp_document_ensure_up_to_date(doc);
}
else
ostr<<'|'<<cp;
-
+
this->setConnectionPointsAttrUndoable( ostr.str().c_str(), _("Added a new connection point") );
}
{
Inkscape::SVGOStringStream ostr;
IdConnectionPointMap::iterator cp_pos = connection_points.find( cp.id );
- if ( cp_pos != connection_points.end() )
- {
+ if ( cp_pos != connection_points.end() ) {
bool first = true;
- for (IdConnectionPointMap::iterator it = connection_points.begin(); it != connection_points.end(); ++it)
- {
- if ( it != cp_pos )
- if ( first )
- {
+ for (IdConnectionPointMap::iterator it = connection_points.begin(); it != connection_points.end(); ++it) {
+ if ( it != cp_pos ) {
+ if ( first ) {
first = false;
ostr<<it->second;
- }
- else
+ } else {
ostr<<'|'<<it->second;
+ }
+ }
}
this->setConnectionPointsAttrUndoable( ostr.str().c_str(), _("Removed a connection point") );
}
setting = new_setting;
Router *router = item->document->router;
-
+
_transformed_connection.disconnect();
if (new_setting) {
Avoid::Polygon poly = avoid_item_poly(item);
const char *id = SP_OBJECT_REPR(item)->attribute("id");
g_assert(id != NULL);
-
+
// Get a unique ID for the item.
GQuark itemID = g_quark_from_string(id);
shapeRef = new Avoid::ShapeRef(router, poly, itemID);
-
+
router->addShape(shapeRef);
}
}
else
{
g_assert(shapeRef);
-
+
router->removeShape(shapeRef);
delete shapeRef;
shapeRef = NULL;
Avoid::IntList shapes;
GQuark shapeId = g_quark_from_string(item->id);
item->document->router->attachedShapes(shapes, shapeId, type);
-
+
Avoid::IntList::iterator finish = shapes.end();
for (Avoid::IntList::iterator i = shapes.begin(); i != finish; ++i) {
const gchar *connId = g_quark_to_string(*i);
Avoid::IntList conns;
GQuark shapeId = g_quark_from_string(item->id);
item->document->router->attachedConns(conns, shapeId, type);
-
+
Avoid::IntList::iterator finish = conns.end();
for (Avoid::IntList::iterator i = conns.begin(); i != finish; ++i) {
const gchar *connId = g_quark_to_string(*i);
g_assert(item);
Geom::Point pos;
const Geom::Matrix& transform = sp_item_i2doc_affine(item);
+ // TODO investigate why this was asking for the active desktop:
SPDesktop *desktop = inkscape_active_desktop();
if ( type == ConnPointDefault )
else
return connection_points.find( id ) != connection_points.end();
}
-
+
return true;
}
if ( convex_hull_approximation_enabled && SP_IS_SHAPE (item) ) {
// The number of points to use for approximation
- const unsigned NUM_POINTS = 64;
+ const unsigned NUM_POINTS = 64;
// printf("[sommer] is a shape\n");
SPCurve* curve = sp_shape_get_curve (SP_SHAPE (item));
const Geom::PathVector& curve_pv = curve->get_pathvector();
std::vector<Geom::Point> hull_points;
for (Geom::PathVector::const_iterator i = curve_pv.begin(); i != curve_pv.end(); i++) {
- const Geom::Path& curve_pv_path = *i;
+ const Geom::Path& curve_pv_path = *i;
// printf("[sommer] tracing sub-path\n");
// FIXME: enlarge path by "desktop->namedview->connector_spacing" (using sp_selected_path_do_offset)?
// sample points along the path for approximation of convex hull
for (unsigned n = 0; n < num_points; n++) {
- double at = curve_pv_path.size() / static_cast<double>(num_points) * n;
+ double at = curve_pv_path.size() / static_cast<double>(num_points) * n;
Geom::Point pt = curve_pv_path.pointAt(at);
hull_points.push_back(pt);
}
// store expanded convex hull in Avoid::Polygn
unsigned n = 0;
Avoid::Polygon poly;
+/*
const Geom::Point& old_pt = *hull.boundary.begin();
+*/
Geom::Line hull_edge(*hull.boundary.begin(), *(hull.boundary.begin()+1));
Geom::Line parallel_hull_edge;
if (int_pt)
{
- Avoid::Point avoid_pt((parallel_hull_edge.origin()+parallel_hull_edge.versor()*int_pt->ta)[Geom::X],
+ Avoid::Point avoid_pt((parallel_hull_edge.origin()+parallel_hull_edge.versor()*int_pt->ta)[Geom::X],
(parallel_hull_edge.origin()+parallel_hull_edge.versor()*int_pt->ta)[Geom::Y]);
// printf("[sommer] %f, %f\n", old_pt[Geom::X], old_pt[Geom::Y]);
-/* printf("[sommer] %f, %f\n", (parallel_hull_edge.origin()+parallel_hull_edge.versor()*int_pt->ta)[Geom::X],
+/* printf("[sommer] %f, %f\n", (parallel_hull_edge.origin()+parallel_hull_edge.versor()*int_pt->ta)[Geom::X],
(parallel_hull_edge.origin()+parallel_hull_edge.versor()*int_pt->ta)[Geom::Y]);*/
poly.ps.push_back(avoid_pt);
}
for (std::vector<Geom::Point>::const_iterator i = hull.boundary.begin() + 1; i != hull.boundary.end(); i++, n++) {
+/*
const Geom::Point& old_pt = *i;
+*/
Geom::Line hull_edge(*i, *(i+1));
Geom::Line parallel_hull_edge;
parallel_hull_edge.origin(hull_edge.origin()+hull_edge.versor().ccw()*spacing);
if (int_pt)
{
- Avoid::Point avoid_pt((parallel_hull_edge.origin()+parallel_hull_edge.versor()*int_pt->ta)[Geom::X],
+ Avoid::Point avoid_pt((parallel_hull_edge.origin()+parallel_hull_edge.versor()*int_pt->ta)[Geom::X],
(parallel_hull_edge.origin()+parallel_hull_edge.versor()*int_pt->ta)[Geom::Y]);
/* printf("[sommer] %f, %f\n", old_pt[Geom::X], old_pt[Geom::Y]);
- printf("[sommer] %f, %f\n", (parallel_hull_edge.origin()+parallel_hull_edge.versor()*int_pt->ta)[Geom::X],
+ printf("[sommer] %f, %f\n", (parallel_hull_edge.origin()+parallel_hull_edge.versor()*int_pt->ta)[Geom::X],
(parallel_hull_edge.origin()+parallel_hull_edge.versor()*int_pt->ta)[Geom::Y]);*/
poly.ps.push_back(avoid_pt);
}
}
-
+
return poly;
}// else printf("[sommer] is no curve\n");
}// else printf("[sommer] is no shape\n");
}
-
+
Geom::OptRect rHull = item->getBounds(sp_item_i2doc_affine(item));
if (!rHull) {
return Avoid::Polygon();
// Add a little buffer around the edge of each object.
Geom::Rect rExpandedHull = *rHull;
- rExpandedHull.expandBy(spacing);
+ rExpandedHull.expandBy(spacing);
Avoid::Polygon poly(4);
for (size_t n = 0; n < 4; ++n) {
}
-GSList *get_avoided_items(GSList *list, SPObject *from, SPDesktop *desktop,
+GSList *get_avoided_items(GSList *list, SPObject *from, SPDesktop *desktop,
bool initialised)
{
for (SPObject *child = sp_object_first_child(SP_OBJECT(from)) ;
child != NULL; child = SP_OBJECT_NEXT(child) ) {
if (SP_IS_ITEM(child) &&
!desktop->isLayer(SP_ITEM(child)) &&
- !SP_ITEM(child)->isLocked() &&
+ !SP_ITEM(child)->isLocked() &&
!desktop->itemIsHidden(SP_ITEM(child)) &&
(!initialised || SP_ITEM(child)->avoidRef->shapeRef)
)
SPDocument *document = sp_desktop_document(desktop);
bool saved = sp_document_get_undo_sensitive(document);
sp_document_set_undo_sensitive(document, false);
-
+
bool initialised = false;
GSList *items = get_avoided_items(NULL, desktop->currentRoot(), desktop,
initialised);
index 228c81d29e0bdc26365ebe694bf4600778f901f3..307d59d1f5f2efad35e2068b78e710424d0b71f3 100644 (file)
* Gobbling away all duplicates after the current can occasionally result
* in the path lagging behind the mouse cursor if it is no longer being
* dragged.
- * o Fix up libavoid's representation after undo actions. It doesn't see
+ * o Fix up libavoid's representation after undo actions. It doesn't see
* any transform signals and hence doesn't know shapes have moved back to
* there earlier positions.
* o Decide whether drawing/editing mode should be an Inkscape preference
* ----------------------------------------------------------------------------
*
* mjwybrow's observations on acracan's Summer of Code connector work:
- *
+ *
* - GUI comments:
- *
+ *
* - Buttons for adding and removing user-specified connection
* points should probably have "+" and "-" symbols on them so they
* are consistent with the similar buttons for the node tool.
- * - Controls on the connector tool be should be reordered logically,
+ * - Controls on the connector tool be should be reordered logically,
* possibly as follows:
- *
- * *Connector*: [Polyline-radio-button] [Orthgonal-radio-button]
+ *
+ * *Connector*: [Polyline-radio-button] [Orthgonal-radio-button]
* [Curvature-control] | *Shape*: [Avoid-button] [Dont-avoid-button]
* [Spacing-control] | *Connection pts*: [Edit-mode] [Add-pt] [Rm-pt]
- *
- * I think that the network layout controls be moved to the
- * Align and Distribute dialog (there is already the layout button
+ *
+ * I think that the network layout controls be moved to the
+ * Align and Distribute dialog (there is already the layout button
* there, but no options are exposed).
- *
+ *
* I think that the style change between polyline and orthogonal
* would be much clearer with two buttons (radio behaviour -- just
* one is true).
- *
- * The other tools show a label change from "New:" to "Change:"
+ *
+ * The other tools show a label change from "New:" to "Change:"
* depending on whether an object is selected. We could consider
* this but there may not be space.
- *
+ *
* The Add-pt and Rm-pt buttons should be greyed out (inactive) if
* we are not in connection point editing mode. And probably also
* if there is no shape selected, i.e. at the times they have no
* effect when clicked.
- *
- * Likewise for the avoid/ignore shapes buttons. These should be
+ *
+ * Likewise for the avoid/ignore shapes buttons. These should be
* inactive when a shape is not selected in the connector context.
- *
+ *
* - When creating/editing connection points:
- *
+ *
* - Strange things can happen if you have connectors selected, or
- * try rerouting connectors by dragging their endpoints when in
+ * try rerouting connectors by dragging their endpoints when in
* connection point editing mode.
- *
+ *
* - Possibly the selected shape's connection points should always
* be shown (i.e., have knots) when in editing mode.
- *
+ *
* - It is a little strange to be able to place connection points
* competely outside shapes. Especially when you later can't draw
* connectors to them since the knots are only visible when you
* are over the shape. I think that you should only be able to
- * place connection points inside or on the boundary of the shape
+ * place connection points inside or on the boundary of the shape
* itself.
- *
- * - The intended ability to place a new point at the current cursor
+ *
+ * - The intended ability to place a new point at the current cursor
* position by pressing RETURN does not seem to work.
- *
+ *
* - The Status bar tooltip should change to reflect editing mode
* and tell the user about RETURN and how to use the tool.
- *
+ *
* - Connection points general:
- *
- * - Connection points that were inside the shape can end up outside
+ *
+ * - Connection points that were inside the shape can end up outside
* after a rotation is applied to the shape in the select tool.
* It doesn't seem like the correct transform is being applied to
* these, or it is being applied at the wrong time. I'd expect
* connection points to rotate with the shape, and stay at the
* same position "on the shape"
- *
+ *
* - I was able to make the connectors attached to a shape fall off
* the shape after scaling it. Not sure the exact cause, but may
* require more investigation/debugging.
- *
+ *
* - The user-defined connection points should be either absolute
* (as the current ones are) or defined as a percentage of the
* shape. These would be based on a toggle setting on the
* toolbar, and they would be placed in exactly the same way by
* the user. The only difference would be that they would be
* store as percentage positions in the SVG connection-points
- * property and that they would update/move automatically if the
+ * property and that they would update/move automatically if the
* object was resized or scaled.
- *
+ *
* - Thinking more, I think you always want to store and think about
* the positions of connection points to be pre-transform, but
* obviously the shape transform is applied to them. That way,
* the shape transform is altered. The Percentage version would
* compute their position from the pre-transform dimensions and
* then have the transform applied to them, for example.
- *
+ *
* - The connection points in the test_connection_points.svg file
* seem to follow the shape when it is moved, but connection
* points I add to new shapes, do not follow the shape, either
* when the shape is just moved or transformed. There is
- * something wrong here. What exactly should the behaviour be
+ * something wrong here. What exactly should the behaviour be
* currently?
- *
+ *
* - I see that connection points are specified at absolute canvas
* positions. I really think that they should be specified in
* shape coordinated relative to the shapes. There may be
cc->clickedhandle = NULL;
new (&cc->connpthandles) ConnectionPointMap();
-
+
for (int i = 0; i < 2; ++i) {
cc->endpt_handle[i] = NULL;
cc->endpt_handler_id[i] = 0;
cc->sel_changed_connection.disconnect();
if (!cc->connpthandles.empty()) {
- for (ConnectionPointMap::iterator it = cc->connpthandles.begin();
+ for (ConnectionPointMap::iterator it = cc->connpthandles.begin();
it != cc->connpthandles.end(); ++it) {
g_object_unref(it->first);
}
cc_selection_changed(cc->selection, (gpointer) cc);
cc->within_tolerance = false;
-
+
sp_event_context_read(ec, "curvature");
sp_event_context_read(ec, "orthogonal");
sp_event_context_read(ec, "mode");
{
cc->selection->set( SP_OBJECT( cc->active_shape ) );
}
- else
+ else
{
SPItem* item = cc->selection->singleItem();
if ( item )
// Hide the connection points if they exist.
if (cc->connpthandles.size()) {
- for (ConnectionPointMap::iterator it = cc->connpthandles.begin();
+ for (ConnectionPointMap::iterator it = cc->connpthandles.begin();
it != cc->connpthandles.end(); ++it) {
sp_knot_hide(it->first);
}
@@ -616,7 +616,7 @@ sp_connector_context_item_handler(SPEventContext *event_context, SPItem *item, G
SPConnectorContext *cc = SP_CONNECTOR_CONTEXT(event_context);
Geom::Point p(event->button.x, event->button.y);
-
+
switch (event->type) {
case GDK_BUTTON_RELEASE:
if (event->button.button == 1 && !event_context->space_panning) {
@@ -660,11 +660,11 @@ sp_connector_context_item_handler(SPEventContext *event_context, SPItem *item, G
if (cc->mode == SP_CONNECTOR_CONTEXT_DRAWING_MODE || (cc->mode == SP_CONNECTOR_CONTEXT_EDITING_MODE && !cc->selected_handle))
{
if (cc_item_is_shape(item)) {
-
+
// I don't really understand what the above does,
// so I commented it.
// This is a shape, so show connection point(s).
- /* if (!(cc->active_shape)
+ /* if (!(cc->active_shape)
// Don't show handle for another handle.
// || (cc->connpthandles.find((SPKnot*) item) != cc->connpthandles.end())
)
@@ -847,7 +847,7 @@ connector_handle_button_press(SPConnectorContext *const cc, GdkEventButton const
cc->xp = bevent.x;
cc->yp = bevent.y;
cc->within_tolerance = true;
-
+
ConnectionPointMap::iterator const& active_knot_it = cc->connpthandles.find( cc->active_handle );
switch (cc->state)
@@ -934,7 +934,7 @@ connector_handle_motion_notify(SPConnectorContext *const cc, GdkEventMotion cons
{
SnapManager &m = dt->namedview->snap_manager;
m.setup(dt);
-
+
switch (cc->state) {
case SP_CONNECTOR_CONTEXT_DRAGGING:
{
@@ -1074,7 +1074,7 @@ connector_handle_button_release(SPConnectorContext *const cc, GdkEventButton con
switch ( cc->state )
{
case SP_CONNECTOR_CONTEXT_DRAGGING:
-
+
if (!cc->within_tolerance)
{
// sp_event_context_snap_window_open(event_context);
@@ -1094,7 +1094,7 @@ connector_handle_button_release(SPConnectorContext *const cc, GdkEventButton con
case SP_CONNECTOR_CONTEXT_NEWCONNPOINT:
// sp_event_context_snap_window_open( event_context );
m.freeSnapReturnByRef(Inkscape::SnapPreferences::SNAPPOINT_NODE, p, Inkscape::SNAPSOURCE_HANDLE);
-
+
sp_knot_set_position(cc->selected_handle, p, 0);
// sp_event_context_snap_window_closed(event_context);
@@ -1118,7 +1118,7 @@ connector_handle_button_release(SPConnectorContext *const cc, GdkEventButton con
}
}
}
-
+
return ret;
}
SnapManager &m = desktop->namedview->snap_manager;
m.setup(desktop);
Geom::Point p = cc->selected_handle->pos;
- SPEventContext* event_context = SP_EVENT_CONTEXT( cc );
-
+// SPEventContext* event_context = SP_EVENT_CONTEXT( cc );
+
if (!cc->within_tolerance)
{
// sp_event_context_snap_window_open(event_context);
@@ -1229,11 +1229,11 @@ connector_handle_key_press(SPConnectorContext *const cc, guint const keyval)
SnapManager &m = desktop->namedview->snap_manager;
m.setup(desktop);
Geom::Point p = cc->selected_handle->pos;
- SPEventContext* event_context = SP_EVENT_CONTEXT( cc );
-
+// SPEventContext* event_context = SP_EVENT_CONTEXT( cc );
+
// sp_event_context_snap_window_open( event_context );
m.freeSnapReturnByRef(Inkscape::SnapPreferences::SNAPPOINT_NODE, p, Inkscape::SNAPSOURCE_HANDLE);
-
+
sp_knot_set_position(cc->selected_handle, p, 0);
// sp_event_context_snap_window_closed(event_context);
cc->selected_handle = NULL;
ret = TRUE;
}
-
+
break;
}
}
// Process pending updates.
cc->newconn->updateRepr();
sp_document_ensure_up_to_date(doc);
-
+
if (connection) {
// Adjust endpoints to shape edge.
sp_conn_reroute_path_immediate(SP_PATH(cc->newconn));
}
// Only set the selection after we are finished with creating the attributes of
- // the connector. Otherwise, the selection change may alter the defaults for
+ // the connector. Otherwise, the selection change may alter the defaults for
// values like curvature in the connector context, preventing subsequent lookup
// of their original values.
cc->selection->set(repr);
@@ -1630,7 +1630,7 @@ static void cc_active_shape_add_knot(SPDesktop* desktop, SPItem* item, Connectio
static void cc_set_active_shape(SPConnectorContext *cc, SPItem *item)
{
g_assert(item != NULL );
-
+
std::map<int, ConnectionPoint>* connpts = &item->avoidRef->connection_points;
if (cc->active_shape != item)
if ( connpts->size() )
for (std::map<int, ConnectionPoint>::iterator it = connpts->begin(); it != connpts->end(); ++it)
cc_active_shape_add_knot(cc->desktop, item, cc->connpthandles, it->second);
-
+
// Also add default connection points
// For now, only centre default connection point will
// be available
index 05d38701fccb995cecdf42b2add28b62abbf5924..fc88102d82bfdf24fac71108de3912b3719f586f 100644 (file)
unsigned int jEnd = X_UPPER ? width+targetX-x : orderX;
for (unsigned int i=iBegin; i<iEnd; i++){
- for (int j=jBegin; j<jEnd; j++){
+ for (unsigned int j=jBegin; j<jEnd; j++){
unsigned int index = 4*( x - targetX + j + width*(y - targetY + i) );
unsigned int kernel_index = orderX-j-1 + orderX*(orderY-i-1);
double k = PREMULTIPLIED ? kernel[kernel_index] : in_data[index+3] * kernel[kernel_index];
diff --git a/src/dom/ucd.cpp b/src/dom/ucd.cpp
index 3747334d2b0861f682993c12dbfe47714520e02d..f9c36ad19b4921133ca551f832e0e2a71c48a75a 100644 (file)
--- a/src/dom/ucd.cpp
+++ b/src/dom/ucd.cpp
int uni_block(int ch)
{
- int ret;
- UcdBlockData *entry;
- for (entry = ucd_blocks, ret=0 ; entry->name ; entry++, ret++)
- if (ch >= entry->low && ch <= entry->high)
+ int ret = 0;
+ for (UcdBlockData *entry = ucd_blocks; entry->name ; entry++, ret++) {
+ if ((ch >= entry->low) && (ch <= entry->high)) {
return ret;
+ }
+ }
return UCD_BLOCK_NO_BLOCK;
}
index 95adbce0e42d665307788ce51ea8ecdafabcfa39..5415fdc80fb050af4193d3c11cab77911811b5b9 100644 (file)
--- a/src/dropper-context.cpp
+++ b/src/dropper-context.cpp
/**
* Returns the current dropper context icc-color.
*/
-SPColor* sp_dropper_context_get_icc_color(SPEventContext *ec)
+SPColor* sp_dropper_context_get_icc_color(SPEventContext */*ec*/)
{
//TODO: implement-me!
+
+ return 0; // At least we will cause a clean crash, instead of random corruption.
}
/**
index 9ac19326f1969ae6c2ed13e932b4367809dd30c1..737bb2885a25cdcd6e261dd5a318a8694d4556af 100644 (file)
namespace Extension {
namespace Internal {
-bool
-CairoPsOutput::check (Inkscape::Extension::Extension * module)
+bool CairoPsOutput::check (Inkscape::Extension::Extension * /*module*/)
{
- if (NULL == Inkscape::Extension::db.get(SP_MODULE_KEY_PRINT_CAIRO_PS))
- return FALSE;
-
- return TRUE;
+ if (NULL == Inkscape::Extension::db.get(SP_MODULE_KEY_PRINT_CAIRO_PS)) {
+ return FALSE;
+ } else {
+ return TRUE;
+ }
}
-bool
-CairoEpsOutput::check (Inkscape::Extension::Extension * module)
+bool CairoEpsOutput::check (Inkscape::Extension::Extension * /*module*/)
{
- if (NULL == Inkscape::Extension::db.get(SP_MODULE_KEY_PRINT_CAIRO_EPS))
- return FALSE;
-
- return TRUE;
+ if (NULL == Inkscape::Extension::db.get(SP_MODULE_KEY_PRINT_CAIRO_EPS)) {
+ return FALSE;
+ } else {
+ return TRUE;
+ }
}
static bool
diff --git a/src/extension/internal/cairo-render-context.h b/src/extension/internal/cairo-render-context.h
index e6f2d698ed433673e0a1555c9296a8448d7a841f..a1f902457302c4fada849f0483398de680d8f253 100644 (file)
CairoRenderer *getRenderer(void) const;
cairo_t *getCairoContext(void) const;
- typedef enum CairoRenderMode {
+ enum CairoRenderMode {
RENDER_MODE_NORMAL,
RENDER_MODE_CLIP
};
- typedef enum CairoClipMode {
+ enum CairoClipMode {
CLIP_MODE_PATH,
CLIP_MODE_MASK
};
diff --git a/src/filters/image.cpp b/src/filters/image.cpp
index ad516a84eaa779a663836fe1b40a69af94344411..eb6dfc22a906aed44076d2a96c264437b613d959 100644 (file)
--- a/src/filters/image.cpp
+++ b/src/filters/image.cpp
static SPFilterPrimitiveClass *feImage_parent_class;
-GType
-sp_feImage_get_type()
+GType sp_feImage_get_type()
{
static GType feImage_type = 0;
return feImage_type;
}
-static void
-sp_feImage_class_init(SPFeImageClass *klass)
+static void sp_feImage_class_init(SPFeImageClass *klass)
{
SPObjectClass *sp_object_class = (SPObjectClass *)klass;
SPFilterPrimitiveClass * sp_primitive_class = (SPFilterPrimitiveClass *)klass;
sp_primitive_class->build_renderer = sp_feImage_build_renderer;
}
-static void
-sp_feImage_init(SPFeImage */*feImage*/)
+static void sp_feImage_init(SPFeImage */*feImage*/)
{
}
* our name must be associated with a repr via "sp_object_type_register". Best done through
* sp-object-repr.cpp's repr_name_entries array.
*/
-static void
-sp_feImage_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+static void sp_feImage_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
{
// Save document reference so we can load images with relative paths.
SPFeImage *feImage = SP_FEIMAGE(object);
@@ -115,8 +111,7 @@ sp_feImage_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *re
/**
* Drops any allocated memory.
*/
-static void
-sp_feImage_release(SPObject *object)
+static void sp_feImage_release(SPObject *object)
{
SPFeImage *feImage = SP_FEIMAGE(object);
feImage->_image_modified_connection.disconnect();
((SPObjectClass *) feImage_parent_class)->release(object);
}
-static void
-sp_feImage_elem_modified(SPObject* /*href*/, guint /*flags*/, SPObject* obj)
+static void sp_feImage_elem_modified(SPObject* /*href*/, guint /*flags*/, SPObject* obj)
{
obj->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
}
-static void
-sp_feImage_href_modified(SPObject* old_elem, SPObject* new_elem, SPObject* obj)
+static void sp_feImage_href_modified(SPObject* /*old_elem*/, SPObject* new_elem, SPObject* obj)
{
SPFeImage *feImage = SP_FEIMAGE(obj);
feImage->_image_modified_connection.disconnect();
/**
* Sets a specific value in the SPFeImage.
*/
-static void
-sp_feImage_set(SPObject *object, unsigned int key, gchar const *value)
+static void sp_feImage_set(SPObject *object, unsigned int key, gchar const *value)
{
SPFeImage *feImage = SP_FEIMAGE(object);
(void)feImage;
/**
* Receives update notifications.
*/
-static void
-sp_feImage_update(SPObject *object, SPCtx *ctx, guint flags)
+static void sp_feImage_update(SPObject *object, SPCtx *ctx, guint flags)
{
if (flags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG |
/**
* Writes its settings to an incoming repr object, if any.
*/
-static Inkscape::XML::Node *
-sp_feImage_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags)
+static Inkscape::XML::Node * sp_feImage_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags)
{
/* TODO: Don't just clone, but create a new repr node and write all
* relevant values into it */
index d9088dfe712f7a13875e9be7306d44f3fd84a434..3dbd941a49fcbf983d837b14d1cc66b4b220cac5 100644 (file)
}
-bool ConnRef::generatePath(Point p0, Point p1)
+bool ConnRef::generatePath(Point /*p0*/, Point /*p1*/)
{
// XXX Code to determine when connectors really need to be rerouted
// does not yet work for orthogonal connectors.
index 747fd1f86f137e5909431b385b3ba1c54458a187..4a7b0af2d39309c521deca07140334e5aaceef36 100644 (file)
* See the file LICENSE.LGPL distributed with the library.
*
* Licensees holding a valid commercial license may use this file in
- * accordance with the commercial license agreement provided with the
+ * accordance with the commercial license agreement provided with the
* library.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Author(s): Michael Wybrow <mjwybrow@users.sourceforge.net>
*/
static const size_t YDIM = 1;
-class ShiftSegment
+class ShiftSegment
{
public:
// For shiftable segments.
- ShiftSegment(ConnRef *conn, const size_t low, const size_t high,
+ ShiftSegment(ConnRef *conn, const size_t low, const size_t high,
bool isSBend, const size_t dim, double minLim, double maxLim)
: connRef(conn),
indexLow(low),
maxSpaceLimit(maxLim)
{
}
+
// For fixed segments.
- ShiftSegment(ConnRef *conn, const size_t low, const size_t high,
+ ShiftSegment(ConnRef *conn, const size_t low, const size_t high,
const size_t dim)
: connRef(conn),
indexLow(low),
minSpaceLimit = lowPoint()[dim];
maxSpaceLimit = lowPoint()[dim];
}
+
Point& lowPoint(void)
{
return connRef->displayRoute().ps[indexLow];
}
+
Point& highPoint(void)
{
return connRef->displayRoute().ps[indexHigh];
}
+
const Point& lowPoint(void) const
{
return connRef->displayRoute().ps[indexLow];
}
- const Point& highPoint(void) const
+
+ const Point& highPoint(void) const
{
return connRef->displayRoute().ps[indexHigh];
}
- const int fixedOrder(bool& isFixed) const
+
+ int fixedOrder(bool& isFixed) const
{
if (fixed)
{
}
return 0;
}
- const int order(void) const
+
+ int order(void) const
{
if (lowC())
{
}
return 0;
}
+
bool operator<(const ShiftSegment& rhs) const
{
const Point& lowPt = lowPoint();
const Point& rhsLowPt = rhs.lowPoint();
-
+
if (lowPt[dimension] != rhsLowPt[dimension])
{
return lowPt[dimension] < rhsLowPt[dimension];
}
return this < &rhs;
}
+
// This counts segments that are colliear and share an endpoint as
// overlapping. This allows them to be nudged apart where possible.
bool overlapsWith(const ShiftSegment& rhs, const size_t dim) const
double minSpaceLimit;
double maxSpaceLimit;
private:
- const bool lowC(void) const
+ bool lowC(void) const
{
// This is true if this is a cBend and its adjoining points
// are at lower positions.
}
return false;
}
- const bool highC(void) const
+
+ bool highC(void) const
{
// This is true if this is a cBend and its adjoining points
// are at higher positions.
struct CmpNodePos { bool operator()(const Node* u, const Node* v) const; };
typedef std::set<Node*,CmpNodePos> NodeSet;
-struct Node
+struct Node
{
ShapeRef *v;
VertInf *c;
pos(p),
firstAbove(NULL),
firstBelow(NULL)
- {
+ {
//COLA_ASSERT(r->width()<1e40);
v->polygon().getBoundingRect(&min[0], &min[1], &max[0], &max[1]);
- }
+ }
Node(VertInf *c, const double p)
: v(NULL),
c(c),
{
min[0] = max[0] = c->point.x;
min[1] = max[1] = c->point.y;
- }
+ }
Node(ShiftSegment *ss, const double p)
: v(NULL),
c(NULL),
{
// These values shouldn't ever be used, so they don't matter.
min[0] = max[0] = min[1] = max[1] = 0;
- }
- ~Node()
+ }
+ ~Node()
{
}
// Find the first Node above in the scanline that is a shape edge,
{
curr = curr->firstAbove;
}
-
+
if (curr)
{
return curr->max[dim];
{
curr = curr->firstBelow;
}
-
+
if (curr)
{
return curr->min[dim];
}
return DBL_MAX;
}
- // Mark all connector segments above in the scanline as being able
+ // Mark all connector segments above in the scanline as being able
// to see to this shape edge.
void markShiftSegmentsAbove(size_t dim)
{
{
if (curr->ss && (curr->pos <= min[dim]))
{
- curr->ss->maxSpaceLimit =
+ curr->ss->maxSpaceLimit =
std::min(min[dim], curr->ss->maxSpaceLimit);
}
curr = curr->firstAbove;
}
}
- // Mark all connector segments below in the scanline as being able
+ // Mark all connector segments below in the scanline as being able
// to see to this shape edge.
void markShiftSegmentsBelow(size_t dim)
{
{
if (curr->ss && (curr->pos >= max[dim]))
{
- curr->ss->minSpaceLimit =
+ curr->ss->minSpaceLimit =
std::max(max[dim], curr->ss->minSpaceLimit);
}
curr = curr->firstBelow;
bool clearVisibility = true;
firstAbovePos = -DBL_MAX;
firstBelowPos = DBL_MAX;
- // We start looking left from the right side of the shape,
- // and vice versa.
+ // We start looking left from the right side of the shape,
+ // and vice versa.
lastAbovePos = max[dim];
lastBelowPos = min[dim];
}
curr = curr->firstAbove;
}
-
+
// Find the first blocking edge below this point. Don't count the
// edges as we are travelling out of shapes we are inside, but then
// mark clearVisibility as false.
return clearVisibility;
}
- double firstPointAbove(size_t dim)
- {
- Node *curr = firstAbove;
- while (curr && (curr->max[dim] >= pos))
- {
- curr = curr->firstAbove;
- }
-
- if (curr)
- {
- return curr->max[dim];
- }
- return -DBL_MAX;
- }
- double firstPointBelow(size_t dim)
- {
- Node *curr = firstBelow;
- while (curr && (curr->min[dim] <= pos))
- {
- curr = curr->firstBelow;
- }
-
- if (curr)
- {
- return curr->min[dim];
- }
- return DBL_MAX;
- }
- // This is a bit inefficient, but we won't need to do it once we have
+ double firstPointAbove(size_t dim)
+ {
+ Node *curr = firstAbove;
+ while (curr && (curr->max[dim] >= pos))
+ {
+ curr = curr->firstAbove;
+ }
+
+ if (curr)
+ {
+ return curr->max[dim];
+ }
+ return -DBL_MAX;
+ }
+ double firstPointBelow(size_t dim)
+ {
+ Node *curr = firstBelow;
+ while (curr && (curr->min[dim] <= pos))
+ {
+ curr = curr->firstBelow;
+ }
+
+ if (curr)
+ {
+ return curr->min[dim];
+ }
+ return DBL_MAX;
+ }
+ // This is a bit inefficient, but we won't need to do it once we have
// connection points.
bool isInsideShape(size_t dimension)
{
};
-bool CmpNodePos::operator() (const Node* u, const Node* v) const
+bool CmpNodePos::operator() (const Node* u, const Node* v) const
{
- if (u->pos != v->pos)
+ if (u->pos != v->pos)
{
return u->pos < v->pos;
}
-
+
// Use the pointers to the base objects to differentiate them.
- void *up = (u->v) ? (void *) u->v :
+ void *up = (u->v) ? (void *) u->v :
((u->c) ? (void *) u->c : (void *) u->ss);
- void *vp = (v->v) ? (void *) v->v :
+ void *vp = (v->v) ? (void *) v->v :
((v->c) ? (void *) v->c : (void *) v->ss);
return up < vp;
}
typedef enum {
Open = 1,
SegOpen = 2,
- ConnPoint = 3,
+ ConnPoint = 3,
SegClose = 4,
Close = 5
} EventType;
struct Event
{
- Event(EventType t, Node *v, double p)
+ Event(EventType t, Node *v, double p)
: type(t),
v(v),
pos(p)
// Returns a bitfield of the direction of visibility (in this dimension)
-// made up of ConnDirDown (for visibility towards lower position values)
+// made up of ConnDirDown (for visibility towards lower position values)
// and ConnDirUp (for visibility towards higher position values).
//
static ConnDirFlags getPosVertInfDirection(VertInf *v, size_t dim)
}
else if (dirs == ConnDirDown)
{
- // For libavoid the Y-axis points downwards, so in terms of
+ // For libavoid the Y-axis points downwards, so in terms of
// smaller or larger position values, Down is Up and vice versa.
return ConnDirUp;
}
else if (dirs == ConnDirUp)
{
- // For libavoid the Y-axis points downwards, so in terms of
+ // For libavoid the Y-axis points downwards, so in terms of
// smaller or larger position values, Down is Up and vice versa.
return ConnDirDown;
}
dir(d)
{
}
-
- bool operator<(const PosVertInf& rhs) const
+
+ bool operator<(const PosVertInf& rhs) const
{
if (pos != rhs.pos)
{
VertInf *vert;
// A bitfield marking the direction of visibility (in this dimension)
- // made up of ConnDirDown (for visibility towards lower position values)
+ // made up of ConnDirDown (for visibility towards lower position values)
// and ConnDirUp (for visibility towards higher position values).
//
ConnDirFlags dir;
struct CmpVertInf
-{
+{
bool operator()(const VertInf* u, const VertInf* v) const
{
// Comparator for VertSet, an ordered set of VertInf pointers.
typedef std::set<VertInf *, CmpVertInf> VertSet;
-// A set of points to break the line segment,
+// A set of points to break the line segment,
// along with vertices for these points.
typedef std::set<PosVertInf> BreakpointSet;
-// Temporary structure used to store the possible horizontal visibility
+// Temporary structure used to store the possible horizontal visibility
// lines arising from the vertical sweep.
-class LineSegment
+class LineSegment
{
public:
- LineSegment(const double& b, const double& f, const double& p,
- bool ss = false, VertInf *bvi = NULL, VertInf *fvi = NULL)
+ LineSegment(const double& b, const double& f, const double& p,
+ bool /*ss*/ = false, VertInf *bvi = NULL, VertInf *fvi = NULL)
: begin(b),
finish(f),
pos(p),
vertInfs.insert(fvi);
}
}
+
LineSegment(const double& bf, const double& p, VertInf *bfvi = NULL)
: begin(bf),
finish(bf),
vertInfs.insert(bfvi);
}
}
-
+
// Order by begin, pos, finish.
- bool operator<(const LineSegment& rhs) const
+ bool operator<(const LineSegment& rhs) const
{
if (begin != rhs.begin)
{
// Lines are exactly equal.
return true;
}
-
+
if (pos == rhs.pos)
{
if (((begin >= rhs.begin) && (begin <= rhs.finish)) ||
finish = std::max(finish, segment.finish);
vertInfs.insert(segment.vertInfs.begin(), segment.vertInfs.end());
}
-
+
VertInf *beginVertInf(void) const
{
if (vertInfs.empty())
}
}
- // Converts a section of the points list to a set of breakPoints.
+ // Converts a section of the points list to a set of breakPoints.
// Returns the first of the intersection points occuring at finishPos.
- VertSet::iterator addSegmentsUpTo(Router *router, double finishPos)
+ VertSet::iterator addSegmentsUpTo(Router */*router*/, double finishPos)
{
VertSet::iterator firstIntersectionPt = vertInfs.end();
- for (VertSet::iterator vert = vertInfs.begin();
+ for (VertSet::iterator vert = vertInfs.begin();
vert != vertInfs.end(); ++vert)
{
if ((*vert)->point.x > finishPos)
// We're done.
break;
}
-
+
breakPoints.insert(PosVertInf((*vert)->point.x, (*vert),
getPosVertInfDirection(*vert, XDIM)));
- if ((firstIntersectionPt == vertInfs.end()) &&
+ if ((firstIntersectionPt == vertInfs.end()) &&
((*vert)->point.x == finishPos))
{
firstIntersectionPt = vert;
return firstIntersectionPt;
}
- // Add visibility edge(s) for this segment. There may be multiple if
+ // Add visibility edge(s) for this segment. There may be multiple if
// one of the endpoints is shared by multiple connector endpoints.
void addEdgeHorizontal(Router *router)
{
commitBegin(router);
commitFinish(router);
-
+
addSegmentsUpTo(router, finish);
}
// Add visibility edge(s) for this segment up until an intersection.
// Then, move the segment beginning to the intersection point, so we
// later only consider the remainder of the segment.
- // There may be multiple segments added to the graph if the beginning
+ // There may be multiple segments added to the graph if the beginning
// endpoint of the segment is shared by multiple connector endpoints.
- VertSet addEdgeHorizontalTillIntersection(Router *router,
+ VertSet addEdgeHorizontalTillIntersection(Router *router,
LineSegment& vertLine)
{
VertSet intersectionSet;
// Does a vertex already exist for this point.
commitPositionX(router, vertLine.pos);
-
- // Generate segments and set end iterator to the first point
+
+ // Generate segments and set end iterator to the first point
// at the intersection position.
VertSet::iterator restBegin = addSegmentsUpTo(router, vertLine.pos);
// Add the intersections points to intersectionSet.
VertSet::iterator restEnd = restBegin;
- while ((restEnd != vertInfs.end()) &&
+ while ((restEnd != vertInfs.end()) &&
(*restEnd)->point.x == vertLine.pos)
{
++restEnd;
return intersectionSet;
}
-
+
// Insert vertical breakpoints.
void insertBreakpointsBegin(Router *router, LineSegment& vertLine)
{
{
if ((*v)->point.x == begin)
{
- vertLine.breakPoints.insert(PosVertInf(pos, *v,
+ vertLine.breakPoints.insert(PosVertInf(pos, *v,
getPosVertInfDirection(*v, YDIM)));
}
}
{
// Here we have a pair of two endpoints that are both
// connector endpoints and both are inside a shape.
-
+
// Give vert visibility back to the first non-connector
// endpoint vertex (i.e., the side of the shape).
BreakpointSet::iterator side = last;
bool canSeeDown = (vert->dir & ConnDirDown);
if (canSeeDown && side->vert->id.isShape)
{
- EdgeInf *edge = new
+ EdgeInf *edge = new
EdgeInf(side->vert, vert->vert, orthogonal);
- edge->setDist(vert->vert->point[dim] -
+ edge->setDist(vert->vert->point[dim] -
side->vert->point[dim]);
}
// Give last visibility back to the first non-connector
// endpoint vertex (i.e., the side of the shape).
side = vert;
- while ((side != breakPoints.end()) &&
+ while ((side != breakPoints.end()) &&
!side->vert->id.isShape)
{
++side;
bool canSeeUp = (last->dir & ConnDirUp);
if (canSeeUp && (side != breakPoints.end()))
{
- EdgeInf *edge = new
+ EdgeInf *edge = new
EdgeInf(last->vert, side->vert, orthogonal);
- edge->setDist(side->vert->point[dim] -
+ edge->setDist(side->vert->point[dim] -
last->vert->point[dim]);
}
}
-
+
// The normal case.
//
- // Note: It's okay to give two connector endpoints visbility
- // here since we only consider the partner endpoint as a
+ // Note: It's okay to give two connector endpoints visbility
+ // here since we only consider the partner endpoint as a
// candidate while searching if it is the other endpoint of
// the connector in question.
//
}
if (generateEdge)
{
- EdgeInf *edge =
+ EdgeInf *edge =
new EdgeInf(last->vert, vert->vert, orthogonal);
- edge->setDist(vert->vert->point[dim] -
+ edge->setDist(vert->vert->point[dim] -
last->vert->point[dim]);
}
double finish;
double pos;
bool shapeSide;
-
+
VertSet vertInfs;
BreakpointSet breakPoints;
private:
- // MSVC wants to generate the assignment operator and the default
- // constructor, but fails. Therefore we declare them private and
+ // MSVC wants to generate the assignment operator and the default
+ // constructor, but fails. Therefore we declare them private and
// don't implement them.
LineSegment & operator=(LineSegment const &);
LineSegment();
}
else
{
- // This is the first overlapping segment, so just
+ // This is the first overlapping segment, so just
// merge the new segment with this one.
curr->mergeVertInfs(segment);
found = curr;
// Given a router instance and a set of possible horizontal segments, and a
// possible vertical visibility segment, compute and add edges to the
// orthogonal visibility graph for all the visibility edges.
-static void intersectSegments(Router *router, SegmentList& segments,
+static void intersectSegments(Router *router, SegmentList& segments,
LineSegment& vertLine)
{
COLA_ASSERT(vertLine.beginVertInf() == NULL);
{
// Add horizontal visibility segment.
horiLine.addEdgeHorizontal(router);
-
+
horiLine.insertBreakpointsFinish(router, vertLine);
-
+
size_t dim = XDIM; // x-dimension
horiLine.generateVisibilityEdgesFromBreakpointSet(router, dim);
if (inVertSegRegion)
{
// Add horizontal visibility segment.
- VertSet intersectionVerts =
+ VertSet intersectionVerts =
horiLine.addEdgeHorizontalTillIntersection(
router, vertLine);
}
-// Processes an event for the vertical sweep used for computing the static
-// orthogonal visibility graph. This adds possible visibility sgments to
+// Processes an event for the vertical sweep used for computing the static
+// orthogonal visibility graph. This adds possible visibility sgments to
// the segments list.
// The first pass is adding the event to the scanline, the second is for
// processing the event and the third for removing it from the scanline.
-static void processEventVert(Router *router, NodeSet& scanline,
+static void processEventVert(Router *router, NodeSet& scanline,
SegmentListWrapper& segments, Event *e, unsigned int pass)
{
Node *v = e->v;
-
+
if ( ((pass == 1) && (e->type == Open)) ||
((pass == 2) && (e->type == ConnPoint)) )
{
NodeSet::iterator it = v->iter;
// Work out neighbours
- if (it != scanline.begin())
+ if (it != scanline.begin())
{
Node *u = *(--it);
v->firstAbove = u;
u->firstBelow = v;
}
it = v->iter;
- if (++it != scanline.end())
+ if (++it != scanline.end())
{
Node *u = *it;
v->firstBelow = u;
u->firstAbove = v;
}
}
-
+
if (pass == 2)
{
if ((e->type == Open) || (e->type == Close))
if (minLimitMax >= maxLimitMin)
{
// Insert possible visibility segments.
- VertInf *vI1 = new VertInf(router, dummyOrthogID,
+ VertInf *vI1 = new VertInf(router, dummyOrthogID,
Point(minShape, lineY));
- VertInf *vI2 = new VertInf(router, dummyOrthogID,
+ VertInf *vI2 = new VertInf(router, dummyOrthogID,
Point(maxShape, lineY));
-
+
// There are no overlapping shapes, so give full visibility.
if (minLimit < minShape)
{
segments.insert(LineSegment(minLimit, minShape, lineY,
true, NULL, vI1));
}
- segments.insert(LineSegment(minShape, maxShape, lineY,
+ segments.insert(LineSegment(minShape, maxShape, lineY,
true, vI1, vI2));
if (maxShape < maxLimit)
{
LineSegment *line1 = NULL, *line2 = NULL;
if (!inShape || (centreVert->visDirections & ConnDirLeft))
{
- line1 = segments.insert(LineSegment(minLimit, cp.x, e->pos,
+ line1 = segments.insert(LineSegment(minLimit, cp.x, e->pos,
true, NULL, centreVert));
}
if (!inShape || (centreVert->visDirections & ConnDirRight))
{
- line2 = segments.insert(LineSegment(cp.x, maxLimit, e->pos,
+ line2 = segments.insert(LineSegment(cp.x, maxLimit, e->pos,
true, centreVert, NULL));
}
if (!line1 && !line2)
// Add a point segment for the centre point.
segments.insert(LineSegment(cp.x, e->pos, centreVert));
}
-
+
if (!inShape)
{
// This is not contained within a shape so add a normal
}
}
}
-
+
if ( ((pass == 3) && (e->type == Close)) ||
((pass == 2) && (e->type == ConnPoint)) )
{
// Clean up neighbour pointers.
Node *l = v->firstAbove, *r = v->firstBelow;
- if (l != NULL)
+ if (l != NULL)
{
l->firstBelow = v->firstBelow;
}
}
-// Processes an event for the vertical sweep used for computing the static
-// orthogonal visibility graph. This adds possible visibility sgments to
+// Processes an event for the vertical sweep used for computing the static
+// orthogonal visibility graph. This adds possible visibility sgments to
// the segments list.
// The first pass is adding the event to the scanline, the second is for
// processing the event and the third for removing it from the scanline.
-static void processEventHori(Router *router, NodeSet& scanline,
+static void processEventHori(Router */*router*/, NodeSet& scanline,
SegmentListWrapper& segments, Event *e, unsigned int pass)
{
Node *v = e->v;
-
+
if ( ((pass == 1) && (e->type == Open)) ||
((pass == 2) && (e->type == ConnPoint)) )
{
NodeSet::iterator it = v->iter;
// Work out neighbours
- if (it != scanline.begin())
+ if (it != scanline.begin())
{
Node *u = *(--it);
v->firstAbove = u;
u->firstBelow = v;
}
it = v->iter;
- if (++it != scanline.end())
+ if (++it != scanline.end())
{
Node *u = *it;
v->firstBelow = u;
u->firstAbove = v;
}
}
-
+
if (pass == 2)
{
if ((e->type == Open) || (e->type == Close))
{
if ((minLimitMax > minLimit) && (minLimitMax >= minShape))
{
- LineSegment vertSeg =
+ LineSegment vertSeg =
LineSegment(minLimit, minLimitMax, lineX);
segments.insert(vertSeg);
}
if ((maxLimitMin < maxLimit) && (maxLimitMin <= maxShape))
{
- LineSegment vertSeg =
+ LineSegment vertSeg =
LineSegment(maxLimitMin, maxLimit, lineX);
segments.insert(vertSeg);
}
double minLimit = v->firstPointAbove(1);
double maxLimit = v->firstPointBelow(1);
bool inShape = v->isInsideShape(1);
-
+
if (!inShape || (centreVert->visDirections & ConnDirUp))
{
segments.insert(LineSegment(minLimit, cp.y, e->pos));
}
}
}
-
+
if ( ((pass == 3) && (e->type == Close)) ||
((pass == 2) && (e->type == ConnPoint)) )
{
// Clean up neighbour pointers.
Node *l = v->firstAbove, *r = v->firstBelow;
- if (l != NULL)
+ if (l != NULL)
{
l->firstBelow = v->firstBelow;
}
++shRefIt;
}
- for (VertInf *curr = router->vertices.connsBegin();
- curr && (curr != router->vertices.shapesBegin());
+ for (VertInf *curr = router->vertices.connsBegin();
+ curr && (curr != router->vertices.shapesBegin());
curr = curr->lstNext)
{
Point& point = curr->point;
{
for (unsigned j = posStartIndex; j < posFinishIndex; ++j)
{
- processEventVert(router, scanline, segments,
+ processEventVert(router, scanline, segments,
events[j], pass);
}
}
posStartIndex = i;
}
- // Do the first sweep event handling -- building the correct
+ // Do the first sweep event handling -- building the correct
// structure of the scanline.
const int pass = 1;
processEventVert(router, scanline, segments, events[i], pass);
++shRefIt;
}
- for (VertInf *curr = router->vertices.connsBegin();
- curr && (curr != router->vertices.shapesBegin());
+ for (VertInf *curr = router->vertices.connsBegin();
+ curr && (curr != router->vertices.shapesBegin());
curr = curr->lstNext)
{
Point& point = curr->point;
{
for (unsigned j = posStartIndex; j < posFinishIndex; ++j)
{
- processEventHori(router, scanline, vertSegments,
+ processEventHori(router, scanline, vertSegments,
events[j], pass);
}
}
-
+
// Process the merged line segments.
vertSegments.list().sort();
for (SegmentList::iterator curr = vertSegments.list().begin();
posStartIndex = i;
}
- // Do the first sweep event handling -- building the correct
+ // Do the first sweep event handling -- building the correct
// structure of the scanline.
const int pass = 1;
processEventHori(router, scanline, vertSegments, events[i], pass);
// Add portions of the horizontal line that are after the final vertical
// position we considered.
- for (SegmentList::iterator it = segments.list().begin();
+ for (SegmentList::iterator it = segments.list().begin();
it != segments.list().end(); )
{
LineSegment& horiLine = *it;
horiLine.addEdgeHorizontal(router);
-
+
size_t dim = XDIM; // x-dimension
horiLine.generateVisibilityEdgesFromBreakpointSet(router, dim);
-// Processes sweep events used to determine each horizontal and vertical
-// line segment in a connector's channel of visibility.
+// Processes sweep events used to determine each horizontal and vertical
+// line segment in a connector's channel of visibility.
// Four calls to this function are made at each position by the scanline:
// 1) Handle all Close event processing.
// 2) Remove Close event objects from the scanline.
// 3) Add Open event objects to the scanline.
// 4) Handle all Open event processing.
//
-static void processShiftEvent(Router *router, NodeSet& scanline,
- ShiftSegmentList& segments, Event *e, size_t dim,
- unsigned int pass)
+static void processShiftEvent(Router */*router*/, NodeSet& scanline,
+ ShiftSegmentList& /*segments*/, Event *e, size_t dim,
+ unsigned int pass)
{
Node *v = e->v;
-
+
if ( ((pass == 3) && (e->type == Open)) ||
((pass == 3) && (e->type == SegOpen)) )
{
NodeSet::iterator it = v->iter;
// Work out neighbours
- if (it != scanline.begin())
+ if (it != scanline.begin())
{
Node *u = *(--it);
v->firstAbove = u;
u->firstBelow = v;
}
it = v->iter;
- if (++it != scanline.end())
+ if (++it != scanline.end())
{
Node *u = *it;
v->firstBelow = u;
u->firstAbove = v;
}
}
-
+
if ( ((pass == 4) && (e->type == Open)) ||
((pass == 4) && (e->type == SegOpen)) ||
((pass == 1) && (e->type == SegClose)) ||
double minLimit = v->firstObstacleAbove(dim);
double maxLimit = v->firstObstacleBelow(dim);
- v->ss->minSpaceLimit =
+ v->ss->minSpaceLimit =
std::max(minLimit, v->ss->minSpaceLimit);
- v->ss->maxSpaceLimit =
+ v->ss->maxSpaceLimit =
std::min(maxLimit, v->ss->maxSpaceLimit);
}
else
v->markShiftSegmentsBelow(dim);
}
}
-
+
if ( ((pass == 2) && (e->type == SegClose)) ||
((pass == 2) && (e->type == Close)) )
{
// Clean up neighbour pointers.
Node *l = v->firstAbove, *r = v->firstBelow;
- if (l != NULL)
+ if (l != NULL)
{
l->firstBelow = v->firstBelow;
}
}
-static void buildOrthogonalChannelInfo(Router *router,
+static void buildOrthogonalChannelInfo(Router *router,
const size_t dim, ShiftSegmentList& segmentList)
{
if (router->routingPenalty(segmentPenalty) == 0)
size_t altDim = (dim + 1) % 2;
// For each connector.
- for (ConnRefList::const_iterator curr = router->connRefs.begin();
- curr != router->connRefs.end(); ++curr)
+ for (ConnRefList::const_iterator curr = router->connRefs.begin();
+ curr != router->connRefs.end(); ++curr)
{
if ((*curr)->routingType() != ConnType_Orthogonal)
{
continue;
}
Polygon& displayRoute = (*curr)->displayRoute();
- // Determine all line segments that we are interested in shifting.
+ // Determine all line segments that we are interested in shifting.
// We don't consider the first or last segment of a path.
for (size_t i = 1; i < displayRoute.size(); ++i)
{
indexLow = i;
indexHigh = i - 1;
}
- COLA_ASSERT(displayRoute.at(indexLow)[altDim] <
+ COLA_ASSERT(displayRoute.at(indexLow)[altDim] <
displayRoute.at(indexHigh)[altDim]);
if ((i == 1) || ((i + 1) == displayRoute.size()))
{
- // The first and last segment of a connector can't be
+ // The first and last segment of a connector can't be
// shifted. We call them fixed segments. Note: this
// will change if we later allow connection channels.
segmentList.push_back(
double prevPos = displayRoute.ps[i - 2][dim];
double nextPos = displayRoute.ps[i + 1][dim];
if (((prevPos < displayRoute.ps[i][dim]) &&
- (nextPos > displayRoute.ps[i][dim]))
+ (nextPos > displayRoute.ps[i][dim]))
||
((prevPos > displayRoute.ps[i][dim]) &&
(nextPos < displayRoute.ps[i][dim])) )
{
isSBend = true;
- // Determine limits if the s-bend is not due to an
- // obstacle. In this case we need to limit the channel
+ // Determine limits if the s-bend is not due to an
+ // obstacle. In this case we need to limit the channel
// to the span of the adjoining segments to this one.
if ((prevPos < displayRoute.ps[i][dim]) &&
(nextPos > displayRoute.ps[i][dim]))
else
{
// isCBend: Both adjoining segments are in the same
- // direction. We indicate this for later by setting
+ // direction. We indicate this for later by setting
// the maxLim or minLim to the segment position.
if (prevPos < displayRoute.ps[i][dim])
{
}
}
- segmentList.push_back(ShiftSegment(*curr, indexLow,
+ segmentList.push_back(ShiftSegment(*curr, indexLow,
indexHigh, isSBend, dim, minLim, maxLim));
}
}
// There are no segments, so we can just return now.
return;
}
-
+
// Do a sweep and shift these segments.
const size_t n = router->shapeRefs.size();
const size_t cpn = segmentList.size();
++shRefIt;
}
- for (ShiftSegmentList::iterator curr = segmentList.begin();
+ for (ShiftSegmentList::iterator curr = segmentList.begin();
curr != segmentList.end(); ++curr)
{
const Point& lowPt = curr->lowPoint();
{
for (unsigned j = posStartIndex; j < posFinishIndex; ++j)
{
- processShiftEvent(router, scanline, segmentList, events[j],
+ processShiftEvent(router, scanline, segmentList, events[j],
dim, pass);
}
}
posStartIndex = i;
}
- // Do the first sweep event handling -- building the correct
+ // Do the first sweep event handling -- building the correct
// structure of the scanline.
const int pass = 1;
processShiftEvent(router, scanline, segmentList, events[i],
static void simplifyOrthogonalRoutes(Router *router)
{
// Simplify routes.
- for (ConnRefList::const_iterator curr = router->connRefs.begin();
- curr != router->connRefs.end(); ++curr)
+ for (ConnRefList::const_iterator curr = router->connRefs.begin();
+ curr != router->connRefs.end(); ++curr)
{
if ((*curr)->routingType() != ConnType_Orthogonal)
{
}
-static void buildOrthogonalNudgingOrderInfo(Router *router,
+static void buildOrthogonalNudgingOrderInfo(Router *router,
PtOrderMap& pointOrders)
{
// Simplify routes.
int crossingsN = 0;
// Do segment splitting.
- for (ConnRefList::const_iterator curr = router->connRefs.begin();
- curr != router->connRefs.end(); ++curr)
+ for (ConnRefList::const_iterator curr = router->connRefs.begin();
+ curr != router->connRefs.end(); ++curr)
{
if ((*curr)->routingType() != ConnType_Orthogonal)
{
continue;
}
ConnRef *conn = *curr;
-
- for (ConnRefList::const_iterator curr2 = router->connRefs.begin();
- curr2 != router->connRefs.end(); ++curr2)
+
+ for (ConnRefList::const_iterator curr2 = router->connRefs.begin();
+ curr2 != router->connRefs.end(); ++curr2)
{
if ((*curr2)->routingType() != ConnType_Orthogonal)
{
continue;
}
ConnRef *conn2 = *curr2;
-
+
if (conn == conn2)
{
continue;
}
-
+
Avoid::Polygon& route = conn->displayRoute();
Avoid::Polygon& route2 = conn2->displayRoute();
splitBranchingSegments(route2, true, route);
}
}
- for (ConnRefList::const_iterator curr = router->connRefs.begin();
- curr != router->connRefs.end(); ++curr)
+ for (ConnRefList::const_iterator curr = router->connRefs.begin();
+ curr != router->connRefs.end(); ++curr)
{
if ((*curr)->routingType() != ConnType_Orthogonal)
{
continue;
}
ConnRef *conn = *curr;
-
- for (ConnRefList::const_iterator curr2 = curr;
- curr2 != router->connRefs.end(); ++curr2)
+
+ for (ConnRefList::const_iterator curr2 = curr;
+ curr2 != router->connRefs.end(); ++curr2)
{
if ((*curr2)->routingType() != ConnType_Orthogonal)
{
{
continue;
}
-
+
Avoid::Polygon& route = conn->displayRoute();
Avoid::Polygon& route2 = conn2->displayRoute();
bool checkForBranchingSegments = false;
for (size_t i = 1; i < route.size(); ++i)
{
const bool finalSegment = ((i + 1) == route.size());
- crossings += countRealCrossings(route2, true, route, i,
- checkForBranchingSegments, finalSegment, NULL,
+ crossings += countRealCrossings(route2, true, route, i,
+ checkForBranchingSegments, finalSegment, NULL,
&pointOrders, conn2, conn).first;
}
if (crossings > 0)
}
}
}
-
+
// Sort the point orders.
PtOrderMap::iterator finish = pointOrders.end();
for (PtOrderMap::iterator it = pointOrders.begin(); it != finish; ++it)
}
-class CmpLineOrder
+class CmpLineOrder
{
public:
CmpLineOrder(PtOrderMap& ord, const size_t dim)
{
*comparable = true;
}
- Point lhsLow = lhs.lowPoint();
- Point rhsLow = rhs.lowPoint();
+ Point lhsLow = lhs.lowPoint();
+ Point rhsLow = rhs.lowPoint();
#ifndef NDEBUG
- const Point& lhsHigh = lhs.highPoint();
- const Point& rhsHigh = rhs.highPoint();
+ const Point& lhsHigh = lhs.highPoint();
+ const Point& rhsHigh = rhs.highPoint();
#endif
size_t altDim = (dimension + 1) % 2;
{
return lhsLow[dimension] < rhsLow[dimension];
}
-
- // If one of these is fixed, then determine order based on
- // fixed segment, that is, order so the fixed segment doesn't
+
+ // If one of these is fixed, then determine order based on
+ // fixed segment, that is, order so the fixed segment doesn't
// block movement.
bool oneIsFixed = false;
const int lhsFixedOrder = lhs.fixedOrder(oneIsFixed);
return lhsFixedOrder < rhsFixedOrder;
}
- // C-bends that did not have a clear order with s-bends might
- // not have a good ordering here, so compare their order in
+ // C-bends that did not have a clear order with s-bends might
+ // not have a good ordering here, so compare their order in
// terms of C-bend direction and S-bends and use that if it
// differs for the two segments.
const int lhsOrder = lhs.order();
{
// A value for rhsPos or lhsPos mean the points are not directly
// comparable, meaning they are at the same position but cannot
- // overlap (they are just collinear. The relative order for
+ // overlap (they are just collinear. The relative order for
// these segments is not important since we do not constrain
// them against each other.
//COLA_ASSERT(lhs.overlapsWith(rhs, dimension) == false);
};
-// We can use the normaal sort algorithm for lists since it is not possible
-// to comapre all elements, but there will be an ordering defined between
-// most of the elements. Hence we order these, using insertion sort, and
-// the case of them not being able to be compared is handled by not setting
+// We can use the normaal sort algorithm for lists since it is not possible
+// to comapre all elements, but there will be an ordering defined between
+// most of the elements. Hence we order these, using insertion sort, and
+// the case of them not being able to be compared is handled by not setting
// up any constraints between such segments when doing the nudging.
//
-static ShiftSegmentList linesort(ShiftSegmentList origList,
+static ShiftSegmentList linesort(ShiftSegmentList origList,
CmpLineOrder& comparison)
{
ShiftSegmentList resultList;
typedef std::list<ShiftSegment *> ShiftSegmentPtrList;
-static void nudgeOrthogonalRoutes(Router *router, size_t dimension,
+static void nudgeOrthogonalRoutes(Router *router, size_t dimension,
PtOrderMap& pointOrders, ShiftSegmentList& segmentList)
{
// Do the actual nudging.
}
CmpLineOrder lineSortComp(pointOrders, dimension);
currentRegion = linesort(currentRegion, lineSortComp);
-
+
if (currentRegion.size() == 1)
{
// Save creating the solver instance if there is just one
currSegment != currentRegion.end(); ++currSegment)
{
Point& lowPt = currSegment->lowPoint();
-
+
// Create a solver variable for the position of this segment.
int varID = freeID;
double idealPos = lowPt[dimension];
{
COLA_ASSERT(currSegment->minSpaceLimit > -CHANNEL_MAX);
COLA_ASSERT(currSegment->maxSpaceLimit < CHANNEL_MAX);
-
+
// For s-bends, take the middle as ideal.
idealPos = currSegment->minSpaceLimit +
((currSegment->maxSpaceLimit -
}
else
{
- // Set a higher weight for c-bends to stop them sometimes
+ // Set a higher weight for c-bends to stop them sometimes
// getting pushed out into channels by more-free connectors
// to the "inner" side of them.
weight = strongWeight;
if (currSegment->overlapsWith(*prevSeg, dimension) &&
(!(currSegment->fixed) || !(prevSeg->fixed)))
{
- // If there is a previous segment to the left that
- // could overlap this in the shift direction, then
+ // If there is a previous segment to the left that
+ // could overlap this in the shift direction, then
// constrain the two segments to be separated.
- // Though don't add the constraint if both the
+ // Though don't add the constraint if both the
// segments are fixed in place.
cs.push_back(new Constraint(prevVar, vs[index],
router->orthogonalNudgeDistance()));
if (!currSegment->fixed)
{
- // If this segment sees a channel boundary to its left,
+ // If this segment sees a channel boundary to its left,
// then constrain its placement as such.
if (currSegment->minSpaceLimit > -CHANNEL_MAX)
{
- vs.push_back(new Variable(fixedID,
+ vs.push_back(new Variable(fixedID,
currSegment->minSpaceLimit, fixedWeight));
- cs.push_back(new Constraint(vs[vs.size() - 1], vs[index],
+ cs.push_back(new Constraint(vs[vs.size() - 1], vs[index],
0.0));
}
-
- // If this segment sees a channel boundary to its right,
+
+ // If this segment sees a channel boundary to its right,
// then constrain its placement as such.
if (currSegment->maxSpaceLimit < CHANNEL_MAX)
{
- vs.push_back(new Variable(fixedID,
+ vs.push_back(new Variable(fixedID,
currSegment->maxSpaceLimit, fixedWeight));
cs.push_back(new Constraint(vs[index], vs[vs.size() - 1],
0.0));
IncSolver f(vs,cs);
f.solve();
bool satisfied = true;
- for (size_t i = 0; i < vs.size(); ++i)
+ for (size_t i = 0; i < vs.size(); ++i)
{
if (vs[i]->id == fixedID)
{
{
// Build nudging info.
// XXX: We need to build the point orders separately in each
- // dimension since things move. There is probably a more
+ // dimension since things move. There is probably a more
// efficient way to do this.
PtOrderMap pointOrders;
buildOrthogonalNudgingOrderInfo(router, pointOrders);
index 754c464b4a8098a7b8deb7045906ed0284c4f1f7..ab13a981be39f9727fe63f71854398270acb74ea 100644 (file)
--- a/src/libavoid/router.cpp
+++ b/src/libavoid/router.cpp
* See the file LICENSE.LGPL distributed with the library.
*
* Licensees holding a valid commercial license may use this file in
- * accordance with the commercial license agreement provided with the
+ * accordance with the commercial license agreement provided with the
* library.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Author(s): Michael Wybrow <mjwybrow@users.sourceforge.net>
*/
}
ShapeRef *shape(void) const
{
- COLA_ASSERT((type == ShapeMove) || (type == ShapeAdd) ||
+ COLA_ASSERT((type == ShapeMove) || (type == ShapeAdd) ||
(type == ShapeRemove));
return (static_cast<ShapeRef *> (objPtr));
}
const ConnEnd& connEnd)
{
ActionInfo modInfo(ConnChange, conn);
-
- ActionInfoList::iterator found =
+
+ ActionInfoList::iterator found =
find(actionList.begin(), actionList.end(), modInfo);
if (found == actionList.end())
{
void Router::modifyConnector(ConnRef *conn)
{
ActionInfo modInfo(ConnChange, conn);
-
- ActionInfoList::iterator found =
+
+ ActionInfoList::iterator found =
find(actionList.begin(), actionList.end(), modInfo);
if (found == actionList.end())
{
{
ActionInfo modInfo(ConnChange, conn);
- ActionInfoList::iterator found =
+ ActionInfoList::iterator found =
find(actionList.begin(), actionList.end(), modInfo);
if (found != actionList.end())
{
// There shouldn't be remove events or move events for the same shape
// already in the action list.
// XXX: Possibly we could handle this by ordering them intelligently.
- COLA_ASSERT(find(actionList.begin(), actionList.end(),
+ COLA_ASSERT(find(actionList.begin(), actionList.end(),
ActionInfo(ShapeRemove, shape)) == actionList.end());
- COLA_ASSERT(find(actionList.begin(), actionList.end(),
+ COLA_ASSERT(find(actionList.begin(), actionList.end(),
ActionInfo(ShapeMove, shape)) == actionList.end());
ActionInfo addInfo(ShapeAdd, shape);
-
- ActionInfoList::iterator found =
+
+ ActionInfoList::iterator found =
find(actionList.begin(), actionList.end(), addInfo);
if (found == actionList.end())
{
void Router::removeShape(ShapeRef *shape)
{
- // There shouldn't be add events events for the same shape already
+ // There shouldn't be add events events for the same shape already
// in the action list.
// XXX: Possibly we could handle this by ordering them intelligently.
- COLA_ASSERT(find(actionList.begin(), actionList.end(),
+ COLA_ASSERT(find(actionList.begin(), actionList.end(),
ActionInfo(ShapeAdd, shape)) == actionList.end());
// Delete any ShapeMove entries for this shape in the action list.
- ActionInfoList::iterator found = find(actionList.begin(),
+ ActionInfoList::iterator found = find(actionList.begin(),
actionList.end(), ActionInfo(ShapeMove, shape));
if (found != actionList.end())
{
@@ -306,16 +306,16 @@ void Router::moveShape(ShapeRef *shape, const double xDiff, const double yDiff)
}
-void Router::moveShape(ShapeRef *shape, const Polygon& newPoly,
+void Router::moveShape(ShapeRef *shape, const Polygon& newPoly,
const bool first_move)
{
// There shouldn't be remove events or add events for the same shape
// already in the action list.
// XXX: Possibly we could handle this by ordering them intelligently.
- COLA_ASSERT(find(actionList.begin(), actionList.end(),
+ COLA_ASSERT(find(actionList.begin(), actionList.end(),
ActionInfo(ShapeRemove, shape)) == actionList.end());
-
- if (find(actionList.begin(), actionList.end(),
+
+ if (find(actionList.begin(), actionList.end(),
ActionInfo(ShapeAdd, shape)) != actionList.end())
{
// The Add is enough, no need for the Move action too.
ActionInfo moveInfo(ShapeMove, shape, newPoly, first_move);
// Sanely cope with the case where the user requests moving the same
// shape multiple times before rerouting connectors.
- ActionInfoList::iterator found =
+ ActionInfoList::iterator found =
find(actionList.begin(), actionList.end(), moveInfo);
if (found != actionList.end())
// leave the firstMove setting alone.
found->newPoly = newPoly;
}
- else
+ else
{
actionList.push_back(moveInfo);
}
void Router::regenerateStaticBuiltGraph(void)
{
- // Here we do talks involved in updating the static-built visibility
+ // Here we do talks involved in updating the static-built visibility
// graph (if necessary) before we do any routing.
if (_staticGraphInvalidated)
{
timers.Register(tmOrthogGraph, timerStart);
// Regenerate a new visibility graph.
generateStaticOrthogonalVisGraph(this);
-
+
timers.Stop();
}
_staticGraphInvalidated = false;
bool Router::shapeInQueuedActionList(ShapeRef *shape) const
{
- bool foundAdd = find(actionList.begin(), actionList.end(),
+ bool foundAdd = find(actionList.begin(), actionList.end(),
ActionInfo(ShapeAdd, shape)) != actionList.end();
- bool foundRem = find(actionList.begin(), actionList.end(),
+ bool foundRem = find(actionList.begin(), actionList.end(),
ActionInfo(ShapeRemove, shape)) != actionList.end();
- bool foundMove = find(actionList.begin(), actionList.end(),
+ bool foundMove = find(actionList.begin(), actionList.end(),
ActionInfo(ShapeMove, shape)) != actionList.end();
return (foundAdd || foundRem || foundMove);
// o Remove entries related to this shape's vertices
shape->removeFromGraph();
-
+
if (SelectiveReroute && (!isMove || notPartialTime || first_move))
{
markConnectors(shape);
}
adjustContainsWithDel(pid);
-
+
// Ignore this shape for visibility.
// XXX: We don't really need to do this if we're not using Partial
// Feedback. Without this the blocked edges still route
// around the shape until it leaves the connector.
shape->makeInactive();
}
-
+
if (seenShapeMovesOrDeletes && _polyLineRouting)
{
if (InvisibilityGrph)
for (curr = actionList.begin(); curr != finish; ++curr)
{
ActionInfo& actInf = *curr;
- if (!((actInf.type == ShapeRemove) ||
+ if (!((actInf.type == ShapeRemove) ||
(actInf.type == ShapeMove)))
{
// Not a move or remove action, so don't do anything.
// Restore this shape for visibility.
shape->makeActive();
-
+
if (isMove)
{
shape->setNewPoly(newPoly);
}
// Clear the actionList.
actionList.clear();
-
+
_staticGraphInvalidated = true;
rerouteAndCallbackConnectors();
void Router::addCluster(ClusterRef *cluster)
{
cluster->makeActive();
-
+
unsigned int pid = cluster->id();
ReferencingPolygon& poly = cluster->polygon();
void Router::delCluster(ClusterRef *cluster)
{
cluster->makeInactive();
-
+
unsigned int pid = cluster->id();
-
+
adjustClustersWithDel(pid);
}
{
// If the suggestedId is zero, then we assign the object the next
// smallest unassigned ID, otherwise we trust the ID given is unique.
- unsigned int assignedId = (suggestedId == 0) ?
+ unsigned int assignedId = (suggestedId == 0) ?
(_largestAssignedId + 1) : suggestedId;
-
+
// Have the router record if this ID is larger than the _largestAssignedId.
_largestAssignedId = std::max(_largestAssignedId, assignedId);
// Returns whether the given ID is unique among all objects known by the
- // router. Outputs a warning if the ID is found ore than once.
+ // router. Outputs a warning if the ID is found ore than once.
// It is expected this is only going to be called from assertions while
// debugging, so efficiency is not an issue and we just iterate over all
// objects.
-bool Router::idIsUnique(const unsigned int id) const
+bool Router::idIsUnique(const unsigned int id) const
{
unsigned int count = 0;
// Examine shapes.
- for (ShapeRefList::const_iterator i = shapeRefs.begin();
- i != shapeRefs.end(); ++i)
+ for (ShapeRefList::const_iterator i = shapeRefs.begin();
+ i != shapeRefs.end(); ++i)
{
if ((*i)->id() == id)
{
}
// Examine connectors.
- for (ConnRefList::const_iterator i = connRefs.begin();
- i != connRefs.end(); ++i)
+ for (ConnRefList::const_iterator i = connRefs.begin();
+ i != connRefs.end(); ++i)
{
if ((*i)->id() == id)
{
}
// Examine clusters.
- for (ClusterRefList::const_iterator i = clusterRefs.begin();
- i != clusterRefs.end(); ++i)
+ for (ClusterRefList::const_iterator i = clusterRefs.begin();
+ i != clusterRefs.end(); ++i)
{
if ((*i)->id() == id)
{
const unsigned int type)
{
ConnRefList::const_iterator fin = connRefs.end();
- for (ConnRefList::const_iterator i = connRefs.begin(); i != fin; ++i)
+ for (ConnRefList::const_iterator i = connRefs.begin(); i != fin; ++i)
{
- if ((type & runningTo) && ((*i)->_dstId == shapeId))
+ if ((type & runningTo) && ((*i)->_dstId == shapeId))
{
conns.push_back((*i)->_id);
}
- else if ((type & runningFrom) && ((*i)->_srcId == shapeId))
+ else if ((type & runningFrom) && ((*i)->_srcId == shapeId))
{
conns.push_back((*i)->_id);
}
const unsigned int type)
{
ConnRefList::const_iterator fin = connRefs.end();
- for (ConnRefList::const_iterator i = connRefs.begin(); i != fin; ++i)
+ for (ConnRefList::const_iterator i = connRefs.begin(); i != fin; ++i)
{
- if ((type & runningTo) && ((*i)->_dstId == shapeId))
+ if ((type & runningTo) && ((*i)->_dstId == shapeId))
{
if ((*i)->_srcId != 0)
{
shapes.push_back((*i)->_srcId);
}
}
- else if ((type & runningFrom) && ((*i)->_srcId == shapeId))
+ else if ((type & runningFrom) && ((*i)->_srcId == shapeId))
{
if ((*i)->_dstId != 0)
{
}
- // It's intended this function is called after visibility changes
- // resulting from shape movement have happened. It will alert
+ // It's intended this function is called after visibility changes
+ // resulting from shape movement have happened. It will alert
// rerouted connectors (via a callback) that they need to be redrawn.
void Router::rerouteAndCallbackConnectors(void)
{
std::set<ConnRef *> reroutedConns;
ConnRefList::const_iterator fin = connRefs.end();
-
- // Updating the orthogonal visibility graph if necessary.
+
+ // Updating the orthogonal visibility graph if necessary.
regenerateStaticBuiltGraph();
timers.Register(tmOrthogRoute, timerStart);
- for (ConnRefList::const_iterator i = connRefs.begin(); i != fin; ++i)
+ for (ConnRefList::const_iterator i = connRefs.begin(); i != fin; ++i)
{
(*i)->_needs_repaint = false;
bool rerouted = (*i)->generatePath();
improveOrthogonalRoutes(this);
// Alert connectors that they need redrawing.
- for (ConnRefList::const_iterator i = connRefs.begin(); i != fin; ++i)
+ for (ConnRefList::const_iterator i = connRefs.begin(); i != fin; ++i)
{
(*i)->_needs_repaint = true;
(*i)->performCallback();
// No penalties, return.
return;
}
-
+
// Find crossings and reroute connectors.
_inCrossingPenaltyReroutingStage = true;
ConnRefSet crossingConns;
ConnRefList::iterator fin = connRefs.end();
- for (ConnRefList::iterator i = connRefs.begin(); i != fin; ++i)
+ for (ConnRefList::iterator i = connRefs.begin(); i != fin; ++i)
{
Avoid::Polygon& iRoute = (*i)->routeRef();
ConnRefList::iterator j = i;
- for (++j; j != fin; ++j)
+ for (++j; j != fin; ++j)
{
- if ((crossingConns.find(*i) != crossingConns.end()) &&
+ if ((crossingConns.find(*i) != crossingConns.end()) &&
(crossingConns.find(*j) != crossingConns.end()))
{
// We already know both these have crossings.
{
const bool finalSegment = ((jInd + 1) == jRoute.size());
CrossingsInfoPair crossingInfo = countRealCrossings(
- iRoute, true, jRoute, jInd, false,
+ iRoute, true, jRoute, jInd, false,
finalSegment, NULL, NULL, *i, *j);
-
- if ((shared_path_penalty > 0) &&
- (crossingInfo.second & CROSSING_SHARES_PATH) &&
- (crossingInfo.second & CROSSING_SHARES_FIXED_SEGMENT) &&
- !(crossingInfo.second & CROSSING_SHARES_PATH_AT_END))
+
+ if ((shared_path_penalty > 0) &&
+ (crossingInfo.second & CROSSING_SHARES_PATH) &&
+ (crossingInfo.second & CROSSING_SHARES_FIXED_SEGMENT) &&
+ !(crossingInfo.second & CROSSING_SHARES_PATH_AT_END))
{
// We are penalising fixedSharedPaths and there is a
// fixedSharedPath.
}
}
- for (ConnRefSet::iterator i = crossingConns.begin();
+ for (ConnRefSet::iterator i = crossingConns.begin();
i != crossingConns.end(); ++i)
{
ConnRef *conn = *i;
// XXX: Could we free these routes here for extra savings?
// conn->freeRoutes();
}
- for (ConnRefSet::iterator i = crossingConns.begin();
+ for (ConnRefSet::iterator i = crossingConns.begin();
i != crossingConns.end(); ++i)
{
ConnRef *conn = *i;
bool blocked = false;
bool countBorder = false;
- bool ep_in_poly1 = !(eID1.isShape) ?
+ bool ep_in_poly1 = !(eID1.isShape) ?
inPoly(poly, e1, countBorder) : false;
- bool ep_in_poly2 = !(eID2.isShape) ?
+ bool ep_in_poly2 = !(eID2.isShape) ?
inPoly(poly, e2, countBorder) : false;
if (ep_in_poly1 || ep_in_poly2)
{
size_t pt_n = (pt_i == (poly.size() - 1)) ? 0 : pt_i + 1;
const Point& pi = poly.ps[pt_i];
const Point& pn = poly.ps[pt_n];
- if (segmentShapeIntersect(e1, e2, pi, pn,
+ if (segmentShapeIntersect(e1, e2, pi, pn,
seenIntersectionAtEndpoint))
{
blocked = true;
// Computer enclosing Clusters
ClusterRefList::const_iterator clFinish = clusterRefs.end();
- for (ClusterRefList::const_iterator i = clusterRefs.begin();
+ for (ClusterRefList::const_iterator i = clusterRefs.begin();
i != clFinish; ++i)
{
if (inPolyGen((*i)->polygon(), pt->point))
}
-void Router::adjustClustersWithAdd(const PolygonInterface& poly,
+void Router::adjustClustersWithAdd(const PolygonInterface& poly,
const int p_cluster)
{
for (VertInf *k = vertices.connsBegin(); k != vertices.shapesBegin();
bool Router::existsOrthogonalPathOverlap(void)
{
ConnRefList::iterator fin = connRefs.end();
- for (ConnRefList::iterator i = connRefs.begin(); i != fin; ++i)
+ for (ConnRefList::iterator i = connRefs.begin(); i != fin; ++i)
{
Avoid::Polygon iRoute = (*i)->displayRoute();
ConnRefList::iterator j = i;
- for (++j; j != fin; ++j)
+ for (++j; j != fin; ++j)
{
// Determine if this pair overlap
Avoid::Polygon jRoute = (*j)->displayRoute();
{
const bool finalSegment = ((jInd + 1) == jRoute.size());
CrossingsInfoPair crossingInfo = countRealCrossings(
- iRoute, true, jRoute, jInd, true,
+ iRoute, true, jRoute, jInd, true,
finalSegment, NULL, NULL, *i, *j);
-
- if ((crossingInfo.second & CROSSING_SHARES_PATH) &&
- (crossingInfo.second & CROSSING_SHARES_FIXED_SEGMENT) &&
- !(crossingInfo.second & CROSSING_SHARES_PATH_AT_END))
+
+ if ((crossingInfo.second & CROSSING_SHARES_PATH) &&
+ (crossingInfo.second & CROSSING_SHARES_FIXED_SEGMENT) &&
+ !(crossingInfo.second & CROSSING_SHARES_PATH_AT_END))
{
// We looking for fixedSharedPaths and there is a
// fixedSharedPath.
bool Router::existsOrthogonalTouchingCorners(void)
{
ConnRefList::iterator fin = connRefs.end();
- for (ConnRefList::iterator i = connRefs.begin(); i != fin; ++i)
+ for (ConnRefList::iterator i = connRefs.begin(); i != fin; ++i)
{
Avoid::Polygon iRoute = (*i)->displayRoute();
ConnRefList::iterator j = i;
- for (++j; j != fin; ++j)
+ for (++j; j != fin; ++j)
{
// Determine if this pair overlap
Avoid::Polygon jRoute = (*j)->displayRoute();
{
const bool finalSegment = ((jInd + 1) == jRoute.size());
CrossingsInfoPair crossingInfo = countRealCrossings(
- iRoute, true, jRoute, jInd, true,
+ iRoute, true, jRoute, jInd, true,
finalSegment, NULL, NULL, *i, *j);
-
- if (crossingInfo.second & CROSSING_TOUCHES)
+
+ if (crossingInfo.second & CROSSING_TOUCHES)
{
return true;
}
reduceRange(p.x);
reduceRange(p.y);
-
+
if (p.x > -LIMIT)
{
minX = std::min(minX, p.x);
fprintf(fp, " PolyLineRouting | OrthogonalRouting);\n");
for (size_t p = 0; p < lastPenaltyMarker; ++p)
{
- fprintf(fp, " router->setRoutingPenalty((PenaltyType)%lu, %g);\n",
- p, _routingPenalties[p]);
+ fprintf(fp, " router->setRoutingPenalty((PenaltyType)%lu, %g);\n",
+ static_cast<long unsigned int>(p), _routingPenalties[p]);
}
fprintf(fp, " router->setOrthogonalNudgeDistance(%g);\n\n",
orthogonalNudgeDistance());
while (shRefIt != shapeRefs.end())
{
ShapeRef *shRef = *shRefIt;
- fprintf(fp, " Polygon poly%u(%lu);\n",
- shRef->id(), shRef->polygon().size());
+ fprintf(fp, " Polygon poly%u(%lu);\n",
+ shRef->id(), static_cast<long unsigned int>(shRef->polygon().size()));
for (size_t i = 0; i < shRef->polygon().size(); ++i)
{
- fprintf(fp, " poly%u.ps[%lu] = Point(%g, %g);\n",
- shRef->id(), i, shRef->polygon().at(i).x,
+ fprintf(fp, " poly%u.ps[%lu] = Point(%g, %g);\n",
+ shRef->id(), static_cast<long unsigned int>(i), shRef->polygon().at(i).x,
shRef->polygon().at(i).y);
}
fprintf(fp, " ShapeRef *shapeRef%u = new ShapeRef(router, poly%u, "
fprintf(fp, " connRef%u->setDestEndpoint(dstPt%u);\n",
connRef->id(), connRef->id());
}
- fprintf(fp, " connRef%u->setRoutingType((ConnType)%u);\n\n",
+ fprintf(fp, " connRef%u->setRoutingType((ConnType)%u);\n\n",
connRef->id(), connRef->routingType());
++revConnRefIt;
}
fprintf(fp, "};\n");
fprintf(fp, "-->\n");
-
+
fprintf(fp, "<g inkscape:groupmode=\"layer\" "
"inkscape:label=\"ShapesPoly\">\n");
shRefIt = shapeRefs.begin();
while (shRefIt != shapeRefs.end())
{
ShapeRef *shRef = *shRefIt;
-
+
fprintf(fp, "<path id=\"poly-%u\" style=\"stroke-width: 1px; "
- "stroke: black; fill: blue; fill-opacity: 0.3;\" d=\"",
+ "stroke: black; fill: blue; fill-opacity: 0.3;\" d=\"",
shRef->id());
for (size_t i = 0; i < shRef->polygon().size(); ++i)
{
- fprintf(fp, "%c %g,%g ", ((i == 0) ? 'M' : 'L'),
+ fprintf(fp, "%c %g,%g ", ((i == 0) ? 'M' : 'L'),
shRef->polygon().at(i).x, shRef->polygon().at(i).y);
}
fprintf(fp, "Z\" />\n");
ShapeRef *shRef = *shRefIt;
double minX, minY, maxX, maxY;
shRef->polygon().getBoundingRect(&minX, &minY, &maxX, &maxY);
-
+
fprintf(fp, "<rect id=\"rect-%u\" x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\" "
"style=\"stroke-width: 1px; stroke: black; fill: blue; fill-opacity: 0.3;\" />\n",
shRef->id(), minX, minY, maxX - minX, maxY - minY);
std::pair<Point, Point> ptpair = t->points();
Point p1 = ptpair.first;
Point p2 = ptpair.second;
-
+
reduceRange(p1.x);
reduceRange(p1.y);
reduceRange(p2.x);
reduceRange(p2.y);
-
+
fprintf(fp, "<path d=\"M %g,%g L %g,%g\" "
- "style=\"fill: none; stroke: %s; stroke-width: 1px;\" />\n",
+ "style=\"fill: none; stroke: %s; stroke-width: 1px;\" />\n",
p1.x, p1.y, p2.x, p2.y,
- (!(ids.first.isShape) || !(ids.second.isShape)) ? "green" :
+ (!(ids.first.isShape) || !(ids.second.isShape)) ? "green" :
"red");
}
fprintf(fp, "</g>\n");
std::pair<Point, Point> ptpair = t->points();
Point p1 = ptpair.first;
Point p2 = ptpair.second;
-
+
reduceRange(p1.x);
reduceRange(p1.y);
reduceRange(p2.x);
reduceRange(p2.y);
-
+
fprintf(fp, "<path d=\"M %g,%g L %g,%g\" "
- "style=\"fill: none; stroke: %s; stroke-width: 1px;\" />\n",
+ "style=\"fill: none; stroke: %s; stroke-width: 1px;\" />\n",
p1.x, p1.y, p2.x, p2.y,
- (!(ids.first.isShape) || !(ids.second.isShape)) ? "green" :
+ (!(ids.first.isShape) || !(ids.second.isShape)) ? "green" :
"red");
}
fprintf(fp, "</g>\n");
std::pair<Point, Point> ptpair = t->points();
Point p1 = ptpair.first;
Point p2 = ptpair.second;
-
+
reduceRange(p1.x);
reduceRange(p1.y);
reduceRange(p2.x);
reduceRange(p2.y);
-
+
std::pair<VertID, VertID> ids = t->ids();
fprintf(fp, "<path d=\"M %g,%g L %g,%g\" "
- "style=\"fill: none; stroke: %s; stroke-width: 1px;\" />\n",
+ "style=\"fill: none; stroke: %s; stroke-width: 1px;\" />\n",
p1.x, p1.y, p2.x, p2.y,
- (!(ids.first.isShape) || !(ids.second.isShape)) ? "green" :
+ (!(ids.first.isShape) || !(ids.second.isShape)) ? "green" :
"red");
}
fprintf(fp, "</g>\n");
while (connRefIt != connRefs.end())
{
ConnRef *connRef = *connRefIt;
-
+
PolyLine route = connRef->route();
if (!route.empty())
{
fprintf(fp, "style=\"fill: none; stroke: black; "
"stroke-width: 1px;\" />\n");
}
-
+
++connRefIt;
}
fprintf(fp, "</g>\n");
while (connRefIt != connRefs.end())
{
ConnRef *connRef = *connRefIt;
-
+
PolyLine route = connRef->displayRoute().curvedPolyline(8);
if (!route.empty())
{
{
if (route.ts[i] == 'C')
{
- fprintf(fp, "%c %g,%g %g,%g %g,%g", route.ts[i],
+ fprintf(fp, "%c %g,%g %g,%g %g,%g", route.ts[i],
route.ps[i].x, route.ps[i].y,
route.ps[i+1].x, route.ps[i+1].y,
route.ps[i+2].x, route.ps[i+2].y);
}
else
{
- fprintf(fp, "%c %g,%g ", route.ts[i],
+ fprintf(fp, "%c %g,%g ", route.ts[i],
route.ps[i].x, route.ps[i].y);
}
}
fprintf(fp, "style=\"fill: none; stroke: black; "
"stroke-width: 1px;\" />\n");
}
-
+
++connRefIt;
}
fprintf(fp, "</g>\n");
while (connRefIt != connRefs.end())
{
ConnRef *connRef = *connRefIt;
-
+
PolyLine route = connRef->displayRoute();
if (!route.empty())
{
fprintf(fp, "style=\"fill: none; stroke: black; "
"stroke-width: 1px;\" />\n");
}
-
+
++connRefIt;
}
fprintf(fp, "</g>\n");
diff --git a/src/libavoid/vpsc.cpp b/src/libavoid/vpsc.cpp
index c9a072375e5cc658db8b9a679360409e90a0bea6..19d360375d2f1c466659654faf35030b198d3604 100644 (file)
--- a/src/libavoid/vpsc.cpp
+++ b/src/libavoid/vpsc.cpp
* See the file LICENSE.LGPL distributed with the library.
*
* Licensees holding a valid commercial license may use this file in
- * accordance with the commercial license agreement provided with the
+ * accordance with the commercial license agreement provided with the
* library.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Author(s): Tim Dwyer <Tim.Dwyer@csse.monash.edu.au>
*
static const double ZERO_UPPERBOUND=-1e-10;
static const double LAGRANGIAN_TOLERANCE=-1e-4;
-IncSolver::IncSolver(vector<Variable*> const &vs, vector<Constraint *> const &cs)
- : m(cs.size()),
- cs(cs),
- n(vs.size()),
- vs(vs)
+IncSolver::IncSolver(vector<Variable*> const &vs, vector<Constraint *> const &cs)
+ : m(cs.size()),
+ cs(cs),
+ n(vs.size()),
+ vs(vs)
{
for(unsigned i=0;i<n;++i) {
vs[i]->in.clear();
#endif
}
copyResult();
- return bs->size()!=n;
+ return bs->size()!=n;
}
/*
* incremental version of satisfy that allows refinement after blocks are
*
* Note: there is a special case to handle when the most violated constraint
* is between two variables in the same block. Then, we must split the block
- * over an active constraint between the two variables. We choose the
- * constraint with the most negative lagrangian multiplier.
+ * over an active constraint between the two variables. We choose the
+ * constraint with the most negative lagrangian multiplier.
*/
bool IncSolver::satisfy() {
#ifdef LIBVPSC_LOGGING
//long splitCtr = 0;
Constraint* v = NULL;
//CBuffer buffer(inactive);
- while((v=mostViolated(inactive))
- &&(v->equality || v->slack() < ZERO_UPPERBOUND && !v->active))
+ while((v = mostViolated(inactive))
+ && (v->equality || ((v->slack() < ZERO_UPPERBOUND) && !v->active)))
{
COLA_ASSERT(!v->active);
Block *lb = v->left->block, *rb = v->right->block;
Constraint *c=*i;
double slack = c->slack();
if(c->equality || slack < minSlack) {
- minSlack=slack;
+ minSlack=slack;
v=c;
deletePoint=i;
if(c->equality) break;
// move the last element over the deletePoint and resize
// downwards. There is always at least 1 element in the
// vector because of search.
- if(deletePoint != end && (minSlack < ZERO_UPPERBOUND && !v->active || v->equality)) {
+ // TODO check this logic and add parens:
+ if((deletePoint != end) && ((minSlack < ZERO_UPPERBOUND) && !v->active || v->equality)) {
*deletePoint = l[l.size()-1];
l.resize(l.size()-1);
}
}
/*
- * returns a list of variables with total ordering determined by the constraint
+ * returns a list of variables with total ordering determined by the constraint
* DAG
*/
list<Variable*> *Blocks::totalOrder() {
if(!c->right->visited) {
dfsVisit(c->right, order);
}
- }
+ }
#ifdef LIBVPSC_LOGGING
ofstream f(LOGFILE,ios::app);
f<<" order="<<*v<<endl;
* Processes incoming constraints, most violated to least, merging with the
* neighbouring (left) block until no more violated constraints are found
*/
-void Blocks::mergeLeft(Block *r) {
+void Blocks::mergeLeft(Block *r) {
#ifdef LIBVPSC_LOGGING
ofstream f(LOGFILE,ios::app);
f<<"mergeLeft called on "<<*r<<endl;
f<<"mergeLeft on constraint: "<<*c<<endl;
#endif
r->deleteMinInConstraint();
- Block *l = c->left->block;
+ Block *l = c->left->block;
if (l->in==NULL) l->setUpInConstraints();
double dist = c->right->offset - c->left->offset - c->gap;
if (r->vars->size() < l->vars->size()) {
r->timeStamp=blockTimeCtr;
removeBlock(l);
c=r->findMinInConstraint();
- }
+ }
#ifdef LIBVPSC_LOGGING
f<<"merged "<<*r<<endl;
#endif
-}
+}
/*
* Symmetrical to mergeLeft
*/
-void Blocks::mergeRight(Block *l) {
+void Blocks::mergeRight(Block *l) {
#ifdef LIBVPSC_LOGGING
ofstream f(LOGFILE,ios::app);
f<<"mergeRight called on "<<*l<<endl;
-#endif
+#endif
l->setUpOutConstraints();
Constraint *c = l->findMinOutConstraint();
- while (c != NULL && c->slack()<0) {
+ while (c != NULL && c->slack()<0) {
#ifdef LIBVPSC_LOGGING
f<<"mergeRight on constraint: "<<*c<<endl;
#endif
l->mergeOut(r);
removeBlock(r);
c=l->findMinOutConstraint();
- }
+ }
#ifdef LIBVPSC_LOGGING
f<<"merged "<<*l<<endl;
#endif
/*
#ifdef LIBVPSC_LOGGING
ofstream f(LOGFILE,ios::app);
- f << "adding v[" << v->id << "], blockscale=" << scale << ", despos="
+ f << "adding v[" << v->id << "], blockscale=" << scale << ", despos="
<< v->desiredPosition << ", ai=" << ai << ", bi=" << bi
<< ", AB=" << AB << ", AD=" << AD << ", A2=" << A2;
#endif
for (Cit j=cs->begin();j!=cs->end();++j) {
Constraint *c=*j;
c->timeStamp=blockTimeCtr;
- if (c->left->block != this && in || c->right->block != this && !in) {
+ if (((c->left->block != this) && in) || ((c->right->block != this) && !in)) {
h->push(c);
}
}
}
-}
+}
Block* Block::merge(Block* b, Constraint* c) {
#ifdef LIBVPSC_LOGGING
ofstream f(LOGFILE,ios::app);
f<<" merged heap: "<<*in<<endl;
#endif
}
-void Block::mergeOut(Block *b) {
+void Block::mergeOut(Block *b) {
findMinOutConstraint();
b->findMinOutConstraint();
while (!b->out->empty())
}
// The top level v and r are variables between which we want to find the
-// constraint with the smallest lm.
+// constraint with the smallest lm.
// Similarly, m is initially NULL and is only assigned a value if the next
// variable to be visited is r or if a possible min constraint is returned from
// a nested call (rather than NULL).
// Then, the search for the m with minimum lm occurs as we return from
-// the recursion (checking only constraints traversed left-to-right
+// the recursion (checking only constraints traversed left-to-right
// in order to avoid creating any new violations).
// We also do not consider equality constraints as potential split points
bool Block::split_path(
- Variable* r,
- Variable* const v,
- Variable* const u,
+ Variable* r,
+ Variable* const v,
+ Variable* const u,
Constraint* &m,
bool desperation=false
- )
+ )
{
for(Cit it(v->in.begin());it!=v->in.end();++it) {
Constraint *c=*it;
}
/*
Block::Pair Block::compute_dfdv_between(
- Variable* r, Variable* const v, Variable* const u,
+ Variable* r, Variable* const v, Variable* const u,
const Direction dir = NONE, bool changedDirection = false) {
double dfdv=v->weight*(v->position() - v->desiredPosition);
Constraint *m=NULL;
for(Cit it(v->in.begin());it!=v->in.end();++it) {
Constraint *c=*it;
if(canFollowLeft(c,u)) {
- if(dir==RIGHT) {
- changedDirection = true;
+ if(dir==RIGHT) {
+ changedDirection = true;
}
if(c->left==r) {
r=NULL;
- if(!c->equality) m=c;
+ if(!c->equality) m=c;
}
Pair p=compute_dfdv_between(r,c->left,v,
LEFT,changedDirection);
dfdv -= c->lm = -p.first;
- if(r && p.second)
+ if(r && p.second)
m = p.second;
}
}
for(Cit it(v->out.begin());it!=v->out.end();++it) {
Constraint *c=*it;
if(canFollowRight(c,u)) {
- if(dir==LEFT) {
- changedDirection = true;
+ if(dir==LEFT) {
+ changedDirection = true;
}
if(c->right==r) {
- r=NULL;
- if(!c->equality) m=c;
+ r=NULL;
+ if(!c->equality) m=c;
}
Pair p=compute_dfdv_between(r,c->right,v,
RIGHT,changedDirection);
dfdv += c->lm = p.first;
- if(r && p.second)
- m = changedDirection && !c->equality && c->lm < p.second->lm
- ? c
+ if(r && p.second)
+ m = changedDirection && !c->equality && c->lm < p.second->lm
+ ? c
: p.second;
}
}
return min_lm;
}
-// populates block b by traversing the active constraint tree adding variables as they're
+// populates block b by traversing the active constraint tree adding variables as they're
// visited. Starts from variable v and does not backtrack over variable u.
void Block::populateSplitBlock(Block *b, Variable* v, Variable const* u) {
b->addVariable(v);
populateSplitBlock(b, (*c)->left, v);
}
for (Cit c=v->out.begin();c!=v->out.end();++c) {
- if (canFollowRight(*c,u))
+ if (canFollowRight(*c,u))
populateSplitBlock(b, (*c)->right, v);
}
}
@@ -1225,7 +1226,7 @@ Constraint::Constraint(Variable *left, Variable *right, double gap, bool equalit
//right->in.push_back(this);
}
Constraint::~Constraint() {
- // see constructor: the following is just way too slow.
+ // see constructor: the following is just way too slow.
// Better to create a
// new DAG on demand than maintain the lists dynamically.
//Constraints::iterator i;
//}
//right->in.erase(i);
}
-double Constraint::slack() const {
+double Constraint::slack() const {
return unsatisfiable ? DBL_MAX
- : right->scale * right->position()
- - gap - left->scale * left->position();
+ : right->scale * right->position()
+ - gap - left->scale * left->position();
}
std::ostream& operator <<(std::ostream &os, const Constraint &c)
{
bool CompareConstraints::operator() (
Constraint *const &l, Constraint *const &r
) const {
- double const sl =
+ double const sl =
l->left->block->timeStamp > l->timeStamp
||l->left->block==l->right->block
?-DBL_MAX:l->slack();
- double const sr =
+ double const sr =
r->left->block->timeStamp > r->timeStamp
||r->left->block==r->right->block
?-DBL_MAX:r->slack();
index ad1279f30dd72de9411aeff42734789e48f81a6c..6e03faf2ff7a48a1c0a329c03a84533319fdd1e7 100644 (file)
/*#ifdef WITH_MMX
#ifdef __cplusplus
extern "C" {
-#endif /* __cplusplus */
-/* fixme: */
-/*int nr_have_mmx (void);
+#endif // __cplusplus
+/ * fixme: * /
+/ *int nr_have_mmx (void);
#define NR_PIXOPS_MMX (1 && nr_have_mmx ())
#ifdef __cplusplus
}
index 93ab60fc56a939015b0816a813b999de45998627..af933eae6939689ec087aad1a006900353e34d76 100644 (file)
return pwd2_out;
}
+ default:
case 1: {
Piecewise<D2<SBasis> > pwd2_out;
bool closed_path = are_near(pwd2_in.firstValue(), pwd2_in.lastValue());
diff --git a/src/live_effects/lpe-recursiveskeleton.cpp b/src/live_effects/lpe-recursiveskeleton.cpp
index 3cbac5829babe66aee719e8f419c668c4903c9b4..50a3bfb6cf41b1e4d3d737a30cbfdc4c1a0da8d0 100644 (file)
#define INKSCAPE_LPE_RECURSIVESKELETON_CPP
/** \file
- * @brief
+ * @brief
*
* Inspired by Hofstadter's 'Goedel Escher Bach', chapter V.
*/
std::vector<Piecewise<D2<SBasis> > > pre_output;
double prop_scale = 1.0;
- double fuse_tolerance = 0;
D2<Piecewise<SBasis> > patternd2 = make_cuts_independent(pwd2_in);
Piecewise<SBasis> x0 = false /*vertical_pattern.get_value()*/ ? Piecewise<SBasis>(patternd2[1]) : Piecewise<SBasis>(patternd2[0]);
double scaling = 1;
scaling = (uskeleton.domain().extent() - toffset)/pattBndsX->extent();
-
+
+ // TODO investigate why pattWidth is not being used:
double pattWidth = pattBndsX->extent() * scaling;
-
+
if (scaling != 1.0) {
x*=scaling;
}
index bcfd0f3736d845bc544f928169d9429e06b65fe7..228857ebf86f99cfe63ef229b2075c97882fcd87 100644 (file)
LevelsCrossings(std::vector<std::vector<double> > const ×,
Piecewise<D2<SBasis> > const &f,
Piecewise<SBasis> const &dx){
-
+
for (unsigned i=0; i<times.size(); i++){
LevelCrossings lcs;
for (unsigned j=0; j<times[i].size(); j++){
}
}
//set indexes to point to the next point in the "snake walk"
- //follow_level's meaning:
+ //follow_level's meaning:
// 0=yes upward
// 1=no, last move was upward,
// 2=yes downward
direction += 1;
return;
}
- double t = (*this)[level][idx].t;
+ //double t = (*this)[level][idx].t;
double sign = ((*this)[level][idx].sign ? 1 : -1);
//---double next_t = t;
//level += 1;
}
-Geom::Piecewise<Geom::D2<Geom::SBasis> >
+Geom::Piecewise<Geom::D2<Geom::SBasis> >
LPERoughHatches::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in){
//std::cout<<"doEffect_pwd2:\n";
Piecewise<D2<SBasis> > result;
-
+
Piecewise<D2<SBasis> > transformed_pwd2_in = pwd2_in;
Point start = pwd2_in.segs.front().at0();
Point end = pwd2_in.segs.back().at1();
@@ -324,11 +324,11 @@ LPERoughHatches::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const &
Matrix mat(-hatches_dir[Y], hatches_dir[X], hatches_dir[X], hatches_dir[Y],0,0);
transformed_pwd2_in = transformed_pwd2_in * mat;
transformed_org *= mat;
-
+
std::vector<std::vector<Point> > snakePoints;
snakePoints = linearSnake(transformed_pwd2_in, transformed_org);
if ( snakePoints.size() > 0 ){
- Piecewise<D2<SBasis> >smthSnake = smoothSnake(snakePoints);
+ Piecewise<D2<SBasis> >smthSnake = smoothSnake(snakePoints);
smthSnake = smthSnake*mat.inverse();
if (do_bend.get_value()){
smthSnake = smthSnake*bend_mat;
while (x < domain.max()){
result.push_back(x);
double rdm = 1;
- if (dist_rdm.get_value() != 0)
+ if (dist_rdm.get_value() != 0)
rdm = 1.+ double((2*dist_rdm - dist_rdm.get_value()))/100.;
x+= step*rdm;
step*=scale;//(1.+double(growth));
//-------------------------------------------------------
// Walk through the intersections to create linear hatches
//-------------------------------------------------------
-std::vector<std::vector<Point> >
+std::vector<std::vector<Point> >
LPERoughHatches::linearSnake(Piecewise<D2<SBasis> > const &f, Point const &org){
//std::cout<<"linearSnake:\n";
@@ -401,14 +401,14 @@ LPERoughHatches::linearSnake(Piecewise<D2<SBasis> > const &f, Point const &org){
unsigned i,j;
lscs.findFirstUnused(i,j);
-
+
std::vector<Point> result_component;
int n = int((range->min()-org[X])/hatch_dist);
-
- while ( i < lscs.size() ){
+
+ while ( i < lscs.size() ){
int dir = 0;
//switch orientation of first segment according to starting point.
- if (i % 2 == n%2 && j < lscs[i].size()-1 && !lscs[i][j].used){
+ if ((i % 2 == n % 2) && ((j + 1) < lscs[i].size()) && !lscs[i][j].used){
j += 1;
dir = 2;
}
@@ -428,7 +428,7 @@ LPERoughHatches::linearSnake(Piecewise<D2<SBasis> > const &f, Point const &org){
//-------------------------------------------------------
// Smooth the linear hatches according to params...
//-------------------------------------------------------
-Piecewise<D2<SBasis> >
+Piecewise<D2<SBasis> >
LPERoughHatches::smoothSnake(std::vector<std::vector<Point> > const &linearSnake){
Piecewise<D2<SBasis> > result;
@@ -444,7 +444,7 @@ LPERoughHatches::smoothSnake(std::vector<std::vector<Point> > const &linearSnake
Geom::Path res_comp_top(last_pt);
Geom::Path res_comp_bot(last_pt);
unsigned i=1;
- //bool is_top = true;//Inversion here; due to downward y?
+ //bool is_top = true;//Inversion here; due to downward y?
bool is_top = ( linearSnake[comp][0][Y] < linearSnake[comp][1][Y] );
while( i+1<linearSnake[comp].size() ){
@@ -454,18 +454,18 @@ LPERoughHatches::smoothSnake(std::vector<std::vector<Point> > const &linearSnake
double scale_in = (is_top ? scale_tf : scale_bf );
double scale_out = (is_top ? scale_tb : scale_bb );
if (is_top){
- if (top_edge_variation.get_value() != 0)
+ if (top_edge_variation.get_value() != 0)
new_pt[Y] += double(top_edge_variation)-top_edge_variation.get_value()/2.;
- if (top_tgt_variation.get_value() != 0)
+ if (top_tgt_variation.get_value() != 0)
new_pt[X] += double(top_tgt_variation)-top_tgt_variation.get_value()/2.;
if (top_smth_variation.get_value() != 0) {
scale_in*=(100.-double(top_smth_variation))/100.;
scale_out*=(100.-double(top_smth_variation))/100.;
}
}else{
- if (bot_edge_variation.get_value() != 0)
+ if (bot_edge_variation.get_value() != 0)
new_pt[Y] += double(bot_edge_variation)-bot_edge_variation.get_value()/2.;
- if (bot_tgt_variation.get_value() != 0)
+ if (bot_tgt_variation.get_value() != 0)
new_pt[X] += double(bot_tgt_variation)-bot_tgt_variation.get_value()/2.;
if (bot_smth_variation.get_value() != 0) {
scale_in*=(100.-double(bot_smth_variation))/100.;
@@ -474,7 +474,7 @@ LPERoughHatches::smoothSnake(std::vector<std::vector<Point> > const &linearSnake
}
Point new_hdle_in = new_pt + (pt0-pt1) * (scale_in /2.);
Point new_hdle_out = new_pt - (pt0-pt1) * (scale_out/2.);
-
+
if ( fat_output.get_value() ){
//double scaled_width = double((is_top ? stroke_width_top : stroke_width_bot))/(pt1[X]-pt0[X]);
double scaled_width = 1./(pt1[X]-pt0[X]);
@@ -494,7 +494,7 @@ LPERoughHatches::smoothSnake(std::vector<std::vector<Point> > const &linearSnake
//TODO: find a good way to handle limit cases (small smthness, large stroke).
//if (inside_hdle_in[X] > inside[X]) inside_hdle_in = inside;
//if (inside_hdle_out[X] < inside[X]) inside_hdle_out = inside;
-
+
if (is_top){
res_comp_top.appendNew<CubicBezier>(last_top_hdle,new_hdle_in,new_pt);
res_comp_bot.appendNew<CubicBezier>(last_bot_hdle,inside_hdle_in,inside);
@@ -509,7 +509,7 @@ LPERoughHatches::smoothSnake(std::vector<std::vector<Point> > const &linearSnake
}else{
res_comp.appendNew<CubicBezier>(last_hdle,new_hdle_in,new_pt);
}
-
+
last_hdle = new_hdle_out;
i+=2;
is_top = !is_top;
@@ -525,7 +525,7 @@ LPERoughHatches::smoothSnake(std::vector<std::vector<Point> > const &linearSnake
if ( fat_output.get_value() ){
res_comp = res_comp_bot;
res_comp.append(res_comp_top.reverse(),Geom::Path::STITCH_DISCONTINUOUS);
- }
+ }
result.concat(res_comp.toPwSb());
}
}
index 80970fd8a5cd43f8a250d7600a75da372293d215..35c9ea69535f278bd0dbad1cc90225f40fe80d79 100644 (file)
LPERuler::LPERuler(LivePathEffectObject *lpeobject) :
Effect(lpeobject),
- unit(_("Unit"), _("Unit"), "unit", &wr, this),
mark_distance(_("Mark distance"), _("Distance between successive ruler marks"), "mark_distance", &wr, this, 20.0),
+ unit(_("Unit"), _("Unit"), "unit", &wr, this),
mark_length(_("Major length"), _("Length of major ruler marks"), "mark_length", &wr, this, 14.0),
minor_mark_length(_("Minor length"), _("Length of minor ruler marks"), "minor_mark_length", &wr, this, 7.0),
major_mark_steps(_("Major steps"), _("Draw a major mark every ... steps"), "major_mark_steps", &wr, this, 5),
index a8ea157440505cf24f268e82bd5324801dc86064..57d583ba6a362ef82f3ffa2f2d3270aee6a36af4 100644 (file)
param_wr(wr),
param_label(label),
oncanvas_editable(false),
+ widget_is_visible(true),
param_tooltip(tip),
- param_effect(effect),
- widget_is_visible(true)
+ param_effect(effect)
{
}
diff --git a/src/print.cpp b/src/print.cpp
index 044dffe345102d60d107d37b61756d11cf7827de..ed9b8d19c4a5c011a8d9aa555e30dc9ff9afa9d9 100644 (file)
--- a/src/print.cpp
+++ b/src/print.cpp
SPItem *base = SP_ITEM(sp_document_root(doc));
NRArena *arena = NRArena::create();
unsigned int dkey = sp_item_display_key_new(1);
+ // TODO investigate why we are grabbing root and then ignoring it.
NRArenaItem *root = sp_item_invoke_show(base, arena, dkey, SP_ITEM_SHOW_DISPLAY);
// Run print dialog
diff --git a/src/sp-conn-end.cpp b/src/sp-conn-end.cpp
index 52914ee9e0bab7b7f770a40820526ef07c9c53b4..2287a182d16a0bbebc02125a7ef339a5037b4578 100644 (file)
--- a/src/sp-conn-end.cpp
+++ b/src/sp-conn-end.cpp
// if this is a group...
if (SP_IS_GROUP(item)) {
SPGroup* group = SP_GROUP(item);
-
+
// consider all first-order children
double child_pos = std::numeric_limits<double>::max();
for (GSList const* i = sp_item_group_item_list(group); i != NULL; i = i->next) {
// The transforms given should be to a common ancestor of both the path and item.
//
static bool try_get_intersect_point_with_item(SPPath* conn, SPItem* item,
- const Geom::Matrix& item_transform, const Geom::Matrix& conn_transform,
+ const Geom::Matrix& item_transform, const Geom::Matrix& conn_transform,
const bool at_start, double& intersect_pos) {
-
+
// Copy the curve and apply transformations up to common ancestor.
SPCurve* conn_curve = conn->curve->copy();
conn_curve->transform(conn_transform);
static void
-sp_conn_get_route_and_redraw(SPPath *const path,
+sp_conn_get_route_and_redraw(SPPath *const path,
const bool updatePathRepr = true)
{
// Get the new route around obstacles.
if (!rerouted) {
return;
}
-
+
SPItem *h2attItem[2];
path->connEndPair.getAttachedItems(h2attItem);
SPObject const *const ancestor = get_nearest_common_ancestor(path_item, h2attItem);
Geom::Matrix const path2anc(i2anc_affine(path_item, ancestor));
- // Set sensible values incase there the connector ends are not
+ // Set sensible values incase there the connector ends are not
// attached to any shapes.
Geom::PathVector conn_pv = path->curve->get_pathvector();
double endPos[2] = { 0, conn_pv[0].size() };
}
void
-SPConnEnd::setAttacherHref(gchar const *value, SPPath* path)
+SPConnEnd::setAttacherHref(gchar const *value, SPPath* /*path*/)
{
if ( value && href && ( strcmp(value, href) == 0 ) ) {
/* No change, do nothing. */
}
}
// Check to see if the connection point changed and update it.
- //
+ //
if ( !value_strarray[1] )
{
validRef = false;
}
}
-
+
if ( changed )
{
// We still have to verify that the reference to the
// connection point is a valid one.
-
+
// Get the item the connector is attached to
SPItem* item = ref.getObject();
if ( item && !item->avoidRef->isValidConnPointId( type, id ) )
// Update the connector
if (path->connEndPair.isAutoRoutingConn()) {
path->connEndPair.tellLibavoidNewEndpoints();
- }*/
+ }
+*/
}
if ( !validRef )
diff --git a/src/sp-namedview.cpp b/src/sp-namedview.cpp
index 47720c5d64f12fb9409e1f74aa7a537b457d0fe8..9b72a41578492440ac2257540e8a4caf893b2f5a 100644 (file)
--- a/src/sp-namedview.cpp
+++ b/src/sp-namedview.cpp
static void sp_namedview_set(SPObject *object, unsigned int key, const gchar *value)
{
SPNamedView *nv = SP_NAMEDVIEW(object);
+ // TODO investigate why we grab this and then never use it
SPUnit const &px = sp_unit_get_by_id(SP_UNIT_PX);
switch (key) {
diff --git a/src/spray-context.cpp b/src/spray-context.cpp
index 1c050ea06458cadc5a250f091800fc5ae38de1d1..b70e164675202ac1a89d9e94f0c08434cc311b98 100644 (file)
--- a/src/spray-context.cpp
+++ b/src/spray-context.cpp
* Authors:
* Pierre-Antoine MARC
* Pierre CACLIN
- * Aurel-Aimé MARMION
+ * Aurel-Aimé MARMION
* Julien LERAY
* Benoît LAVORATA
* Vincent MONTAGNE
#include "display/canvas-arena.h"
#include "display/curve.h"
#include "livarot/Shape.h"
-#include <2geom/isnan.h>
+#include <2geom/isnan.h>
#include <2geom/transforms.h>
#include "preferences.h"
#include "style.h"
static void sp_spray_context_set(SPEventContext *ec, Inkscape::Preferences::Entry *val);
static gint sp_spray_context_root_handler(SPEventContext *ec, GdkEvent *event);
-static SPEventContextClass *parent_class;
+static SPEventContextClass *parent_class = 0;
//Fin de la création de NormalDistribution
-GtkType
-sp_spray_context_get_type(void)
+GtkType sp_spray_context_get_type(void)
{
static GType type = 0;
if (!type) {
return type;
}
-static void
-sp_spray_context_class_init(SPSprayContextClass *klass)
+static void sp_spray_context_class_init(SPSprayContextClass *klass)
{
GObjectClass *object_class = (GObjectClass *) klass;
SPEventContextClass *event_context_class = (SPEventContextClass *) klass;
event_context_class->set = sp_spray_context_set;
event_context_class->root_handler = sp_spray_context_root_handler;
}
+
/*Method to rotate items*/
-void
-sp_spray_rotate_rel(Geom::Point c,SPDesktop *desktop,SPItem *item, Geom::Rotate const &rotation)
+void sp_spray_rotate_rel(Geom::Point c,SPDesktop */*desktop*/,SPItem *item, Geom::Rotate const &rotation)
{
Geom::Point center = c;
@@ -197,23 +195,23 @@ sp_spray_rotate_rel(Geom::Point c,SPDesktop *desktop,SPItem *item, Geom::Rotate
item->updateRepr();
}
}
+
/*Method to scale items*/
-void
-sp_spray_scale_rel (Geom::Point c, SPDesktop *desktop, SPItem *item, Geom::Scale const &scale)
+void sp_spray_scale_rel(Geom::Point c, SPDesktop */*desktop*/, SPItem *item, Geom::Scale const &scale)
{
- Geom::Translate const s(c);
+ Geom::Translate const s(c);
+
-
sp_item_set_i2d_affine(item, sp_item_i2d_affine(item) * s.inverse() * scale * s );
sp_item_write_transform(item, SP_OBJECT_REPR(item), item->transform);
}
-static void
-sp_spray_context_init(SPSprayContext *tc)
-{
+
+static void sp_spray_context_init(SPSprayContext *tc)
+{
SPEventContext *event_context = SP_EVENT_CONTEXT(tc);
-
+
event_context->cursor_shape = cursor_spray_xpm;
new (&tc->style_set_connection) sigc::connection();
}
-static void
-sp_spray_context_dispose(GObject *object)
+static void sp_spray_context_dispose(GObject *object)
{
SPSprayContext *tc = SP_SPRAY_CONTEXT(object);
G_OBJECT_CLASS(parent_class)->dispose(object);
}
-bool is_transform_modes (gint mode)
+bool is_transform_modes(gint mode)
{
return (mode == SPRAY_MODE_COPY ||
mode == SPRAY_MODE_CLONE ||
mode == SPRAY_OPTION);
}
-void
-sp_spray_update_cursor (SPSprayContext *tc, bool with_shift)
+void sp_spray_update_cursor(SPSprayContext *tc, bool /*with_shift*/)
{
SPEventContext *event_context = SP_EVENT_CONTEXT(tc);
SPDesktop *desktop = event_context->desktop;
g_free(sel_message);
}
-static void
-sp_spray_context_setup(SPEventContext *ec)
+static void sp_spray_context_setup(SPEventContext *ec)
{
SPSprayContext *tc = SP_SPRAY_CONTEXT(ec);
tc->_message_context = new Inkscape::MessageContext((ec->desktop)->messageStack());
- sp_event_context_read(ec, "distrib");
+ sp_event_context_read(ec, "distrib");
sp_event_context_read(ec, "width");
sp_event_context_read(ec, "ratio");
sp_event_context_read(ec, "tilt");
}
}
-static void
-sp_spray_context_set(SPEventContext *ec, Inkscape::Preferences::Entry *val)
+static void sp_spray_context_set(SPEventContext *ec, Inkscape::Preferences::Entry *val)
{
SPSprayContext *tc = SP_SPRAY_CONTEXT(ec);
Glib::ustring path = val->getEntryName();
} else if (path == "rot_max") {
tc->rot_max = CLAMP(val->getDouble(0), 0, 10.0);
} else if (path == "scale_min") {
- tc->scale_min = CLAMP(val->getDouble(1.0), 0, 10.0);
+ tc->scale_min = CLAMP(val->getDouble(1.0), 0, 10.0);
} else if (path == "scale_max") {
tc->scale_max = CLAMP(val->getDouble(1.0), 0, 10.0);
} else if (path == "mean") {
}
}
-static void
-sp_spray_extinput(SPSprayContext *tc, GdkEvent *event)
+static void sp_spray_extinput(SPSprayContext *tc, GdkEvent *event)
{
if (gdk_event_get_axis (event, GDK_AXIS_PRESSURE, &tc->pressure))
tc->pressure = CLAMP (tc->pressure, TC_MIN_PRESSURE, TC_MAX_PRESSURE);
tc->pressure = TC_DEFAULT_PRESSURE;
}
-double
-get_dilate_radius (SPSprayContext *tc)
+double get_dilate_radius(SPSprayContext *tc)
{
return 250 * tc->width/SP_EVENT_CONTEXT(tc)->desktop->current_zoom();
}
-double
-get_path_force (SPSprayContext *tc)
+double get_path_force(SPSprayContext *tc)
{
double force = 8 * (tc->usepressure? tc->pressure : TC_DEFAULT_PRESSURE)
/sqrt(SP_EVENT_CONTEXT(tc)->desktop->current_zoom());
return force * tc->force;
}
-double
-get_path_mean (SPSprayContext *tc)
+double get_path_mean(SPSprayContext *tc)
{
return tc->mean;
}
-double
-get_path_standard_deviation (SPSprayContext *tc)
+double get_path_standard_deviation(SPSprayContext *tc)
{
return tc->standard_deviation;
}
-double
-get_move_force (SPSprayContext *tc)
+double get_move_force(SPSprayContext *tc)
{
double force = (tc->usepressure? tc->pressure : TC_DEFAULT_PRESSURE);
return force * tc->force;
}
-double
-get_move_mean (SPSprayContext *tc)
+double get_move_mean(SPSprayContext *tc)
{
return tc->mean;
}
-double
-get_move_standard_deviation (SPSprayContext *tc)
+double get_move_standard_deviation(SPSprayContext *tc)
{
return tc->standard_deviation;
}
-bool
-sp_spray_dilate_recursive (SPDesktop *desktop, Inkscape::Selection *selection, SPItem *item, Geom::Point p, Geom::Point vector, gint mode, double radius, double force, double population, double &scale, double scale_min, double scale_max, bool reverse, double mean, double standard_deviation, double ratio,double tilt, double rot_min, double rot_max, gint _distrib )
+bool sp_spray_dilate_recursive(SPDesktop *desktop,
+ Inkscape::Selection *selection,
+ SPItem *item,
+ Geom::Point p,
+ Geom::Point /*vector*/,
+ gint mode,
+ double radius,
+ double /*force*/,
+ double population,
+ double &scale,
+ double scale_min,
+ double scale_max,
+ bool /*reverse*/,
+ double mean,
+ double standard_deviation,
+ double ratio,
+ double tilt,
+ double rot_min,
+ double rot_max,
+ gint _distrib )
{
@@ -551,13 +555,13 @@ sp_spray_dilate_recursive (SPDesktop *desktop, Inkscape::Selection *selection, S
Geom::OptRect a = item->getBounds(sp_item_i2doc_affine(item));
if (a) {
- double dr; double dp;
+ double dr; double dp;
random_position(dr,dp,mean,standard_deviation,_distrib);
dr=dr*radius;
double _fid = g_random_double_range(0,1);
SPItem *item_copied;
- double angle = g_random_double_range(rot_min, rot_max);
- double _scale = g_random_double_range(scale_min, scale_max);
+ double angle = g_random_double_range(rot_min, rot_max);
+ double _scale = g_random_double_range(scale_min, scale_max);
if(_fid<=population)
{
// duplicate
@@ -571,17 +575,17 @@ sp_spray_dilate_recursive (SPDesktop *desktop, Inkscape::Selection *selection, S
SPObject *new_obj = doc->getObjectByRepr(copy);
item_copied = (SPItem *) new_obj; //convertion object->item
Geom::Point center=item->getCenter();
- sp_spray_scale_rel(center,desktop,item_copied, Geom::Scale(_scale,_scale));
- sp_spray_scale_rel(center,desktop,item_copied, Geom::Scale(scale,scale));
-
- sp_spray_rotate_rel(center,desktop,item_copied, Geom::Rotate(angle));
+ sp_spray_scale_rel(center,desktop,item_copied, Geom::Scale(_scale,_scale));
+ sp_spray_scale_rel(center,desktop,item_copied, Geom::Scale(scale,scale));
+
+ sp_spray_rotate_rel(center,desktop,item_copied, Geom::Rotate(angle));
Geom::Point move = (Geom::Point(cos(tilt)*cos(dp)*dr/(1-ratio)+sin(tilt)*sin(dp)*dr/(1+ratio),-sin(tilt)*cos(dp)*dr/(1-ratio)+cos(tilt)*sin(dp)*dr/(1+ratio)))+(p-a->midpoint());//Move the cursor p
sp_item_move_rel(item_copied, Geom::Translate(move[Geom::X], -move[Geom::Y]));
-
-
-
+
+
+
did = true;
}
}
@@ -623,8 +627,8 @@ sp_spray_dilate_recursive (SPDesktop *desktop, Inkscape::Selection *selection, S
random_position(dr,dp,mean,standard_deviation,_distrib);
dr=dr*radius;
double _fid = g_random_double_range(0,1);
- double angle = (g_random_double_range(rot_min, rot_max));
- double _scale = g_random_double_range(scale_min, scale_max);
+ double angle = (g_random_double_range(rot_min, rot_max));
+ double _scale = g_random_double_range(scale_min, scale_max);
if (i==2) {
Inkscape::XML::Node *copy1 = old_repr->duplicate(xml_doc);
parent->appendChild(copy1);
@@ -640,11 +644,11 @@ sp_spray_dilate_recursive (SPDesktop *desktop, Inkscape::Selection *selection, S
parent->appendChild(copy2);
SPObject *new_obj2 = doc->getObjectByRepr(copy2);
item_copied = (SPItem *) new_obj2;
-
- Geom::Point move = (Geom::Point(cos(tilt)*cos(dp)*dr/(1-ratio)+sin(tilt)*sin(dp)*dr/(1+ratio),-sin(tilt)*cos(dp)*dr/(1-ratio)+cos(tilt)*sin(dp)*dr/(1+ratio)))+(p-a->midpoint());//Move around the cursor
+
+ Geom::Point move = (Geom::Point(cos(tilt)*cos(dp)*dr/(1-ratio)+sin(tilt)*sin(dp)*dr/(1+ratio),-sin(tilt)*cos(dp)*dr/(1-ratio)+cos(tilt)*sin(dp)*dr/(1+ratio)))+(p-a->midpoint());//Move around the cursor
Geom::Point center=Pere->getCenter();
- sp_spray_scale_rel(center,desktop,item_copied, Geom::Scale(_scale,_scale));
+ sp_spray_scale_rel(center,desktop,item_copied, Geom::Scale(_scale,_scale));
sp_spray_scale_rel(center,desktop,item_copied, Geom::Scale(scale,scale));
sp_spray_rotate_rel(center,desktop,item_copied, Geom::Rotate(angle));
sp_item_move_rel(item_copied, Geom::Translate(move[Geom::X], -move[Geom::Y]));
@@ -661,10 +665,10 @@ sp_spray_dilate_recursive (SPDesktop *desktop, Inkscape::Selection *selection, S
}
} else if (mode == SPRAY_MODE_CLONE) {
-
+
Geom::OptRect a = item->getBounds(sp_item_i2doc_affine(item));
if (a) {
- double dr; double dp;
+ double dr; double dp;
random_position(dr,dp,mean,standard_deviation,_distrib);
dr=dr*radius;
double _fid = g_random_double_range(0,1);
@@ -673,7 +677,7 @@ sp_spray_dilate_recursive (SPDesktop *desktop, Inkscape::Selection *selection, S
if(_fid<=population)
{
- SPItem *item_copied;
+ SPItem *item_copied;
SPDocument *doc = SP_OBJECT_DOCUMENT(item);
Inkscape::XML::Document* xml_doc = sp_document_repr_doc(doc);
Inkscape::XML::Node *old_repr = SP_OBJECT_REPR(item);
@@ -683,33 +687,43 @@ sp_spray_dilate_recursive (SPDesktop *desktop, Inkscape::Selection *selection, S
Inkscape::XML::Node *clone = xml_doc->createElement("svg:use");
parent->appendChild(clone); //Ajout du clone à la liste d'enfants du père (selection initiale
clone->setAttribute("xlink:href", g_strdup_printf("#%s", old_repr->attribute("id")), false); //Génère le lien entre les attributs du père et du fils
-
- SPObject *clone_object = doc->getObjectByRepr(clone);
+
+ SPObject *clone_object = doc->getObjectByRepr(clone);
item_copied = (SPItem *) clone_object;//conversion object->item
Geom::Point center=item->getCenter();
- sp_spray_scale_rel(center,desktop,item_copied, Geom::Scale(_scale,_scale));
+ sp_spray_scale_rel(center,desktop,item_copied, Geom::Scale(_scale,_scale));
sp_spray_scale_rel(center,desktop,item_copied, Geom::Scale(scale,scale));
- sp_spray_rotate_rel(center,desktop,item_copied, Geom::Rotate(angle));
+ sp_spray_rotate_rel(center,desktop,item_copied, Geom::Rotate(angle));
Geom::Point move = (Geom::Point(cos(tilt)*cos(dp)*dr/(1-ratio)+sin(tilt)*sin(dp)*dr/(1+ratio),-sin(tilt)*cos(dp)*dr/(1-ratio)+cos(tilt)*sin(dp)*dr/(1+ratio)))+(p-a->midpoint());
- sp_item_move_rel(item_copied, Geom::Translate(move[Geom::X], -move[Geom::Y]));
+ sp_item_move_rel(item_copied, Geom::Translate(move[Geom::X], -move[Geom::Y]));
Inkscape::GC::release(clone);
did = true;
} }}
return did;
-
+
}
-bool
-sp_spray_color_recursive (guint mode, SPItem *item, SPItem *item_at_point,
- guint32 fill_goal, bool do_fill,
- guint32 stroke_goal, bool do_stroke,
- float opacity_goal, bool do_opacity,
- bool do_blur, bool reverse,
- Geom::Point p, double radius, double force,
- bool do_h, bool do_s, bool do_l, bool do_o)
+bool sp_spray_color_recursive(guint /*mode*/,
+ SPItem */*item*/,
+ SPItem */*item_at_point*/,
+ guint32 /*fill_goal*/,
+ bool /*do_fill*/,
+ guint32 /*stroke_goal*/,
+ bool /*do_stroke*/,
+ float /*opacity_goal*/,
+ bool /*do_opacity*/,
+ bool /*do_blur*/,
+ bool /*reverse*/,
+ Geom::Point /*p*/,
+ double /*radius*/,
+ double /*force*/,
+ bool /*do_h*/,
+ bool /*do_s*/,
+ bool /*do_l*/,
+ bool /*do_o*/)
{
bool did = false;
}
-bool
-sp_spray_dilate (SPSprayContext *tc, Geom::Point event_p, Geom::Point p, Geom::Point vector, bool reverse)
+bool sp_spray_dilate(SPSprayContext *tc, Geom::Point /*event_p*/, Geom::Point p, Geom::Point vector, bool reverse)
{
Inkscape::Selection *selection = sp_desktop_selection(SP_EVENT_CONTEXT(tc)->desktop);
SPDesktop *desktop = SP_EVENT_CONTEXT(tc)->desktop;
@@ -815,8 +828,7 @@ sp_spray_dilate (SPSprayContext *tc, Geom::Point event_p, Geom::Point p, Geom::P
return did;
}
-void
-sp_spray_update_area (SPSprayContext *tc)
+void sp_spray_update_area(SPSprayContext *tc)
{
double radius = get_dilate_radius(tc);
Geom::Matrix const sm ( Geom::Scale(radius/(1-tc->ratio), radius/(1+tc->ratio)) );
sp_canvas_item_show(tc->dilate_area);
}
-void
-sp_spray_switch_mode (SPSprayContext *tc, gint mode, bool with_shift)
+void sp_spray_switch_mode(SPSprayContext *tc, gint mode, bool with_shift)
{
SP_EVENT_CONTEXT(tc)->desktop->setToolboxSelectOneValue ("spray_tool_mode", mode); //sélectionne le bouton numéro "mode"
// need to set explicitly, because the prefs may not have changed by the previous
sp_spray_update_cursor (tc, with_shift);
}
-void
-sp_spray_switch_mode_temporarily (SPSprayContext *tc, gint mode, bool with_shift)
+void sp_spray_switch_mode_temporarily(SPSprayContext *tc, gint mode, bool with_shift)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
// Juggling about so that prefs have the old value but tc->mode and the button show new mode:
@@ -847,8 +857,7 @@ sp_spray_switch_mode_temporarily (SPSprayContext *tc, gint mode, bool with_shift
sp_spray_update_cursor (tc, with_shift);
}
-gint
-sp_spray_context_root_handler(SPEventContext *event_context,
+gint sp_spray_context_root_handler(SPEventContext *event_context,
GdkEvent *event)
{
SPSprayContext *tc = SP_SPRAY_CONTEXT(event_context);
sp_spray_dilate (tc, motion_w, motion_doc, motion_doc - tc->last_push, event->button.state & GDK_SHIFT_MASK? true : false);
//tc->last_push = motion_doc;
tc->has_dilated = true;
-
+
// it's slow, so prevent clogging up with events
gobble_motion_events(GDK_BUTTON1_MASK);
return TRUE;
Geom::Point const scroll_w(event->button.x,event->button.y);
Geom::Point const scroll_dt = desktop->point();;
Geom::Point motion_doc(desktop->dt2doc(scroll_dt));
- switch (event->scroll.direction)
+ switch (event->scroll.direction)
{
case GDK_SCROLL_UP:
{
tc->is_dilating = true;
tc->has_dilated = false;
if(tc->is_dilating && !event_context->space_panning)
-
+
sp_spray_dilate (tc, scroll_w, desktop->dt2doc(scroll_dt), Geom::Point(0,0),false);
-
+
tc->has_dilated=true;
tc->population=temp;
desktop->setToolboxAdjustmentValue ("population", tc->population * 100);
-
+
ret = TRUE;
}
break;
case GDK_j: if (MOD__SHIFT_ONLY) {
sp_spray_switch_mode(tc, SPRAY_MODE_COPY, MOD__SHIFT);
ret = TRUE;
- }
+ }
case GDK_J: if (MOD__SHIFT_ONLY) {
sp_spray_switch_mode(tc, SPRAY_MODE_COPY, MOD__SHIFT);
ret = TRUE;
}
-
+
break;
case GDK_m:
case GDK_M:
case GDK_0:
-
+
break;
case GDK_i:
case GDK_I:
ret = TRUE;
}
break;
-
+
case GDK_l: if (MOD__SHIFT_ONLY) {
sp_spray_switch_mode(tc, SPRAY_MODE_CLONE, MOD__SHIFT);
ret = TRUE;
}
-
+
case GDK_L:
if (MOD__SHIFT_ONLY) {
sp_spray_switch_mode(tc, SPRAY_MODE_CLONE, MOD__SHIFT);
diff --git a/src/svg/svg-color.cpp b/src/svg/svg-color.cpp
index 46779311e74ec741452acfadff9382521eb228ad..ff5a6c2d34ba2b4acc7ded68b0ce3a9675982ae2 100644 (file)
--- a/src/svg/svg-color.cpp
+++ b/src/svg/svg-color.cpp
* this check wrapper. */
gchar const *end = str;
guint32 const ret = internal_sp_svg_read_color(str, &end, dfl);
- assert(ret == dfl && end == str
+ assert(((ret == dfl) && (end == str))
|| (((ret & 0xff) == 0)
- && str < end));
+ && (str < end)));
if (str < end) {
gchar *buf = (gchar *) g_malloc(end + 1 - str);
memcpy(buf, str, end - str);
diff --git a/src/svg/svg-length.cpp b/src/svg/svg-length.cpp
index 942f74d46af3b324c7fddb5a49a6b78a9a7388da..94f1cf312c5ec4943ba35aa0b66e7db773dd0719 100644 (file)
--- a/src/svg/svg-length.cpp
+++ b/src/svg/svg-length.cpp
return 1;
}
+// TODO must add a buffer length parameter for safety:
static unsigned int sp_svg_number_write_ui(gchar *buf, unsigned int val)
{
unsigned int i = 0;
index f9db265d66b1a6f3319f9dcb7363b055bf333c14..60cab06a27c1aacf804525344fba880600368387 100644 (file)
--- a/src/ui/dialog/print.cpp
+++ b/src/ui/dialog/print.cpp
-static void
-draw_page (GtkPrintOperation *operation,
- GtkPrintContext *context,
- gint /*page_nr*/,
- gpointer user_data)
+static void draw_page(
+#ifdef WIN32
+ GtkPrintOperation *operation,
+#else
+ GtkPrintOperation *,
+#endif
+ GtkPrintContext *context,
+ gint /*page_nr*/,
+ gpointer user_data)
{
struct workaround_gtkmm *junk = (struct workaround_gtkmm*)user_data;
//printf("%s %d\n",__FUNCTION__, page_nr);
index ec83b07cdc3575c3b970979a4e4b2dfeb1aca686..a9e037381184578ccd53d22615f89bed50a20636 100644 (file)
#include "graphlayout/graphlayout.h"
#include "inkscape.h"
#include "macros.h"
-#include "node-context.h"
+#include "node-context.h"
#include "preferences.h"
#include "removeoverlap/removeoverlap.h"
#include "selection.h"
-#include "shape-editor.h"
+#include "shape-editor.h"
#include "sp-flowtext.h"
#include "sp-item-transform.h"
#include "sp-text.h"
class Action {
public:
Action(const Glib::ustring &id,
- const Glib::ustring &tiptext,
- guint row, guint column,
+ const Glib::ustring &/*tiptext*/,
+ guint /*row*/,
+ guint /*column*/,
Gtk::Table &parent,
- Gtk::Tooltips &tooltips,
+ Gtk::Tooltips &/*tooltips*/,
SprayOptionClass &dialog):
_dialog(dialog),
_id(id),
_parent(parent) {}
-
+
virtual ~Action(){}
virtual void on_button_click(){}
SprayOptionClass &_dialog;
-
+
private :
-
+
Glib::ustring _id;
Gtk::Table &_parent;
};
dialog._Table().set_col_spacings(3);
double increm = ((double)_max - (double)_min)/10;
- double val_ini = ((double)_max + (double)_min)/2;
+ double val_ini = ((double)_max + (double)_min)/2;
_Gap.set_digits(1);
_Gap.set_size_request(60, -1);
_Gap.set_increments(increm , 0);
virtual void on_button_click(){
if (!_dialog.getDesktop()) return;
-
+
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-
+
prefs->setDouble(_pref_path, SP_VERB_CONTEXT_SPRAY);
-
+
double const Gap = _Gap.get_value();
-
-
+
+
prefs->setDouble(_pref_path, Gap);
sp_document_done(sp_desktop_document(_dialog.getDesktop()), SP_VERB_CONTEXT_SPRAY,
}
-};
+};
class ActionF : public Action {
private:
{
dialog.F_Table().set_col_spacings(3);
- _Label.set_label(id);
+ _Label.set_label(id);
_Gap1.set_digits(1);
_Gap1.set_size_request(60, -1);
_Gap1.set_value(1);
dialog.tooltips().set_tip(_Gap1,
_("Minimum"));
-
+
_Label1.set_label(Q_("Min"));
_Gap2.set_digits(1);
_Gap2.set_value(1);
dialog.tooltips().set_tip(_Gap2,
_("Maximum"));
-
+
_Label2.set_label(_("Max:"));
-
+
_Gap1.signal_changed().connect(sigc::mem_fun(*this, &ActionF::on_button_click));
- _Gap2.signal_changed().connect(sigc::mem_fun(*this, &ActionF::on_button_click));
+ _Gap2.signal_changed().connect(sigc::mem_fun(*this, &ActionF::on_button_click));
dialog.F_Table().attach(_Label, column, column+1, row, row+1, Gtk::FILL, Gtk::FILL);
dialog.F_Table().attach(_Label1, column+1, column+2, row, row+1, Gtk::FILL, Gtk::FILL);
virtual void on_button_click(){
if (!_dialog.getDesktop()) return;
-
+
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-
+
prefs->setDouble(_pref1_path, SP_VERB_CONTEXT_SPRAY);
prefs->setDouble(_pref2_path, SP_VERB_CONTEXT_SPRAY);
-
+
double const Gap1 = _Gap1.get_value();
double const Gap2 = _Gap2.get_value();
-
+
prefs->setDouble(_pref1_path, Gap1);
prefs->setDouble(_pref2_path, Gap2);
}
-};
+};
void SprayOptionClass::combo_action() {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
cout<<"combo.get_active_row_number = "<<_combo.get_active_row_number()<<endl;
-
+
int const distrib = _combo.get_active_row_number();
-
+
prefs->setInt("/tools/spray/distribution", distrib);
-
+
sp_document_done(sp_desktop_document(this->getDesktop()), SP_VERB_CONTEXT_SPRAY,
- _("Remove overlaps"));
+ _("Remove overlaps"));
}
void SprayOptionClass::action() {
- int r=1;
- for (list<Action *>::iterator it = _actionList.begin();
- it != _actionList.end();
- it ++)
+ for (list<Action *>::iterator it = _actionList.begin(); it != _actionList.end(); ++it) {
(*it)->on_button_click();
+ }
combo_action();
}
@@ -242,16 +241,33 @@ void on_selection_changed(Inkscape::Application */*inkscape*/, Inkscape::Selecti
SprayOptionClass::SprayOptionClass()
: UI::Widget::Panel ("", "/dialogs/spray", SP_VERB_DIALOG_SPRAY_OPTION),
+ _actionList(),
_distributionFrame(Q_("sprayOptions|Distribution")),
_Frame(Q_("sprayOptions|Cursor Options")),
_FFrame(Q_("sprayOptions|Random Options")),
+ _distributionTable(),
_gaussianTable(1, 5, false),
_ETable(3,2,false),
_FTable(2,5,false),
+ _anchorBox(),
+ _unifBox(),
+ _gaussianBox(),
+ _HBox(),
+ _FHBox(),
+ _BoutonBox(),
+ _distributionBox(),
+ _VBox(),
+ _FVBox(),
+ _ActionBox(),
+ _anchorLabel(Q_("sprayOptions|Distribution:")),
_unifLabel(Q_("sprayOptions|Uniform")),
_gaussLabel(Q_("sprayOptions|Gaussian")),
- _anchorLabel(Q_("sprayOptions|Distribution:"))
-
+ _Label(),
+ _FLabel(),
+ _unif(),
+ _gauss(),
+ _combo(),
+ _tooltips()
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
_combo.append_text(Q_("sprayOptions|Uniform"));
_combo.append_text(Q_("sprayOptions|Gaussian"));
-
+
_combo.set_active(prefs->getInt("/tools/spray/distribution", 1));
_combo.signal_changed().connect(sigc::mem_fun(*this, &SprayOptionClass::combo_action));
//Implementation dans la Vbox Cursor
_FVBox.pack_start(_FHBox);
- _FFrame.add(_FVBox);
+ _FFrame.add(_FVBox);
//Hbox Cursor
addEButton(Q_("sprayOptions|Ratio:") ,_("Eccentricity of the ellipse"), 0, 0, 0, 1,"/tools/spray/ratio");
Gtk::Box *contents = _getContents();
contents->set_spacing(4);
-
-
-
+
+
+
// Crée dans l'ordre suivant les différentes Frames (cadres de réglages)
contents->pack_start(_distributionFrame, true, true);
- contents->pack_start(_FFrame, true, true);
+ contents->pack_start(_FFrame, true, true);
contents->pack_start(_Frame, true, true);
-
-
+
+
// Connect to the global selection change, to invalidate cached randomize_bbox
g_signal_connect (G_OBJECT (INKSCAPE), "change_selection", G_CALLBACK (on_selection_changed), this);
randomize_bbox = Geom::OptRect();
show_all_children();
-
-
+
+
}
const Glib::ustring &tiptext,
guint row, guint column,
guint min, guint max,
- Glib::ustring const &pref_path)
+ Glib::ustring const &pref_path)
{
_actionList.push_back( new ActionE(id, tiptext,row, column,*this,min ,max, pref_path ));
}
const Glib::ustring &tiptext,
guint row, guint column,
Glib::ustring const &pref1_path,
- Glib::ustring const &pref2_path)
+ Glib::ustring const &pref2_path)
{
_actionList.push_back( new ActionF(id, tiptext,row, column,*this,pref1_path, pref2_path ));
}
index 75dfe1e35b9760eed756581fe6032b45a82d10b8..42090a120cf0d76e29d426a870ef0bde08f3f421 100644 (file)
#include "graphlayout/graphlayout.h"
#include "inkscape.h"
#include "macros.h"
-#include "node-context.h"
+#include "node-context.h"
#include "preferences.h"
#include "removeoverlap/removeoverlap.h"
#include "selection.h"
-#include "shape-editor.h"
+#include "shape-editor.h"
#include "sp-flowtext.h"
#include "sp-item-transform.h"
#include "sp-text.h"
SprayOptionClass(SprayOptionClass const &d);
SprayOptionClass& operator=(SprayOptionClass const &d);
-
+
public:
SprayOptionClass();
- virtual ~SprayOptionClass();
+ virtual ~SprayOptionClass();
void test() { cout<<"appel de test !!"<<endl; }
static SprayOptionClass &getInstance() { return *new SprayOptionClass(); }
-
+
Gtk::Table &_Table(){return _ETable;}
Gtk::Table &F_Table(){return _FTable;}
Gtk::Tooltips &tooltips(){return _tooltips;}
void action();
- void combo_action();
+ void combo_action();
Geom::OptRect randomize_bbox;
SprayOptionClass &get_SprayOptionClass();
const Glib::ustring &pref1_path, const Glib::ustring &pref2_path);
std::list<Action *> _actionList;
- Gtk::Frame _distributionFrame, _Frame, _FFrame ;
- Gtk::Table _distributionTable, _gaussianTable, _ETable, _FTable;
+ Gtk::Frame _distributionFrame;
+ Gtk::Frame _Frame;
+ Gtk::Frame _FFrame;
+ Gtk::Table _distributionTable;
+ Gtk::Table _gaussianTable;
+ Gtk::Table _ETable;
+ Gtk::Table _FTable;
Gtk::HBox _anchorBox;
- Gtk::HBox _unifBox, _gaussianBox, _HBox, _FHBox, _BoutonBox;
- Gtk::VBox _distributionBox, _VBox, _FVBox, _ActionBox;
+ Gtk::HBox _unifBox;
+ Gtk::HBox _gaussianBox;
+ Gtk::HBox _HBox;
+ Gtk::HBox _FHBox;
+ Gtk::HBox _BoutonBox;
+ Gtk::VBox _distributionBox;
+ Gtk::VBox _VBox;
+ Gtk::VBox _FVBox;
+ Gtk::VBox _ActionBox;
Gtk::Label _anchorLabel;
- Gtk::Label _unifLabel, _gaussLabel, _Label, _FLabel;
- Gtk::CheckButton _unif, _gauss;
+ Gtk::Label _unifLabel;
+ Gtk::Label _gaussLabel;
+ Gtk::Label _Label;
+ Gtk::Label _FLabel;
+ Gtk::CheckButton _unif;
+ Gtk::CheckButton _gauss;
Gtk::ComboBoxText _combo;
Gtk::Tooltips _tooltips;
-
};
diff --git a/src/widgets/icon.cpp b/src/widgets/icon.cpp
index 5824b102c9dd8551b7462437187b9ec3942eeecd..743502d2702365012d3b57919caee5fb8afb990e 100644 (file)
--- a/src/widgets/icon.cpp
+++ b/src/widgets/icon.cpp
static int lastSys[Inkscape::ICON_SIZE_DECORATION + 1];
static int vals[Inkscape::ICON_SIZE_DECORATION + 1];
- size = CLAMP( size, GTK_ICON_SIZE_MENU, Inkscape::ICON_SIZE_DECORATION );
+ size = CLAMP( size, static_cast<int>(GTK_ICON_SIZE_MENU), static_cast<int>(Inkscape::ICON_SIZE_DECORATION) );
if ( !sizeMapDone ) {
injectCustomSize();
diff --git a/src/widgets/ruler.cpp b/src/widgets/ruler.cpp
index c90b55e734e79c917cb057df7da84994e26ce2ae..c70d969919edc3db03797f2635e22ffd61032be2 100644 (file)
--- a/src/widgets/ruler.cpp
+++ b/src/widgets/ruler.cpp
// code, those warnings are actually desired. They say "Hey! Fix this". We
// definitely don't want to hide/ignore them. --JonCruz
+// TODO address const/non-const gchar* issue:
/// Ruler metrics.
static GtkRulerMetric const sp_ruler_metrics[] = {
// NOTE: the order of records in this struct must correspond to the SPMetric enum.
index f5f1094f01980fa400efac2814d600313564c0f1..4362139464d0921768721fc4a5aef0d730ba076c 100644 (file)
--- a/src/widgets/toolbox.cpp
+++ b/src/widgets/toolbox.cpp
@@ -4408,11 +4408,13 @@ static void sp_spray_width_value_changed( GtkAdjustment *adj, GObject */*tbl*/ )
prefs->setDouble( "/tools/spray/width", adj->value );
}
-static void sp_spray_force_value_changed( GtkAdjustment *adj, GObject */*tbl*/ )
+/*
+static void sp_spray_force_value_changed( GtkAdjustment * / *adj* /, GObject * / *tbl* / )
{
//Inkscape::Preferences *prefs = Inkscape::Preferences::get();
//prefs->setDouble( "/tools/spray/force", adj->value * 0.01 );
}
+*/
static void sp_spray_mean_value_changed( GtkAdjustment *adj, GObject */*tbl*/ )
{
@@ -4432,7 +4434,7 @@ static void sp_spray_pressure_state_changed( GtkToggleAction *act, gpointer /*da
prefs->setBool("/tools/spray/usepressure", gtk_toggle_action_get_active(act));
}
-static void sp_spray_mode_changed( EgeSelectOneAction *act, GObject *tbl )
+static void sp_spray_mode_changed( EgeSelectOneAction *act, GObject */*tbl*/ )
{
int mode = ege_select_one_action_get_active( act );
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
@@ -6571,7 +6573,7 @@ sp_text_toolbox_family_keypress (GtkWidget */*w*/, GdkEventKey *event, GObject *
}
gboolean
-sp_text_toolbox_family_list_keypress (GtkWidget *w, GdkEventKey *event, GObject */*tbl*/)
+sp_text_toolbox_family_list_keypress (GtkWidget */*w*/, GdkEventKey *event, GObject */*tbl*/)
{
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
if (!desktop) return FALSE;
g_free(family_escaped);
}
-gboolean text_toolbox_completion_match_selected (GtkEntryCompletion *widget,
- GtkTreeModel *model,
- GtkTreeIter *iter,
- GObject *tbl)
+gboolean text_toolbox_completion_match_selected(GtkEntryCompletion */*widget*/,
+ GtkTreeModel *model,
+ GtkTreeIter *iter,
+ GObject *tbl)
{
// We intercept this signal so as to fire family_changed at once (without it, you'd have to
// press Enter again after choosing a completion)
- gchar *family;
+ gchar *family = 0;
gtk_tree_model_get(model, iter, 0, &family, -1);
GtkEntry *entry = GTK_ENTRY (g_object_get_data (G_OBJECT (tbl), "family-entry"));
g_object_unref(completion);
}
-void sp_text_toolbox_family_popnotify (GtkComboBox *widget,
- void *property,
- GObject *tbl)
+void sp_text_toolbox_family_popnotify(GtkComboBox *widget,
+ void */*property*/,
+ GObject *tbl)
{
// while the drop-down is open, we disable font family changing, reenabling it only when it closes
@@ -7109,7 +7111,7 @@ static void sp_connector_orthogonal_toggled( GtkToggleAction* act, GObject *tbl
{
return;
}
-
+
// quit if run by the _changed callbacks
if (g_object_get_data( tbl, "freeze" )) {
{
return;
}
-
+
// quit if run by the _changed callbacks
if (g_object_get_data( tbl, "freeze" )) {
@@ -7280,7 +7282,7 @@ static void sp_nooverlaps_graph_layout_toggled( GtkToggleAction* act, GtkObject
}
-static void connector_length_changed(GtkAdjustment *adj, GObject* tbl)
+static void connector_length_changed(GtkAdjustment *adj, GObject* /*tbl*/)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
prefs->setDouble("/tools/connector/length", adj->value);
@@ -7495,9 +7497,9 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA
g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_new_connection_point), holder );
gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
}
-
+
// Remove selected connection point button
-
+
{
InkAction* inky = ink_action_new( "ConnectorRemoveConnPointAction",
_("Remove connection point"),
@@ -7507,7 +7509,7 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA
g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_remove_connection_point), holder );
gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
}
-
+
// Code to watch for changes to the connector-spacing attribute in
// the XML.