snap.cpp revision 0e6c684b45e5626866ddc996b7a2b7701711f394
/*
* SnapManager class.
*
* Authors:
* Lauris Kaplinski <lauris@kaplinski.com>
* Frank Felfe <innerspace@iname.com>
* Nathan Hurst <njh@njhurst.com>
* Carl Hetherington <inkscape@carlh.net>
* Diederik van Lierop <mail@diedenrezi.nl>
*
* Copyright (C) 2006-2007 Johan Engelen <johan@shouraizou.nl>
* Copyrigth (C) 2004 Nathan Hurst
* Copyright (C) 1999-2012 Authors
*
* Released under GNU GPL, read the file 'COPYING' for more information
*/
#include <utility>
#include "sp-namedview.h"
#include "snap.h"
#include "snap-enums.h"
#include "snapped-line.h"
#include "snapped-curve.h"
#include "display/canvas-grid.h"
#include "display/snap-indicator.h"
#include "inkscape.h"
#include "desktop.h"
#include "selection.h"
#include "sp-guide.h"
#include "preferences.h"
#include "ui/tools/tool-base.h"
guide(this, 0),
object(this, 0),
snapprefs(),
_named_view(v),
_snapindicator(true),
{
}
{
return s;
}
{
SnapperList s;
if (_desktop && _desktop->gridsEnabled() && snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_GRID)) {
}
}
return s;
}
{
if ( !snapprefs.getSnapEnabledGlobally() ) {
return false;
}
// If we're asking if some snapper might snap RIGHT NOW (without the snap being postponed)...
return false;
}
SnapperList const s = getSnappers();
while (i != s.end() && (*i)->ThisSnapperMightSnap() == false) {
++i;
}
return (i != s.end());
}
bool SnapManager::gridSnapperMightSnap() const
{
return false;
}
SnapperList const s = getGridSnappers();
while (i != s.end() && (*i)->ThisSnapperMightSnap() == false) {
++i;
}
return (i != s.end());
}
{
Inkscape::SnappedPoint const s = freeSnap(Inkscape::SnapCandidatePoint(p, source_type), bbox_to_snap);
s.getPointIfSnapped(p);
}
{
if (!someSnapperMightSnap()) {
return Inkscape::SnappedPoint(p, Inkscape::SNAPTARGET_UNDEFINED, Geom::infinity(), 0, false, false, false);
}
}
return findBestSnap(p, isr, false);
}
{
// setup() must have been called before calling this method!
if (_snapindicator) {
_snapindicator = false; // prevent other methods from drawing a snap indicator; we want to control this here
if (s.getSnapped()) {
} else {
}
_snapindicator = true; // restore the original value
}
}
{
return t;
bool success = false;
// It will snap to the grid for which we find the closest snap. This might be a different
// grid than to which the objects were initially aligned. I don't see an easy way to fix
// this, so when using multiple grids one can get unexpected results
// Cannot use getGridSnappers() because we need both the grids AND their snappers
// Therefore we iterate through all grids manually
// To find the nearest multiple of the grid pitch for a given translation t, we
// will use the grid snapper. Simply snapping the value t to the grid will do, but
// only if the origin of the grid is at (0,0). If it's not then compensate for this
// in the translation t
// Only the first three parameters are being used for grid snappers
snapper->freeSnap(isr, Inkscape::SnapCandidatePoint(t_offset, Inkscape::SNAPSOURCE_GRID_PITCH),Geom::OptRect(), NULL, NULL);
// Find the best snap for this grid, including intersections of the grid-lines
bool old_val = _snapindicator;
_snapindicator = false;
Inkscape::SnappedPoint s = findBestSnap(Inkscape::SnapCandidatePoint(t_offset, Inkscape::SNAPSOURCE_GRID_PITCH), isr, false, true);
// use getSnapDistance() instead of getWeightedDistance() here because the pointer's position
// doesn't tell us anything about which node to snap
success = true;
nearest_distance = s.getSnapDistance();
bestSnappedPoint = s;
}
}
}
if (success) {
return nearest_multiple;
}
}
return t;
}
{
Inkscape::SnappedPoint const s = constrainedSnap(Inkscape::SnapCandidatePoint(p, source_type), constraint, bbox_to_snap);
p = s.getPoint(); // If we didn't snap, then we will return the point projected onto the constraint
}
{
// First project the mouse pointer onto the constraint
Inkscape::SnappedPoint no_snap = Inkscape::SnappedPoint(pp, p.getSourceType(), p.getSourceNum(), Inkscape::SNAPTARGET_CONSTRAINT, Geom::infinity(), 0, false, true, false);
if (!someSnapperMightSnap()) {
// Always return point on constraint
return no_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
// We'll only do this if we're dragging a single handle, and for example not when transforming an object in the selector tool
if (result.getSnapped()) {
// only change the snap indicator if we really snapped to something
if (_snapindicator && _desktop) {
}
// Apply the constraint
return result;
}
return no_snap;
}
}
if (result.getSnapped()) {
// only change the snap indicator if we really snapped to something
if (_snapindicator && _desktop) {
}
return result;
}
return no_snap;
}
/* See the documentation for constrainedSnap() directly above for more details.
* The difference is that multipleConstrainedSnaps() will take a list of constraints instead of a single one,
* 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
*/
bool dont_snap,
{
Inkscape::SnappedPoint no_snap = Inkscape::SnappedPoint(p.getPoint(), p.getSourceType(), p.getSourceNum(), Inkscape::SNAPTARGET_CONSTRAINT, Geom::infinity(), 0, false, true, false);
if (constraints.size() == 0) {
return no_snap;
}
for (std::vector<Inkscape::Snapper::SnapConstraint>::const_iterator c = constraints.begin(); c != constraints.end(); ++c) {
// Project the mouse pointer onto the constraint; In case we don't snap then we will
// return the projection onto the constraint, such that the constraint is always enforced
}
// 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
// We'll only to this if we're dragging a single handle, and for example not when transforming an object in the selector tool
} else {
// Iterate over the constraints
for (std::vector<Inkscape::Snapper::SnapConstraint>::const_iterator c = constraints.begin(); c != constraints.end(); ++c) {
// Try to snap to the constraint
if (!snapping_is_futile) {
}
}
}
}
if (result.getSnapped()) {
if (snap_mouse) {
// If "snap_mouse" then we still have to apply the constraint, because so far we only tried a freeSnap
for (std::vector<Inkscape::Snapper::SnapConstraint>::const_iterator c = constraints.begin(); c != constraints.end(); ++c) {
// Project the mouse pointer onto the constraint; In case we don't snap then we will
// return the projection onto the constraint, such that the constraint is always enforced
if (c == constraints.begin() || (Geom::L2(result_p - p.getPoint()) < Geom::L2(result_closest - p.getPoint()))) {
}
}
}
return result;
}
// So we didn't snap, but we still need to return a point on one of the constraints
// Find out which of the constraints yielded the closest projection of point p
}
} else {
}
}
return no_snap;
}
unsigned const snaps) const
{
if (snaps > 0) { // 0 means no angular snapping
// p is at an arbitrary angle. Now we should snap this angle to specific increments.
// For this we'll calculate the closest two angles, one at each side of the current angle
double angle_offset = 0;
if (p_ref) {
}
// We have two angles now. The constrained snapper will try each of them and return the closest
// Now do the snapping...
sp = multipleConstrainedSnaps(p, constraints); // Constraints will always be applied, even if we didn't snap
}
} else {
}
return sp;
}
void SnapManager::guideFreeSnap(Geom::Point &p, Geom::Point &origin_or_vector, bool origin, bool freeze_angle) const
{
if (freeze_angle && origin) {
g_warning("Dear developer, when snapping guides you shouldn't ask me to freeze the guide's vector when you haven't specified one");
// You've supplied me with an origin instead of a vector
}
if (!snapprefs.getSnapEnabledGlobally() || snapprefs.getSnapPostponedGlobally() || !snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_GUIDE)) {
return;
}
if (origin) {
} else {
}
}
s.getPointIfSnapped(p);
if (!freeze_angle && s.getSnapped()) {
// PS: The tangent might not have been set if we snapped for example to a node
}
}
}
{
if (!snapprefs.getSnapEnabledGlobally() || snapprefs.getSnapPostponedGlobally() || !snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_GUIDE)) {
return;
}
Inkscape::SnapCandidatePoint candidate(p, Inkscape::SNAPSOURCE_GUIDE_ORIGIN, Inkscape::SNAPTARGET_UNDEFINED);
Inkscape::Snapper::SnapConstraint cl(guideline.point_on_line, Geom::rot90(guideline.normal_to_line));
}
s.getPointIfSnapped(p);
}
bool constrained,
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'.
*/
}
long source_num = 0;
for (std::vector<Inkscape::SnapCandidatePoint>::const_iterator i = points.begin(); i != points.end(); ++i) {
/* Work out the transformed version of this point */
Geom::Point transformed = _transformPoint(*i, transformation_type, transformation, origin, dim, uniform);
// add the current transformed point to the box hulling all transformed points
} else {
}
transformed_points.push_back(Inkscape::SnapCandidatePoint(transformed, (*i).getSourceType(), source_num, Inkscape::SNAPTARGET_UNDEFINED, Geom::OptRect()));
source_num++;
}
/* The current best transformation */
/* The current best metric for the best transformation; lower is better, Geom::infinity()
** means that we haven't snapped anything.
*/
// Warnings for the devs
g_warning("Non-uniform constrained scaling is not supported!");
}
// We do not yet allow for simultaneous rotation and scaling
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
_snapindicator = false;
// std::cout << std::endl;
bool first_free_snap = true;
for (std::vector<Inkscape::SnapCandidatePoint>::const_iterator i = points.begin(); i != points.end(); ++i) {
/* Snap it */
Geom::Point const b = ((*i).getPoint() - origin); // vector to original point (not the transformed point! required for rotations!)
if (constrained) {
// When uniformly scaling, each point will have its own unique constraint line,
// running from the scaling origin to the original untransformed point. We will
// calculate that line here
} else if (transformation_type == ROTATE) {
} else if (transformation_type == TRANSLATE) {
// When doing a constrained translation, all points will move in the same direction, i.e.
// either horizontally or vertically. The lines along which they move are therefore all
// parallel, but might not be colinear. Therefore we will have to specify the point through
// which the constraint-line runs here, for each point individually. (we could also have done this
// earlier on, e.g. in seltrans.cpp but we're being lazy there and don't want to add an iteration loop)
dedicated_constraint = Inkscape::Snapper::SnapConstraint((*i).getPoint(), constraint.getDirection());
} // else: leave the original constraint, e.g. for skewing
} else {
// When scaling, a point aligned either horizontally or vertically with the origin can only
// move in that specific direction; therefore it should only snap in that direction, otherwise
// we will get snapped points with an invalid transformation
} else {
// If we have a collection of SnapCandidatePoints, with mixed constrained snapping and free snapping
// requirements, then freeSnap might never see the SnapCandidatePoint with source_num == 0. The freeSnap()
// method in the object snapper depends on this, because only for source-num == 0 the target nodes will
// be collected. Therefore we enforce that the first SnapCandidatePoint that is to be freeSnapped always
// has source_num == 0;
// TODO: This is a bit ugly so fix this; do we need sourcenum for anything else? if we don't then get rid
// of it and explicitly communicate to the object snapper that this is a first point
if (first_free_snap) {
(*j).setSourceNum(0);
first_free_snap = false;
}
}
}
// std::cout << "dist = " << snapped_point.getSnapDistance() << std::endl;
// Allow the snapindicator to be displayed again
/*Find the transformation that describes where the snapped point has
** ended up, and also the metric for this transformation.
*/
//Geom::Point const b = (*i - origin); // vector to original point
switch (transformation_type) {
case TRANSLATE:
/* 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 over 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 to an intersection 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:
{
// 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)
if (fabs(fabs(a[index]/b[index]) - fabs(transformation[index])) > 1e-7) { // if SNAPPING DID occur in this direction
}
// we might have left result[1-index] = Geom::infinity()
// if scaling didn't occur in the other direction
}
}
if (uniform) {
} else {
}
}
// Compare the resulting scaling with the desired scaling
Geom::Point scale_metric = result - transformation; // One or both of its components might be Geom::infinity()
} else {
}
break;
}
case STRETCH:
} else { // STRETCHING might occur for this point, but only when the stretching is uniform
}
}
// Store the metric for this transformation as a virtual distance
break;
case SKEW:
// Store the metric for this transformation as a virtual distance
break;
case ROTATE:
// a is vector to snapped point; b is vector to original point; now lets calculate angle between a and b
if (Geom::L2(b) < 1e-9) { // points too close to the rotation center will not move. Don't try to snap these
// as they will always yield a perfect snap result if they're already snapped beforehand (e.g.
// when the transformation center has been snapped to a grid intersection in the selector tool)
// PS1: Apparently we don't have to do this for skewing, but why?
// PS2: We cannot easily filter these points upstream, e.g. in the grab() method (seltrans.cpp)
// because the rotation center will change when pressing shift, and grab() won't be recalled.
// Filtering could be done in handleRequest() (again in seltrans.cpp), by iterating through
// the snap candidates. But hey, we're iterating here anyway.
} else {
}
break;
default:
}
if (snapped_point.getSnapped()) {
// We snapped; keep track of the best snap
}
} 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
// .. so we must keep track of the best non-snapped constrained point
}
}
}
++j;
}
if (transformation_type == SCALE) {
// When scaling, don't ever exit with one of scaling components uninitialized
} else {
}
}
}
}
// Using " < 1e6" instead of " < Geom::infinity()" for catching some rounding errors
// These rounding errors might be caused by NRRects, see bug #1584301
if (_snapindicator) {
if (best_snapped_point.getSnapped()) {
} else {
}
}
return best_snapped_point;
}
Inkscape::SnappedPoint SnapManager::freeSnapTranslate(std::vector<Inkscape::SnapCandidatePoint> const &p,
{
Inkscape::SnappedPoint result = _snapTransformed(p, pointer, false, Geom::Point(0,0), TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);
if (p.size() == 1) {
}
return result;
}
Inkscape::SnappedPoint SnapManager::constrainedSnapTranslate(std::vector<Inkscape::SnapCandidatePoint> const &p,
{
Inkscape::SnappedPoint result = _snapTransformed(p, pointer, true, constraint, TRANSLATE, tr, Geom::Point(0,0), Geom::X, false);
if (p.size() == 1) {
}
return result;
}
Inkscape::SnappedPoint SnapManager::freeSnapScale(std::vector<Inkscape::SnapCandidatePoint> const &p,
{
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) {
}
return result;
}
Inkscape::SnappedPoint SnapManager::constrainedSnapScale(std::vector<Inkscape::SnapCandidatePoint> const &p,
{
// 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) {
}
return result;
}
Inkscape::SnappedPoint SnapManager::constrainedSnapStretch(std::vector<Inkscape::SnapCandidatePoint> const &p,
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) {
}
return result;
}
Inkscape::SnappedPoint SnapManager::constrainedSnapSkew(std::vector<Inkscape::SnapCandidatePoint> const &p,
{
// "s" contains skew factor in s[0], and scale factor in s[1]
// 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
// NOT the case for example when rotating or skewing. The bounding box itself cannot possibly rotate or skew,
// so it's corners have a different transformation. The snappers cannot handle this, therefore snapping
// of bounding boxes is not allowed here.
if (!p.empty()) {
}
Inkscape::SnappedPoint result = _snapTransformed(p, pointer, true, constraint, SKEW, s, o, d, false);
if (p.size() == 1) {
}
return result;
}
Inkscape::SnappedPoint SnapManager::constrainedSnapRotate(std::vector<Inkscape::SnapCandidatePoint> const &p,
{
// 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
// NOT the case for example when rotating or skewing. The bounding box itself cannot possibly rotate or skew,
// 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) {
}
return result;
}
IntermSnapResults const &isr,
bool constrained,
bool allowOffScreen) const
{
/*
std::cout << "Type and number of snapped constraints: " << std::endl;
std::cout << " Points : " << isr.points.size() << std::endl;
std::cout << " Grid lines : " << isr.grid_lines.size()<< std::endl;
std::cout << " Guide lines : " << isr.guide_lines.size()<< std::endl;
std::cout << " Curves : " << isr.curves.size()<< std::endl;
*/
/*
// Display all snap candidates on the canvas
_desktop->snapindicator->remove_debugging_points();
for (std::list<Inkscape::SnappedPoint>::const_iterator i = isr.points.begin(); i != isr.points.end(); i++) {
_desktop->snapindicator->set_new_debugging_point((*i).getPoint());
}
for (std::list<Inkscape::SnappedCurve>::const_iterator i = isr.curves.begin(); i != isr.curves.end(); i++) {
_desktop->snapindicator->set_new_debugging_point((*i).getPoint());
}
for (std::list<Inkscape::SnappedLine>::const_iterator i = isr.grid_lines.begin(); i != isr.grid_lines.end(); i++) {
_desktop->snapindicator->set_new_debugging_point((*i).getPoint());
}
for (std::list<Inkscape::SnappedLine>::const_iterator i = isr.guide_lines.begin(); i != isr.guide_lines.end(); i++) {
_desktop->snapindicator->set_new_debugging_point((*i).getPoint());
}
*/
// Store all snappoints
// search for the closest snapped point
}
// search for the closest snapped curve
// We might have collected the paths only to snap to their intersection, without the intention to snap to the paths themselves
// Therefore we explicitly check whether the paths should be considered as snap targets themselves
}
// search for the closest snapped grid line
}
// search for the closest snapped guide line
}
// Therefore we will try get fully constrained by finding an intersection with another grid/guide/path
// When doing a constrained snap however, we're already at an intersection of the constrained line and
// no need to look for additional intersections
if (!constrained) {
// search for the closest snapped intersection of curves
if (getClosestIntersectionCS(isr.curves, p.getPoint(), closestCurvesIntersection, _desktop->dt2doc())) {
}
}
// search for the closest snapped intersection of a guide with a curve
if (getClosestIntersectionCL(isr.curves, isr.guide_lines, p.getPoint(), closestCurveGuideIntersection, _desktop->dt2doc())) {
}
}
// search for the closest snapped intersection of grid lines
}
// search for the closest snapped intersection of guide lines
}
// search for the closest snapped intersection of grid with guide lines
}
}
}
// now let's see which snapped point gets a thumbs up
// std::cout << "Finding the best snap..." << std::endl;
for (std::list<Inkscape::SnappedPoint>::const_iterator i = sp_list.begin(); i != sp_list.end(); ++i) {
// std::cout << "sp = " << (*i).getPoint() << " | source = " << (*i).getSource() << " | target = " << (*i).getTarget();
// if it's the first point, or if it is closer than the best snapped point so far
// then prefer this point over the previous one
bestSnappedPoint = *i;
}
}
}
// std::cout << std::endl;
}
// Update the snap indicator, if requested
if (_snapindicator) {
if (bestSnappedPoint.getSnapped()) {
} else {
}
}
// std::cout << "findBestSnap = " << bestSnappedPoint.getPoint() << " | dist = " << bestSnappedPoint.getSnapDistance() << std::endl;
return bestSnappedPoint;
}
bool snapindicator,
SPItem const *item_to_ignore,
{
g_warning("The snapmanager has been set up before, but unSetup() hasn't been called afterwards. It possibly held invalid pointers");
}
}
bool snapindicator,
{
g_warning("The snapmanager has been set up before, but unSetup() hasn't been called afterwards. It possibly held invalid pointers");
}
}
/// Setup, taking the list of items to ignore from the desktop's selection.
bool snapindicator,
{
// Someone has been naughty here! This is dangerous
g_warning("The snapmanager has been set up before, but unSetup() hasn't been called afterwards. It possibly held invalid pointers");
}
}
}
{
return _named_view->document;
}
bool const uniform) const
{
/* Work out the transformed version of this point */
switch (transformation_type) {
case TRANSLATE:
break;
case SCALE:
transformed = (p.getPoint() - origin) * Geom::Scale(transformation[Geom::X], transformation[Geom::Y]) + origin;
break;
case STRETCH:
{
if (uniform)
else {
}
break;
}
case SKEW:
// Apply the skew factor
transformed[dim] = (p.getPoint())[dim] + transformation[0] * ((p.getPoint())[1 - dim] - origin[1 - dim]);
// While skewing, mirroring and scaling (by integer multiples) in the opposite direction is also allowed.
// Apply that scale factor here
break;
case ROTATE:
// for rotations: transformation[0] stores the angle in radians
break;
default:
}
return transformed;
}
/**
* Mark the location of the snap source (not the snap target!) on the canvas by drawing a symbol.
*
* @param point_type Category of points to which the source point belongs: node, guide or bounding box
* @param p The transformed position of the source point, paired with an identifier of the type of the snap source.
*/
bool p_is_other = (t & Inkscape::SNAPSOURCE_OTHERS_CATEGORY) || (t & Inkscape::SNAPSOURCE_DATUMS_CATEGORY);
if (snapprefs.getSnapEnabledGlobally() && (p_is_other || (p_is_a_node && snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_NODE_CATEGORY)) || (p_is_a_bbox && snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_BBOX_CATEGORY)))) {
} else {
}
}
}
/*
Local Variables:
mode:c++
c-file-style:"stroustrup"
c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
indent-tabs-mode:nil
fill-column:99
End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :