![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/snap.cpp b/src/snap.cpp
index 46bd01f4d5996e06e5d04ee735634fed1ce0567f..85d2fd5afbac5bfe129b400bc04214b23813f1fd 100644 (file)
--- a/src/snap.cpp
+++ b/src/snap.cpp
#include "sp-namedview.h"
#include "snap.h"
+#include "snap-enums.h"
#include "snapped-line.h"
#include "snapped-curve.h"
@@ -319,11 +320,12 @@ Geom::Point SnapManager::multipleOfGridPitch(Geom::Point const &t, Geom::Point c
* constrainedSnapReturnByRef() is equal in snapping behavior to
* constrainedSnap(), but the former returns the snapped point trough the referenced
* parameter p. This parameter p initially contains the position of the snap
- * source and will we overwritten by the target position if snapping has occurred.
+ * source and will be overwritten by the target position if snapping has occurred.
* This makes snapping transparent to the calling code. If this is not desired
* because either the calling code must know whether snapping has occurred, or
* because the original position should not be touched, then constrainedSnap() should
- * be called instead.
+ * be called instead. If there's nothing to snap to or if snapping has been disabled,
+ * then this method will still apply the constraint (but without snapping)
*
* PS:
* 1) SnapManager::setup() must have been called before calling this method,
*
* PS: SnapManager::setup() must have been called before calling this method,
* but only once for a set of points
+ * PS: If there's nothing to snap to or if snapping has been disabled, then this
+ * method will still apply the constraint (but without snapping)
*
* \param p Source point to be snapped
* \param constraint The direction or line along which snapping must occur
@@ -421,12 +425,14 @@ Inkscape::SnappedPoint SnapManager::constrainedSnap(Inkscape::SnapCandidatePoint
* and will try to snap the SnapCandidatePoint to all of the provided constraints and see which one fits best
* \param p Source point to be snapped
* \param constraints List of directions or lines along which snapping must occur
+ * \param dont_snap If true then we will only apply the constraint, without snapping
* \param bbox_to_snap Bounding box hulling the set of points, all from the same selection and having the same transformation
*/
Inkscape::SnappedPoint SnapManager::multipleConstrainedSnaps(Inkscape::SnapCandidatePoint const &p,
std::vector<Inkscape::Snapper::SnapConstraint> const &constraints,
+ bool dont_snap,
Geom::OptRect const &bbox_to_snap) const
{
@@ -438,7 +444,7 @@ Inkscape::SnappedPoint SnapManager::multipleConstrainedSnaps(Inkscape::SnapCandi
SnappedConstraints sc;
SnapperList const snappers = getSnappers();
std::vector<Geom::Point> projections;
- bool snapping_is_futile = !someSnapperMightSnap();
+ bool snapping_is_futile = !someSnapperMightSnap() || dont_snap;
Inkscape::SnappedPoint result = no_snap;
@@ -452,7 +458,7 @@ Inkscape::SnappedPoint SnapManager::multipleConstrainedSnaps(Inkscape::SnapCandi
projections.push_back(pp);
}
- if (snap_mouse && p.isSingleHandle()) {
+ if (snap_mouse && p.isSingleHandle() && !dont_snap) {
// Snapping the mouse pointer instead of the constrained position of the knot allows
// to snap to things which don't intersect with the constraint line; this is basically
// then just a freesnap with the constraint applied afterwards
@@ -653,6 +659,8 @@ void SnapManager::guideConstrainedSnap(Geom::Point &p, SPGuide const &guideline)
* a free snap or constrained snap is more appropriate, do the snapping, calculate
* some metrics to quantify the snap "distance", and see if it's better than the
* previous snap. Finally, the best ("nearest") snap from all these points is returned.
+ * If no snap has occurred and we're asked for a constrained snap then the constraint
+ * will be applied nevertheless
*
* \param points Collection of points to snap (snap sources), at their untransformed position, all points undergoing the same transformation. Paired with an identifier of the type of the snap source.
* \param pointer Location of the mouse pointer at the time dragging started (i.e. when the selection was still untransformed).
Geom::Point const &transformation,
Geom::Point const &origin,
Geom::Dim2 dim,
- bool uniform) const
+ bool uniform)
{
/* We have a list of points, which we are proposing to transform in some way. We need to see
** if any of these points, when transformed, snap to anything. If they do, we return the
** appropriate transformation with `true'; otherwise we return the original scale with `false'.
*/
- /* Quick check to see if we have any snappers that are enabled
- ** Also used to globally disable all snapping
- */
- if (someSnapperMightSnap() == false || points.size() == 0) {
+ if (points.size() == 0) {
return Inkscape::SnappedPoint(pointer);
}
g_warning("Unconstrained rotation is not supported!");
}
+ // We will try to snap a set of points, but we don't want to have a snap indicator displayed
+ // for each of them. That's why it's temporarily disabled here, and re-enabled again after we
+ // have finished calling the freeSnap() and constrainedSnap() methods
+ bool _orig_snapindicator_status = _snapindicator;
+ _snapindicator = false;
+
std::vector<Inkscape::SnapCandidatePoint>::iterator j = transformed_points.begin();
// std::cout << std::endl;
// std::cout << "dist = " << snapped_point.getSnapDistance() << std::endl;
snapped_point.setPointerDistance(Geom::L2(pointer - (*i).getPoint()));
+ // Allow the snapindicator to be displayed again
+ _snapindicator = _orig_snapindicator_status;
+
Geom::Point result;
- if (snapped_point.getSnapped()) {
- /* We snapped. Find the transformation that describes where the snapped point has
- ** ended up, and also the metric for this transformation.
- */
- Geom::Point const a = snapped_point.getPoint() - origin; // vector to snapped point
- //Geom::Point const b = (*i - origin); // vector to original point
-
- switch (transformation_type) {
- case TRANSLATE:
- result = snapped_point.getPoint() - (*i).getPoint();
- /* Consider the case in which a box is almost aligned with a grid in both
- * horizontal and vertical directions. The distance to the intersection of
- * the grid lines will always be larger then the distance to a single grid
- * line. If we prefer snapping to an intersection instead of to a single
- * grid line, then we cannot use "metric = Geom::L2(result)". Therefore the
- * snapped distance will be used as a metric. Please note that the snapped
- * distance is defined as the distance to the nearest line of the intersection,
- * and not to the intersection itself!
- */
- // Only for translations, the relevant metric will be the real snapped distance,
- // so we don't have to do anything special here
- break;
- case SCALE:
- {
- result = Geom::Point(NR_HUGE, NR_HUGE);
- // If this point *i is horizontally or vertically aligned with
- // the origin of the scaling, then it will scale purely in X or Y
- // We can therefore only calculate the scaling in this direction
- // and the scaling factor for the other direction should remain
- // untouched (unless scaling is uniform of course)
- for (int index = 0; index < 2; index++) {
- if (fabs(b[index]) > 1e-6) { // if SCALING CAN occur in this direction
- if (fabs(fabs(a[index]/b[index]) - fabs(transformation[index])) > 1e-12) { // if SNAPPING DID occur in this direction
- result[index] = a[index] / b[index]; // then calculate it!
- }
- // we might leave result[1-index] = NR_HUGE
- // if scaling didn't occur in the other direction
+ /*Find the transformation that describes where the snapped point has
+ ** ended up, and also the metric for this transformation.
+ */
+ Geom::Point const a = snapped_point.getPoint() - origin; // vector to snapped point
+ //Geom::Point const b = (*i - origin); // vector to original point
+
+ switch (transformation_type) {
+ case TRANSLATE:
+ result = snapped_point.getPoint() - (*i).getPoint();
+ /* Consider the case in which a box is almost aligned with a grid in both
+ * horizontal and vertical directions. The distance to the intersection of
+ * the grid lines will always be larger then the distance to a single grid
+ * line. If we prefer snapping to an intersection instead of to a single
+ * grid line, then we cannot use "metric = Geom::L2(result)". Therefore the
+ * snapped distance will be used as a metric. Please note that the snapped
+ * distance is defined as the distance to the nearest line of the intersection,
+ * and not to the intersection itself!
+ */
+ // Only for translations, the relevant metric will be the real snapped distance,
+ // so we don't have to do anything special here
+ break;
+ case SCALE:
+ {
+ result = Geom::Point(NR_HUGE, NR_HUGE);
+ // If this point *i is horizontally or vertically aligned with
+ // the origin of the scaling, then it will scale purely in X or Y
+ // We can therefore only calculate the scaling in this direction
+ // and the scaling factor for the other direction should remain
+ // untouched (unless scaling is uniform of course)
+ for (int index = 0; index < 2; index++) {
+ if (fabs(b[index]) > 1e-6) { // if SCALING CAN occur in this direction
+ if (fabs(fabs(a[index]/b[index]) - fabs(transformation[index])) > 1e-12) { // if SNAPPING DID occur in this direction
+ result[index] = a[index] / b[index]; // then calculate it!
}
+ // we might leave result[1-index] = NR_HUGE
+ // if scaling didn't occur in the other direction
}
- if (uniform) {
- if (fabs(result[0]) < fabs(result[1])) {
- result[1] = result[0];
- } else {
- result[0] = result[1];
- }
- }
- // Compare the resulting scaling with the desired scaling
- Geom::Point scale_metric = Geom::abs(result - transformation); // One or both of its components might be NR_HUGE
- snapped_point.setSnapDistance(std::min(scale_metric[0], scale_metric[1]));
- snapped_point.setSecondSnapDistance(std::max(scale_metric[0], scale_metric[1]));
- break;
}
- case STRETCH:
- result = Geom::Point(NR_HUGE, NR_HUGE);
- if (fabs(b[dim]) > 1e-6) { // if STRETCHING will occur for this point
- result[dim] = a[dim] / b[dim];
- result[1-dim] = uniform ? result[dim] : 1;
- } else { // STRETCHING might occur for this point, but only when the stretching is uniform
- if (uniform && fabs(b[1-dim]) > 1e-6) {
- result[1-dim] = a[1-dim] / b[1-dim];
- result[dim] = result[1-dim];
- }
+ if (uniform) {
+ if (fabs(result[0]) < fabs(result[1])) {
+ result[1] = result[0];
+ } else {
+ result[0] = result[1];
}
- // Store the metric for this transformation as a virtual distance
- snapped_point.setSnapDistance(std::abs(result[dim] - transformation[dim]));
- snapped_point.setSecondSnapDistance(NR_HUGE);
- break;
- case SKEW:
- result[0] = (snapped_point.getPoint()[dim] - ((*i).getPoint())[dim]) / b[1 - dim]; // skew factor
- result[1] = transformation[1]; // scale factor
- // Store the metric for this transformation as a virtual distance
- snapped_point.setSnapDistance(std::abs(result[0] - transformation[0]));
- snapped_point.setSecondSnapDistance(NR_HUGE);
- break;
- case ROTATE:
- // a is vector to snapped point; b is vector to original point; now lets calculate angle between a and b
- result[0] = atan2(Geom::dot(Geom::rot90(b), a), Geom::dot(b, a));
- result[1] = result[1]; // how else should we store an angle in a point ;-)
- // Store the metric for this transformation as a virtual distance (we're storing an angle)
- snapped_point.setSnapDistance(std::abs(result[0] - transformation[0]));
- snapped_point.setSecondSnapDistance(NR_HUGE);
- break;
- default:
- g_assert_not_reached();
+ }
+ // Compare the resulting scaling with the desired scaling
+ Geom::Point scale_metric = Geom::abs(result - transformation); // One or both of its components might be NR_HUGE
+ snapped_point.setSnapDistance(std::min(scale_metric[0], scale_metric[1]));
+ snapped_point.setSecondSnapDistance(std::max(scale_metric[0], scale_metric[1]));
+ break;
}
+ case STRETCH:
+ result = Geom::Point(NR_HUGE, NR_HUGE);
+ if (fabs(b[dim]) > 1e-6) { // if STRETCHING will occur for this point
+ result[dim] = a[dim] / b[dim];
+ result[1-dim] = uniform ? result[dim] : 1;
+ } else { // STRETCHING might occur for this point, but only when the stretching is uniform
+ if (uniform && fabs(b[1-dim]) > 1e-6) {
+ result[1-dim] = a[1-dim] / b[1-dim];
+ result[dim] = result[1-dim];
+ }
+ }
+ // Store the metric for this transformation as a virtual distance
+ snapped_point.setSnapDistance(std::abs(result[dim] - transformation[dim]));
+ snapped_point.setSecondSnapDistance(NR_HUGE);
+ break;
+ case SKEW:
+ result[0] = (snapped_point.getPoint()[dim] - ((*i).getPoint())[dim]) / b[1 - dim]; // skew factor
+ result[1] = transformation[1]; // scale factor
+ // Store the metric for this transformation as a virtual distance
+ snapped_point.setSnapDistance(std::abs(result[0] - transformation[0]));
+ snapped_point.setSecondSnapDistance(NR_HUGE);
+ break;
+ case ROTATE:
+ // a is vector to snapped point; b is vector to original point; now lets calculate angle between a and b
+ result[0] = atan2(Geom::dot(Geom::rot90(b), a), Geom::dot(b, a));
+ result[1] = result[1]; // how else should we store an angle in a point ;-)
+ // Store the metric for this transformation as a virtual distance (we're storing an angle)
+ snapped_point.setSnapDistance(std::abs(result[0] - transformation[0]));
+ snapped_point.setSecondSnapDistance(NR_HUGE);
+ break;
+ default:
+ g_assert_not_reached();
+ }
+ if (snapped_point.getSnapped()) {
+ // We snapped; keep track of the best snap
+ // TODO: Compare the transformations instead of the snap points; we should be looking for the closest transformation
if (best_snapped_point.isOtherSnapBetter(snapped_point, true)) {
best_transformation = result;
best_snapped_point = snapped_point;
}
+ } else {
+ // So we didn't snap for this point
+ if (!best_snapped_point.getSnapped()) {
+ // ... and none of the points before snapped either
+ // We might still need to apply a constraint though, if we tried a constrained snap. And
+ // in case of a free snap we might have use for the transformed point, so let's return that
+ // point, whether it's constrained or not
+ if (best_snapped_point.isOtherSnapBetter(snapped_point, true)) {
+ // .. so we must keep track of the best non-snapped constrained point
+ best_transformation = result;
+ best_snapped_point = snapped_point;
+ }
+ }
}
j++;
// Using " < 1e6" instead of " < NR_HUGE" for catching some rounding errors
// These rounding errors might be caused by NRRects, see bug #1584301
best_snapped_point.setSnapDistance(best_metric < 1e6 ? best_metric : NR_HUGE);
+
+ if (_snapindicator) {
+ if (best_snapped_point.getSnapped()) {
+ _desktop->snapindicator->set_new_snaptarget(best_snapped_point);
+ } else {
+ _desktop->snapindicator->remove_snaptarget();
+ }
+ }
+
return best_snapped_point;
}
Inkscape::SnappedPoint SnapManager::freeSnapTranslate(std::vector<Inkscape::SnapCandidatePoint> const &p,
Geom::Point const &pointer,
- Geom::Point const &tr) const
+ Geom::Point const &tr)
{
+ Inkscape::SnappedPoint result = _snapTransformed(p, pointer, false, Geom::Point(0,0), TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);
+
if (p.size() == 1) {
- Geom::Point pt = _transformPoint(p.at(0), TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);
- _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
+ _displaySnapsource(Inkscape::SnapCandidatePoint(result.getPoint(), p.at(0).getSourceType()));
}
-
-
- return _snapTransformed(p, pointer, false, Geom::Point(0,0), TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);
+ return result;
}
/**
@@ -954,14 +991,15 @@ Inkscape::SnappedPoint SnapManager::freeSnapTranslate(std::vector<Inkscape::Snap
Inkscape::SnappedPoint SnapManager::constrainedSnapTranslate(std::vector<Inkscape::SnapCandidatePoint> const &p,
Geom::Point const &pointer,
Inkscape::Snapper::SnapConstraint const &constraint,
- Geom::Point const &tr) const
+ Geom::Point const &tr)
{
+ Inkscape::SnappedPoint result = _snapTransformed(p, pointer, true, constraint, TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);
+
if (p.size() == 1) {
- Geom::Point pt = _transformPoint(p.at(0), TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);
- _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
+ _displaySnapsource(Inkscape::SnapCandidatePoint(result.getPoint(), p.at(0).getSourceType()));
}
- return _snapTransformed(p, pointer, true, constraint, TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);
+ return result;
}
@@ -978,14 +1016,15 @@ Inkscape::SnappedPoint SnapManager::constrainedSnapTranslate(std::vector<Inkscap
Inkscape::SnappedPoint SnapManager::freeSnapScale(std::vector<Inkscape::SnapCandidatePoint> const &p,
Geom::Point const &pointer,
Geom::Scale const &s,
- Geom::Point const &o) const
+ Geom::Point const &o)
{
+ Inkscape::SnappedPoint result = _snapTransformed(p, pointer, false, Geom::Point(0,0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, false);
+
if (p.size() == 1) {
- Geom::Point pt = _transformPoint(p.at(0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, false);
- _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
+ _displaySnapsource(Inkscape::SnapCandidatePoint(result.getPoint(), p.at(0).getSourceType()));
}
- return _snapTransformed(p, pointer, false, Geom::Point(0,0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, false);
+ return result;
}
@@ -1002,15 +1041,16 @@ Inkscape::SnappedPoint SnapManager::freeSnapScale(std::vector<Inkscape::SnapCand
Inkscape::SnappedPoint SnapManager::constrainedSnapScale(std::vector<Inkscape::SnapCandidatePoint> const &p,
Geom::Point const &pointer,
Geom::Scale const &s,
- Geom::Point const &o) const
+ Geom::Point const &o)
{
// When constrained scaling, only uniform scaling is supported.
+ Inkscape::SnappedPoint result = _snapTransformed(p, pointer, true, Geom::Point(0,0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, true);
+
if (p.size() == 1) {
- Geom::Point pt = _transformPoint(p.at(0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, true);
- _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
+ _displaySnapsource(Inkscape::SnapCandidatePoint(result.getPoint(), p.at(0).getSourceType()));
}
- return _snapTransformed(p, pointer, true, Geom::Point(0,0), SCALE, Geom::Point(s[Geom::X], s[Geom::Y]), o, Geom::X, true);
+ return result;
}
/**
@@ -1030,14 +1070,15 @@ Inkscape::SnappedPoint SnapManager::constrainedSnapStretch(std::vector<Inkscape:
Geom::Coord const &s,
Geom::Point const &o,
Geom::Dim2 d,
- bool u) const
+ bool u)
{
+ Inkscape::SnappedPoint result = _snapTransformed(p, pointer, true, Geom::Point(0,0), STRETCH, Geom::Point(s, s), o, d, u);
+
if (p.size() == 1) {
- Geom::Point pt = _transformPoint(p.at(0), STRETCH, Geom::Point(s, s), o, d, u);
- _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
+ _displaySnapsource(Inkscape::SnapCandidatePoint(result.getPoint(), p.at(0).getSourceType()));
}
- return _snapTransformed(p, pointer, true, Geom::Point(0,0), STRETCH, Geom::Point(s, s), o, d, u);
+ return result;
}
/**
@@ -1057,7 +1098,7 @@ Inkscape::SnappedPoint SnapManager::constrainedSnapSkew(std::vector<Inkscape::Sn
Inkscape::Snapper::SnapConstraint const &constraint,
Geom::Point const &s,
Geom::Point const &o,
- Geom::Dim2 d) const
+ Geom::Dim2 d)
{
// "s" contains skew factor in s[0], and scale factor in s[1]
@@ -1070,12 +1111,13 @@ Inkscape::SnappedPoint SnapManager::constrainedSnapSkew(std::vector<Inkscape::Sn
g_assert(!(p.at(0).getSourceType() & Inkscape::SNAPSOURCE_BBOX_CATEGORY));
}
+ Inkscape::SnappedPoint result = _snapTransformed(p, pointer, true, constraint, SKEW, s, o, d, false);
+
if (p.size() == 1) {
- Geom::Point pt = _transformPoint(p.at(0), SKEW, s, o, d, false);
- _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
+ _displaySnapsource(Inkscape::SnapCandidatePoint(result.getPoint(), p.at(0).getSourceType()));
}
- return _snapTransformed(p, pointer, true, constraint, SKEW, s, o, d, false);
+ return result;
}
/**
@@ -1091,7 +1133,7 @@ Inkscape::SnappedPoint SnapManager::constrainedSnapSkew(std::vector<Inkscape::Sn
Inkscape::SnappedPoint SnapManager::constrainedSnapRotate(std::vector<Inkscape::SnapCandidatePoint> const &p,
Geom::Point const &pointer,
Geom::Coord const &angle,
- Geom::Point const &o) const
+ Geom::Point const &o)
{
// Snapping the nodes of the bounding box of a selection that is being transformed, will only work if
// the transformation of the bounding box is equal to the transformation of the individual nodes. This is
@@ -1099,12 +1141,13 @@ Inkscape::SnappedPoint SnapManager::constrainedSnapRotate(std::vector<Inkscape::
// so it's corners have a different transformation. The snappers cannot handle this, therefore snapping
// of bounding boxes is not allowed here.
+ Inkscape::SnappedPoint result = _snapTransformed(p, pointer, true, Geom::Point(0,0), ROTATE, Geom::Point(angle, angle), o, Geom::X, false);
+
if (p.size() == 1) {
- Geom::Point pt = _transformPoint(p.at(0), ROTATE, Geom::Point(angle, angle), o, Geom::X, false);
- _displaySnapsource(Inkscape::SnapCandidatePoint(pt, p.at(0).getSourceType()));
+ _displaySnapsource(Inkscape::SnapCandidatePoint(result.getPoint(), p.at(0).getSourceType()));
}
- return _snapTransformed(p, pointer, true, Geom::Point(0,0), ROTATE, Geom::Point(angle, angle), o, Geom::X, false);
+ return result;
}
@@ -1406,6 +1449,26 @@ void SnapManager::_displaySnapsource(Inkscape::SnapCandidatePoint const &p) cons
}
}
+void SnapManager::keepClosestPointOnly(std::vector<Inkscape::SnapCandidatePoint> &points, const Geom::Point &reference) const
+{
+ if (points.size() < 2) return;
+
+ Inkscape::SnapCandidatePoint closest_point = Inkscape::SnapCandidatePoint(Geom::Point(NR_HUGE, NR_HUGE), Inkscape::SNAPSOURCE_UNDEFINED, Inkscape::SNAPTARGET_UNDEFINED);
+ Geom::Coord closest_dist = NR_HUGE;
+
+ for(std::vector<Inkscape::SnapCandidatePoint>::const_iterator i = points.begin(); i != points.end(); i++) {
+ Geom::Coord dist = Geom::L2((*i).getPoint() - reference);
+ if (i == points.begin() || dist < closest_dist) {
+ closest_point = *i;
+ closest_dist = dist;
+ }
+ }
+
+ closest_point.setSourceNum(-1);
+ points.clear();
+ points.push_back(closest_point);
+}
+
/*
Local Variables:
mode:c++
@@ -1415,4 +1478,4 @@ void SnapManager::_displaySnapsource(Inkscape::SnapCandidatePoint const &p) cons
fill-column:99
End:
*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :