summaryrefslogtreecommitdiffstats
path: root/src/ui
diff options
context:
space:
mode:
Diffstat (limited to 'src/ui')
-rw-r--r--src/ui/tool/curve-drag-point.cpp4
-rw-r--r--src/ui/tool/node.cpp98
-rw-r--r--src/ui/tool/path-manipulator.cpp122
-rw-r--r--src/ui/tool/path-manipulator.h12
-rw-r--r--src/ui/tools/freehand-base.cpp12
-rw-r--r--src/ui/tools/freehand-base.h2
-rw-r--r--src/ui/tools/pen-tool.cpp407
-rw-r--r--src/ui/tools/pen-tool.h28
-rw-r--r--src/ui/tools/pencil-tool.cpp22
9 files changed, 357 insertions, 350 deletions
diff --git a/src/ui/tool/curve-drag-point.cpp b/src/ui/tool/curve-drag-point.cpp
index a90dfb155..23640456e 100644
--- a/src/ui/tool/curve-drag-point.cpp
+++ b/src/ui/tool/curve-drag-point.cpp
@@ -54,7 +54,7 @@ bool CurveDragPoint::grabbed(GdkEventMotion */*event*/)
// delta is a vector equal 1/3 of distance from first to second
Geom::Point delta = (second->position() - first->position()) / 3.0;
// only update the nodes if the mode is bspline
- if(!_pm.isBSpline()){
+ if(!_pm._isBSpline()){
first->front()->move(first->front()->position() + delta);
second->back()->move(second->back()->position() - delta);
}
@@ -91,7 +91,7 @@ void CurveDragPoint::dragged(Geom::Point &new_pos, GdkEventMotion *event)
Geom::Point offset1 = (weight/(3*t*t*(1-t))) * delta;
//modified so that, if the trace is bspline, it only acts if the SHIFT key is pressed
- if(!_pm.isBSpline()){
+ if(!_pm._isBSpline()){
first->front()->move(first->front()->position() + offset0);
second->back()->move(second->back()->position() + offset1);
}else if(weight>=0.8){
diff --git a/src/ui/tool/node.cpp b/src/ui/tool/node.cpp
index 08cc6708d..aa5365265 100644
--- a/src/ui/tool/node.cpp
+++ b/src/ui/tool/node.cpp
@@ -175,9 +175,9 @@ void Handle::move(Geom::Point const &new_pos)
setPosition(new_pos);
//move the handler and its oposite the same proportion
- if(_pm().isBSpline()){
- setPosition(_pm().BSplineHandleReposition(this,this));
- this->other()->setPosition(_pm().BSplineHandleReposition(this->other(),this));
+ if(_pm()._isBSpline()){
+ setPosition(_pm()._bsplineHandleReposition(this,this));
+ this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),this));
}
return;
}
@@ -192,9 +192,9 @@ void Handle::move(Geom::Point const &new_pos)
setRelativePos(new_delta);
//move the handler and its oposite the same proportion
- if(_pm().isBSpline()){
- setPosition(_pm().BSplineHandleReposition(this,this));
- this->other()->setPosition(_pm().BSplineHandleReposition(this->other(),this));
+ if(_pm()._isBSpline()){
+ setPosition(_pm()._bsplineHandleReposition(this,this));
+ this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),this));
}
return;
@@ -218,9 +218,9 @@ void Handle::move(Geom::Point const &new_pos)
setPosition(new_pos);
// moves the handler and its oposite the same proportion
- if(_pm().isBSpline()){
- setPosition(_pm().BSplineHandleReposition(this,this));
- this->other()->setPosition(_pm().BSplineHandleReposition(this->other(),this));
+ if(_pm()._isBSpline()){
+ setPosition(_pm()._bsplineHandleReposition(this,this));
+ this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),this));
}
}
@@ -312,9 +312,9 @@ bool Handle::_eventHandler(Inkscape::UI::Tools::ToolBase *event_context, GdkEven
//this function moves the handler and its oposite to the default proportion of defaultStartPower
void Handle::handle_2button_press(){
- if(_pm().isBSpline()){
- setPosition(_pm().BSplineHandleReposition(this,defaultStartPower));
- this->other()->setPosition(_pm().BSplineHandleReposition(this->other(),defaultStartPower));
+ if(_pm()._isBSpline()){
+ setPosition(_pm()._bsplineHandleReposition(this,defaultStartPower));
+ this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),defaultStartPower));
_pm().update();
}
}
@@ -372,16 +372,16 @@ void Handle::dragged(Geom::Point &new_pos, GdkEventMotion *event)
new_pos = result;
// moves the handler and its oposite in X fixed positions depending on parameter "steps with control"
// by default in live BSpline
- if(_pm().isBSpline()){
+ if(_pm()._isBSpline()){
setPosition(new_pos);
- int steps = _pm().BSplineGetSteps();
- new_pos=_pm().BSplineHandleReposition(this,ceilf(_pm().BSplineHandlePosition(this,this)*steps)/steps);
+ int steps = _pm()._bsplineGetSteps();
+ new_pos=_pm()._bsplineHandleReposition(this,ceilf(_pm()._bsplineHandlePosition(this,this)*steps)/steps);
}
}
std::vector<Inkscape::SnapCandidatePoint> unselected;
//if the snap adjustment is activated and it is not bspline
- if (snap && !_pm().isBSpline()) {
+ if (snap && !_pm()._isBSpline()) {
ControlPointSelection::Set &nodes = _parent->_selection.allPoints();
for (ControlPointSelection::Set::iterator i = nodes.begin(); i != nodes.end(); ++i) {
Node *n = static_cast<Node*>(*i);
@@ -422,7 +422,7 @@ void Handle::dragged(Geom::Point &new_pos, GdkEventMotion *event)
}
}
//if it is bspline but SHIFT or CONTROL are not pressed it fixes it in the original position
- if(_pm().isBSpline() && !held_shift(*event) && !held_control(*event)){
+ if(_pm()._isBSpline() && !held_shift(*event) && !held_control(*event)){
new_pos=_last_drag_origin();
}
move(new_pos); // needed for correct update, even though it's redundant
@@ -486,7 +486,7 @@ Glib::ustring Handle::_getTip(unsigned state) const
// a trick to mark as bspline if the node has no strength, we are going to use it later
// to show the appropiate messages. We cannot do it in any different way becasue the function is constant
Handle *h = const_cast<Handle *>(this);
- bool isBSpline = _pm().isBSpline();
+ bool isBSpline = _pm()._isBSpline();
bool can_shift_rotate = _parent->type() == NODE_CUSP && !other()->isDegenerate();
if (can_shift_rotate && !isBSpline) {
more = C_("Path handle tip", "more: Shift, Ctrl, Alt");
@@ -549,7 +549,7 @@ Glib::ustring Handle::_getTip(unsigned state) const
"<b>Auto node handle</b>: drag to convert to smooth node (%s)"), more);
}else{
return format_tip(C_("Path handle tip",
- "<b>BSpline node handle</b>: Shift to drag, double click to reset (%s). %g power"),more,_pm().BSplineHandlePosition(h,NULL));
+ "<b>BSpline node handle</b>: Shift to drag, double click to reset (%s). %g power"),more,_pm()._bsplineHandlePosition(h,NULL));
}
}
}
@@ -633,15 +633,15 @@ void Node::move(Geom::Point const &new_pos)
Node *n = this;
Node * nextNode = n->nodeToward(n->front());
Node * prevNode = n->nodeToward(n->back());
- nodeWeight = fmax(_pm().BSplineHandlePosition(n->front()),_pm().BSplineHandlePosition(n->back()));
+ nodeWeight = fmax(_pm()._bsplineHandlePosition(n->front()),_pm()._bsplineHandlePosition(n->back()));
if(prevNode){
if(prevNode->isEndNode()){
- prevNodeWeight = _pm().BSplineHandlePosition(prevNode->front(),prevNode->front());
+ prevNodeWeight = _pm()._bsplineHandlePosition(prevNode->front(),prevNode->front());
}
}
if(nextNode){
if(nextNode->isEndNode()){
- nextNodeWeight = _pm().BSplineHandlePosition(nextNode->back(),nextNode->back());
+ nextNodeWeight = _pm()._bsplineHandlePosition(nextNode->back(),nextNode->back());
}
}
@@ -655,21 +655,21 @@ void Node::move(Geom::Point const &new_pos)
_fixNeighbors(old_pos, new_pos);
// move the affected handlers. First the node ones, later the adjoining ones.
- if(_pm().isBSpline()){
- _front.setPosition(_pm().BSplineHandleReposition(this->front(),nodeWeight));
- _back.setPosition(_pm().BSplineHandleReposition(this->back(),nodeWeight));
+ if(_pm()._isBSpline()){
+ _front.setPosition(_pm()._bsplineHandleReposition(this->front(),nodeWeight));
+ _back.setPosition(_pm()._bsplineHandleReposition(this->back(),nodeWeight));
if(prevNode){
if(prevNode->isEndNode()){
- prevNode->front()->setPosition(_pm().BSplineHandleReposition(prevNode->front(),prevNodeWeight));
+ prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNodeWeight));
}else{
- prevNode->front()->setPosition(_pm().BSplineHandleReposition(prevNode->front(),prevNode->back()));
+ prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNode->back()));
}
}
if(nextNode){
if(nextNode->isEndNode()){
- nextNode->back()->setPosition(_pm().BSplineHandleReposition(nextNode->back(),nextNodeWeight));
+ nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNodeWeight));
}else{
- nextNode->back()->setPosition(_pm().BSplineHandleReposition(nextNode->back(),nextNode->front()));
+ nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNode->front()));
}
}
}
@@ -687,15 +687,15 @@ void Node::transform(Geom::Affine const &m)
Node *n = this;
Node * nextNode = n->nodeToward(n->front());
Node * prevNode = n->nodeToward(n->back());
- nodeWeight = _pm().BSplineHandlePosition(n->front());
+ nodeWeight = _pm()._bsplineHandlePosition(n->front());
if(prevNode){
if(prevNode->isEndNode()){
- prevNodeWeight = _pm().BSplineHandlePosition(prevNode->front(),prevNode->front());
+ prevNodeWeight = _pm()._bsplineHandlePosition(prevNode->front(),prevNode->front());
}
}
if(nextNode){
if(nextNode->isEndNode()){
- nextNodeWeight = _pm().BSplineHandlePosition(nextNode->back(),nextNode->back());
+ nextNodeWeight = _pm()._bsplineHandlePosition(nextNode->back(),nextNode->back());
}
}
@@ -708,21 +708,21 @@ void Node::transform(Geom::Affine const &m)
_fixNeighbors(old_pos, position());
// move the involved handlers, first the node ones, later the adjoining ones
- if(_pm().isBSpline()){
- _front.setPosition(_pm().BSplineHandleReposition(this->front(),nodeWeight));
- _back.setPosition(_pm().BSplineHandleReposition(this->back(),nodeWeight));
+ if(_pm()._isBSpline()){
+ _front.setPosition(_pm()._bsplineHandleReposition(this->front(),nodeWeight));
+ _back.setPosition(_pm()._bsplineHandleReposition(this->back(),nodeWeight));
if(prevNode){
if(prevNode->isEndNode()){
- prevNode->front()->setPosition(_pm().BSplineHandleReposition(prevNode->front(),prevNodeWeight));
+ prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNodeWeight));
}else{
- prevNode->front()->setPosition(_pm().BSplineHandleReposition(prevNode->front(),prevNode->back()));
+ prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNode->back()));
}
}
if(nextNode){
if(nextNode->isEndNode()){
- nextNode->back()->setPosition(_pm().BSplineHandleReposition(nextNode->back(),nextNodeWeight));
+ nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNodeWeight));
}else{
- nextNode->back()->setPosition(_pm().BSplineHandleReposition(nextNode->back(),nextNode->front()));
+ nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNode->front()));
}
}
}
@@ -915,13 +915,13 @@ void Node::setType(NodeType type, bool update_handles)
}
/* in node type changes, about bspline traces, we can mantain them with noPower power in border mode,
or we give them the default power in curve mode */
- if(_pm().isBSpline()){
+ if(_pm()._isBSpline()){
double weight = noPower;
- if(_pm().BSplineHandlePosition(this->front()) != noPower ){
+ if(_pm()._bsplineHandlePosition(this->front()) != noPower ){
weight = defaultStartPower;
}
- _front.setPosition(_pm().BSplineHandleReposition(this->front(),weight));
- _back.setPosition(_pm().BSplineHandleReposition(this->back(),weight));
+ _front.setPosition(_pm()._bsplineHandleReposition(this->front(),weight));
+ _back.setPosition(_pm()._bsplineHandleReposition(this->back(),weight));
}
}
_type = type;
@@ -1171,9 +1171,9 @@ void Node::_setState(State state)
mgr.setActive(_canvas_item, true);
mgr.setPrelight(_canvas_item, false);
//this shows the handlers when selecting the nodes
- if(_pm().isBSpline()){
- this->front()->setPosition(_pm().BSplineHandleReposition(this->front()));
- this->back()->setPosition(_pm().BSplineHandleReposition(this->back()));
+ if(_pm()._isBSpline()){
+ this->front()->setPosition(_pm()._bsplineHandleReposition(this->front()));
+ this->back()->setPosition(_pm()._bsplineHandleReposition(this->back()));
}
break;
}
@@ -1433,7 +1433,7 @@ Node *Node::nodeAwayFrom(Handle *h)
Glib::ustring Node::_getTip(unsigned state) const
{
- bool isBSpline = _pm().isBSpline();
+ bool isBSpline = _pm()._isBSpline();
Handle *h = const_cast<Handle *>(&_front);
Handle *h2 = const_cast<Handle *>(&_back);
if (state_held_shift(state)) {
@@ -1470,7 +1470,7 @@ Glib::ustring Node::_getTip(unsigned state) const
"<b>%s</b>: drag to shape the path (more: Shift, Ctrl, Alt)"), nodetype);
}else if(_selection.size() == 1){
return format_tip(C_("Path node tip",
- "<b>BSpline node</b>: drag to shape the path (more: Shift, Ctrl, Alt). %g power"),_pm().BSplineHandlePosition(h,h2));
+ "<b>BSpline node</b>: drag to shape the path (more: Shift, Ctrl, Alt). %g power"),_pm()._bsplineHandlePosition(h,h2));
}
return format_tip(C_("Path node tip",
"<b>%s</b>: drag to shape the path, click to toggle scale/rotation handles (more: Shift, Ctrl, Alt)"), nodetype);
@@ -1480,7 +1480,7 @@ Glib::ustring Node::_getTip(unsigned state) const
"<b>%s</b>: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt)"), nodetype);
}else{
return format_tip(C_("Path node tip",
- "<b>BSpline node</b>: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt). %g power"),_pm().BSplineHandlePosition(h,h2));
+ "<b>BSpline node</b>: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt). %g power"),_pm()._bsplineHandlePosition(h,h2));
}
}
diff --git a/src/ui/tool/path-manipulator.cpp b/src/ui/tool/path-manipulator.cpp
index dbae69f2c..6b0c95f68 100644
--- a/src/ui/tool/path-manipulator.cpp
+++ b/src/ui/tool/path-manipulator.cpp
@@ -56,8 +56,8 @@ enum PathChange {
};
} // anonymous namespace
-const double handleCubicGap = 0.01;
-const double noPower = 0.0;
+const double HANDLE_CUBIC_GAP = 0.01;
+const double NO_POWER = 0.0;
const double defaultStartPower = 0.3334;
@@ -152,7 +152,7 @@ PathManipulator::PathManipulator(MultiPathManipulator &mpm, SPPath *path,
_createControlPointsFromGeometry();
//Define if the path is BSpline on construction
- recalculateIsBSpline();
+ _recalculateIsBSpline();
}
PathManipulator::~PathManipulator()
@@ -671,12 +671,12 @@ unsigned PathManipulator::_deleteStretch(NodeList::iterator start, NodeList::ite
start = next;
}
// if we are removing, we readjust the handlers
- if(isBSpline()){
+ if(_isBSpline()){
if(start.prev()){
- start.prev()->front()->setPosition(BSplineHandleReposition(start.prev()->front(),start.prev()->back()));
+ start.prev()->front()->setPosition(_bsplineHandleReposition(start.prev()->front(),start.prev()->back()));
}
if(end){
- end->back()->setPosition(BSplineHandleReposition(end->back(),end->front()));
+ end->back()->setPosition(_bsplineHandleReposition(end->back(),end->front()));
}
}
@@ -1000,30 +1000,30 @@ NodeList::iterator PathManipulator::subdivideSegment(NodeList::iterator first, d
// set new handle positions
Node *n = new Node(_multi_path_manipulator._path_data.node_data, seg2[0]);
- if(!isBSpline()){
+ if(!_isBSpline()){
n->back()->setPosition(seg1[2]);
n->front()->setPosition(seg2[1]);
n->setType(NODE_SMOOTH, false);
} else {
- Geom::D2< Geom::SBasis > SBasisInsideNodes;
- SPCurve *lineInsideNodes = new SPCurve();
+ Geom::D2< Geom::SBasis > sbasis_inside_nodes;
+ SPCurve *line_inside_nodes = new SPCurve();
if(second->back()->isDegenerate()){
- lineInsideNodes->moveto(n->position());
- lineInsideNodes->lineto(second->position());
- SBasisInsideNodes = lineInsideNodes->first_segment()->toSBasis();
- Geom::Point next = SBasisInsideNodes.valueAt(defaultStartPower);
- next = Geom::Point(next[Geom::X] + handleCubicGap,next[Geom::Y] + handleCubicGap);
- lineInsideNodes->reset();
+ line_inside_nodes->moveto(n->position());
+ line_inside_nodes->lineto(second->position());
+ sbasis_inside_nodes = line_inside_nodes->first_segment()->toSBasis();
+ Geom::Point next = sbasis_inside_nodes.valueAt(defaultStartPower);
+ next = Geom::Point(next[Geom::X] + HANDLE_CUBIC_GAP,next[Geom::Y] + HANDLE_CUBIC_GAP);
+ line_inside_nodes->reset();
n->front()->setPosition(next);
}else{
n->front()->setPosition(seg2[1]);
}
if(first->front()->isDegenerate()){
- lineInsideNodes->moveto(n->position());
- lineInsideNodes->lineto(first->position());
- SBasisInsideNodes = lineInsideNodes->first_segment()->toSBasis();
- Geom::Point previous = SBasisInsideNodes.valueAt(defaultStartPower);
- previous = Geom::Point(previous[Geom::X] + handleCubicGap,previous[Geom::Y] + handleCubicGap);
+ line_inside_nodes->moveto(n->position());
+ line_inside_nodes->lineto(first->position());
+ sbasis_inside_nodes = line_inside_nodes->first_segment()->toSBasis();
+ Geom::Point previous = sbasis_inside_nodes.valueAt(defaultStartPower);
+ previous = Geom::Point(previous[Geom::X] + HANDLE_CUBIC_GAP,previous[Geom::Y] + HANDLE_CUBIC_GAP);
n->back()->setPosition(previous);
}else{
n->back()->setPosition(seg1[2]);
@@ -1218,16 +1218,16 @@ void PathManipulator::_createControlPointsFromGeometry()
}
//determines if the trace has a bspline effect and the number of steps that it takes
-int PathManipulator::BSplineGetSteps() const {
+int PathManipulator::_bsplineGetSteps() const {
LivePathEffect::LPEBSpline const *lpe_bsp = NULL;
SPLPEItem * path = dynamic_cast<SPLPEItem *>(_path);
if (path){
if(path->hasPathEffect()){
- Inkscape::LivePathEffect::Effect const *thisEffect = path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE);
- if(thisEffect){
- lpe_bsp = dynamic_cast<LivePathEffect::LPEBSpline const*>(thisEffect->getLPEObj()->get_lpe());
+ Inkscape::LivePathEffect::Effect const *this_effect = path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE);
+ if(this_effect){
+ lpe_bsp = dynamic_cast<LivePathEffect::LPEBSpline const*>(this_effect->getLPEObj()->get_lpe());
}
}
}
@@ -1239,10 +1239,10 @@ int PathManipulator::BSplineGetSteps() const {
}
// determines if the trace has bspline effect
-void PathManipulator::recalculateIsBSpline(){
+void PathManipulator::_recalculateIsBSpline(){
if (SP_IS_LPE_ITEM(_path) && _path->hasPathEffect()) {
- Inkscape::LivePathEffect::Effect const *thisEffect = _path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE);
- if(thisEffect){
+ Inkscape::LivePathEffect::Effect const *this_effect = _path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE);
+ if(this_effect){
_is_bspline = true;
return;
}
@@ -1250,61 +1250,61 @@ void PathManipulator::recalculateIsBSpline(){
_is_bspline = false;
}
-bool PathManipulator::isBSpline() const {
+bool PathManipulator::_isBSpline() const {
return _is_bspline;
}
// returns the corresponding strength to the position of the handlers
-double PathManipulator::BSplineHandlePosition(Handle *h, Handle *h2)
+double PathManipulator::_bsplineHandlePosition(Handle *h, Handle *h2)
{
using Geom::X;
using Geom::Y;
if(h2){
h = h2;
}
- double pos = noPower;
+ double pos = NO_POWER;
Node *n = h->parent();
- Node * nextNode = NULL;
- nextNode = n->nodeToward(h);
- if(nextNode){
- SPCurve *lineInsideNodes = new SPCurve();
- lineInsideNodes->moveto(n->position());
- lineInsideNodes->lineto(nextNode->position());
+ Node * next_node = NULL;
+ next_node = n->nodeToward(h);
+ if(next_node){
+ SPCurve *line_inside_nodes = new SPCurve();
+ line_inside_nodes->moveto(n->position());
+ line_inside_nodes->lineto(next_node->position());
if(!are_near(h->position(), n->position())){
- pos = Geom::nearest_point(Geom::Point(h->position()[X] - handleCubicGap, h->position()[Y] - handleCubicGap), *lineInsideNodes->first_segment());
+ pos = Geom::nearest_point(Geom::Point(h->position()[X] - HANDLE_CUBIC_GAP, h->position()[Y] - HANDLE_CUBIC_GAP), *line_inside_nodes->first_segment());
}
}
- if (pos == noPower && !h2){
- return BSplineHandlePosition(h, h->other());
+ if (pos == NO_POWER && !h2){
+ return _bsplineHandlePosition(h, h->other());
}
return pos;
}
// give the location for the handler in the corresponding position
-Geom::Point PathManipulator::BSplineHandleReposition(Handle *h, Handle *h2)
+Geom::Point PathManipulator::_bsplineHandleReposition(Handle *h, Handle *h2)
{
- double pos = this->BSplineHandlePosition(h, h2);
- return BSplineHandleReposition(h,pos);
+ double pos = this->_bsplineHandlePosition(h, h2);
+ return _bsplineHandleReposition(h,pos);
}
// give the location for the handler to the specified position
-Geom::Point PathManipulator::BSplineHandleReposition(Handle *h,double pos){
+Geom::Point PathManipulator::_bsplineHandleReposition(Handle *h,double pos){
using Geom::X;
using Geom::Y;
Geom::Point ret = h->position();
Node *n = h->parent();
- Geom::D2< Geom::SBasis > SBasisInsideNodes;
- SPCurve *lineInsideNodes = new SPCurve();
- Node * nextNode = NULL;
- nextNode = n->nodeToward(h);
- if(nextNode && pos != noPower){
- lineInsideNodes->moveto(n->position());
- lineInsideNodes->lineto(nextNode->position());
- SBasisInsideNodes = lineInsideNodes->first_segment()->toSBasis();
- ret = SBasisInsideNodes.valueAt(pos);
- ret = Geom::Point(ret[X] + handleCubicGap,ret[Y] + handleCubicGap);
+ Geom::D2< Geom::SBasis > sbasis_inside_nodes;
+ SPCurve *line_inside_nodes = new SPCurve();
+ Node * next_node = NULL;
+ next_node = n->nodeToward(h);
+ if(next_node && pos != NO_POWER){
+ line_inside_nodes->moveto(n->position());
+ line_inside_nodes->lineto(next_node->position());
+ sbasis_inside_nodes = line_inside_nodes->first_segment()->toSBasis();
+ ret = sbasis_inside_nodes.valueAt(pos);
+ ret = Geom::Point(ret[X] + HANDLE_CUBIC_GAP, ret[Y] + HANDLE_CUBIC_GAP);
}else{
- if(pos == noPower){
+ if(pos == NO_POWER){
ret = n->position();
}
}
@@ -1319,7 +1319,7 @@ void PathManipulator::_createGeometryFromControlPoints(bool alert_LPE)
{
Geom::PathBuilder builder;
//Refresh if is bspline some times -think on path change selection, this value get lost
- recalculateIsBSpline();
+ _recalculateIsBSpline();
for (std::list<SubpathPtr>::iterator spi = _subpaths.begin(); spi != _subpaths.end(); ) {
SubpathPtr subpath = *spi;
if (subpath->empty()) {
@@ -1349,16 +1349,16 @@ void PathManipulator::_createGeometryFromControlPoints(bool alert_LPE)
if (alert_LPE) {
/// \todo note that _path can be an Inkscape::LivePathEffect::Effect* too, kind of confusing, rework member naming?
if (SP_IS_LPE_ITEM(_path) && _path->hasPathEffect()) {
- Inkscape::LivePathEffect::Effect* thisEffect = _path->getPathEffectOfType(Inkscape::LivePathEffect::POWERSTROKE);
- if(thisEffect){
- LivePathEffect::LPEPowerStroke *lpe_pwr = dynamic_cast<LivePathEffect::LPEPowerStroke*>(thisEffect->getLPEObj()->get_lpe());
+ Inkscape::LivePathEffect::Effect* this_effect = _path->getPathEffectOfType(Inkscape::LivePathEffect::POWERSTROKE);
+ if(this_effect){
+ LivePathEffect::LPEPowerStroke *lpe_pwr = dynamic_cast<LivePathEffect::LPEPowerStroke*>(this_effect->getLPEObj()->get_lpe());
if (lpe_pwr) {
lpe_pwr->adjustForNewPath(pathv);
}
}
- thisEffect = _path->getPathEffectOfType(Inkscape::LivePathEffect::FILLET_CHAMFER);
- if(thisEffect){
- LivePathEffect::LPEFilletChamfer *lpe_fll = dynamic_cast<LivePathEffect::LPEFilletChamfer*>(thisEffect->getLPEObj()->get_lpe());
+ this_effect = _path->getPathEffectOfType(Inkscape::LivePathEffect::FILLET_CHAMFER);
+ if(this_effect){
+ LivePathEffect::LPEFilletChamfer *lpe_fll = dynamic_cast<LivePathEffect::LPEFilletChamfer*>(this_effect->getLPEObj()->get_lpe());
if (lpe_fll) {
lpe_fll->adjustForNewPath(pathv);
}
diff --git a/src/ui/tool/path-manipulator.h b/src/ui/tool/path-manipulator.h
index 6dc1c9d09..2219af849 100644
--- a/src/ui/tool/path-manipulator.h
+++ b/src/ui/tool/path-manipulator.h
@@ -96,7 +96,7 @@ public:
NodeList::iterator extremeNode(NodeList::iterator origin, bool search_selected,
bool search_unselected, bool closest);
- int BSplineGetSteps() const;
+ int _bsplineGetSteps() const;
// this is necessary for Tab-selection in MultiPathManipulator
SubpathList &subpathList() { return _subpaths; }
@@ -107,11 +107,11 @@ private:
void _createControlPointsFromGeometry();
- void recalculateIsBSpline();
- bool isBSpline() const;
- double BSplineHandlePosition(Handle *h, Handle *h2 = NULL);
- Geom::Point BSplineHandleReposition(Handle *h, Handle *h2 = NULL);
- Geom::Point BSplineHandleReposition(Handle *h, double pos);
+ void _recalculateIsBSpline();
+ bool _isBSpline() const;
+ double _bsplineHandlePosition(Handle *h, Handle *h2 = NULL);
+ Geom::Point _bsplineHandleReposition(Handle *h, Handle *h2 = NULL);
+ Geom::Point _bsplineHandleReposition(Handle *h, double pos);
void _createGeometryFromControlPoints(bool alert_LPE = false);
unsigned _deleteStretch(NodeList::iterator first, NodeList::iterator last, bool keep_shape);
std::string _createTypeString();
diff --git a/src/ui/tools/freehand-base.cpp b/src/ui/tools/freehand-base.cpp
index 096957be0..9aa6c9589 100644
--- a/src/ui/tools/freehand-base.cpp
+++ b/src/ui/tools/freehand-base.cpp
@@ -93,7 +93,7 @@ FreehandBase::FreehandBase(gchar const *const *cursor_shape, gint hot_x, gint ho
, white_item(NULL)
, white_curves(NULL)
, white_anchors(NULL)
- , overwriteCurve(NULL)
+ , overwrite_curve(NULL)
, sa(NULL)
, ea(NULL)
, waiting_LPE_type(Inkscape::LivePathEffect::INVALID_LPE)
@@ -150,7 +150,7 @@ void FreehandBase::setup() {
this->green_closed = FALSE;
// Create start anchor alternative curve
- this->overwriteCurve = new SPCurve();
+ this->overwrite_curve = new SPCurve();
this->attach = TRUE;
spdc_attach_selection(this, this->selection);
@@ -632,12 +632,12 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed)
}
if(prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 1 ||
prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 2){
- dc->overwriteCurve->append_continuous(c, 0.0625);
+ dc->overwrite_curve->append_continuous(c, 0.0625);
c->unref();
- dc->overwriteCurve->closepath_current();
+ dc->overwrite_curve->closepath_current();
if(dc->sa){
dc->white_curves = g_slist_remove(dc->white_curves, dc->sa->curve);
- dc->white_curves = g_slist_append(dc->white_curves, dc->overwriteCurve);
+ dc->white_curves = g_slist_append(dc->white_curves, dc->overwrite_curve);
}
}else{
dc->sa->curve->append_continuous(c, 0.0625);
@@ -654,7 +654,7 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed)
dc->white_curves = g_slist_remove(dc->white_curves, s);
if(prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 1 ||
prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 2){
- s = dc->overwriteCurve;
+ s = dc->overwrite_curve;
}
if (dc->sa->start) {
s = reverse_then_unref(s);
diff --git a/src/ui/tools/freehand-base.h b/src/ui/tools/freehand-base.h
index 6b4265215..a3e7b42f9 100644
--- a/src/ui/tools/freehand-base.h
+++ b/src/ui/tools/freehand-base.h
@@ -78,7 +78,7 @@ public:
//ALternative curve to use on continuing exisiting curve in case of bspline or spirolive
//because usigh anchor curves give memory and random bugs, - and obscure code- in some plataform reported by su_v in mac
- SPCurve *overwriteCurve;
+ SPCurve *overwrite_curve;
// Start anchor
SPDrawAnchor *sa;
diff --git a/src/ui/tools/pen-tool.cpp b/src/ui/tools/pen-tool.cpp
index d5f501163..daffc7032 100644
--- a/src/ui/tools/pen-tool.cpp
+++ b/src/ui/tools/pen-tool.cpp
@@ -85,7 +85,7 @@ namespace Tools {
static Geom::Point pen_drag_origin_w(0, 0);
static bool pen_within_tolerance = false;
static int pen_last_paraxial_dir = 0; // last used direction in horizontal/vertical mode; 0 = horizontal, 1 = vertical
-const double handleCubicGap = 0.01;
+const double HANDLE_CUBIC_GAP = 0.01;
const std::string& PenTool::getPrefsPath() {
return PenTool::prefsPath;
@@ -165,17 +165,17 @@ void PenTool::setPolylineMode() {
this->polylines_paraxial = (mode == 4);
//we call the function which defines the Spiro modes and the BSpline
//todo: merge to one function only
- this->_pen_context_set_mode(mode);
+ this->_penContextSetMode(mode);
}
/*
*.Set the mode of draw spiro, and bsplines
*/
-void PenTool::_pen_context_set_mode(guint mode) {
+void PenTool::_penContextSetMode(guint mode) {
// define the nodes
this->spiro = (mode == 1);
this->bspline = (mode == 2);
- this->_bspline_spiro_color();
+ this->_bsplineSpiroColor();
}
/**
@@ -429,7 +429,7 @@ bool PenTool::_handleButtonPress(GdkEventButton const &bevent) {
// This is allowed, if we just canceled curve
case PenTool::POINT:
if (this->npoints == 0) {
- this->_bspline_spiro_color();
+ this->_bsplineSpiroColor();
Geom::Point p;
if ((bevent.state & GDK_CONTROL_MASK) && (this->polylines_only || this->polylines_paraxial)) {
p = event_dt;
@@ -451,7 +451,7 @@ bool PenTool::_handleButtonPress(GdkEventButton const &bevent) {
this->sa = anchor;
if(anchor){
- this->_bspline_spiro_start_anchor(bevent.state & GDK_SHIFT_MASK);
+ this->_bsplineSpiroStartAnchor(bevent.state & GDK_SHIFT_MASK);
}
if (anchor && (!this->hasWaitingLPE()|| this->bspline || this->spiro)) {
// Adjust point to anchor if needed; if we have a waiting LPE, we need
@@ -700,10 +700,10 @@ bool PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
}
// calls the function "bspline_spiro_motion" when the mouse starts or stops moving
if(this->bspline){
- this->_bspline_spiro_motion(mevent.state & GDK_SHIFT_MASK);
+ this->_bsplineSpiroMotion(mevent.state & GDK_SHIFT_MASK);
}else{
if ( Geom::LInfty( event_w - pen_drag_origin_w ) > (tolerance/2) || mevent.time == 0) {
- this->_bspline_spiro_motion(mevent.state & GDK_SHIFT_MASK);
+ this->_bsplineSpiroMotion(mevent.state & GDK_SHIFT_MASK);
pen_drag_origin_w = event_w;
}
}
@@ -742,7 +742,7 @@ bool PenTool::_handleButtonRelease(GdkEventButton const &revent) {
case PenTool::POINT:
if ( this->npoints == 0 ) {
// Start new thread only with button release
- this->_bspline_spiro_color();
+ this->_bsplineSpiroColor();
if (anchor) {
p = anchor->dp;
}
@@ -750,7 +750,7 @@ bool PenTool::_handleButtonRelease(GdkEventButton const &revent) {
// continue the existing curve
if (anchor) {
if(this->bspline || this->spiro){
- this->_bspline_spiro_start_anchor(revent.state & GDK_SHIFT_MASK);;
+ this->_bsplineSpiroStartAnchor(revent.state & GDK_SHIFT_MASK);;
}
}
this->_setInitialPoint(p);
@@ -879,11 +879,11 @@ void PenTool::_redrawAll() {
this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data);
}
// one canvas bpath for all of green_curve
- SPCanvasItem *cshape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve);
- sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
- sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(cshape), 0, SP_WIND_RULE_NONZERO);
+ SPCanvasItem *canvas_shape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve);
+ sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvas_shape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+ sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvas_shape), 0, SP_WIND_RULE_NONZERO);
- this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape);
+ this->green_bpaths = g_slist_prepend(this->green_bpaths, canvas_shape);
}
if (this->green_anchor)
SP_CTRL(this->green_anchor->ctrl)->moveto(this->green_anchor->dp);
@@ -925,7 +925,7 @@ void PenTool::_redrawAll() {
// simply redraw the spiro. because its a redrawing, we don't call the global function,
// but we call the redrawing at the ending.
- this->_bspline_spiro_build();
+ this->_bsplineSpiroBuild();
}
void PenTool::_lastpointMove(gdouble x, gdouble y) {
@@ -1001,7 +1001,7 @@ void PenTool::_lastpointToCurve() {
}
//if the last node is an union with another curve
if (this->green_curve->is_empty() && this->sa && !this->sa->curve->is_empty()) {
- this->_bspline_spiro_start_anchor(false);
+ this->_bsplineSpiroStartAnchor(false);
}
}
@@ -1048,7 +1048,7 @@ void PenTool::_lastpointToLine() {
}
// if the last node is an union with another curve
if(this->green_curve->is_empty() && this->sa && !this->sa->curve->is_empty()){
- this->_bspline_spiro_start_anchor(true);
+ this->_bsplineSpiroStartAnchor(true);
}
}
@@ -1312,7 +1312,7 @@ void PenTool::_setAngleDistanceStatusMessage(Geom::Point const p, int pc_point_t
}
// this function changes the colors red, green and blue making them transparent or not, depending on if spiro is being used.
-void PenTool::_bspline_spiro_color()
+void PenTool::_bsplineSpiroColor()
{
static Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if(this->spiro){
@@ -1346,25 +1346,25 @@ void PenTool::_bspline_spiro_color()
this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data);
}
// one canvas bpath for all of green_curve
- SPCanvasItem *cshape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve);
- sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
- sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(cshape), 0, SP_WIND_RULE_NONZERO);
- this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape);
+ SPCanvasItem *canvas_shape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve);
+ sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvas_shape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+ sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvas_shape), 0, SP_WIND_RULE_NONZERO);
+ this->green_bpaths = g_slist_prepend(this->green_bpaths, canvas_shape);
}
sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(this->red_bpath), this->red_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
}
-void PenTool::_bspline_spiro(bool shift)
+void PenTool::_bsplineSpiro(bool shift)
{
if(!this->spiro && !this->bspline)
return;
- shift?this->_bspline_spiro_off():this->_bspline_spiro_on();
- this->_bspline_spiro_build();
+ shift?this->_bsplineSpiroOff():this->_bsplineSpiroOn();
+ this->_bsplineSpiroBuild();
}
-void PenTool::_bspline_spiro_on()
+void PenTool::_bsplineSpiroOn()
{
if(!this->red_curve->is_empty()){
using Geom::X;
@@ -1373,11 +1373,11 @@ void PenTool::_bspline_spiro_on()
this->p[0] = this->red_curve->first_segment()->initialPoint();
this->p[3] = this->red_curve->first_segment()->finalPoint();
this->p[2] = this->p[3] + (1./3)*(this->p[0] - this->p[3]);
- this->p[2] = Geom::Point(this->p[2][X] + handleCubicGap,this->p[2][Y] + handleCubicGap);
+ this->p[2] = Geom::Point(this->p[2][X] + HANDLE_CUBIC_GAP,this->p[2][Y] + HANDLE_CUBIC_GAP);
}
}
-void PenTool::_bspline_spiro_off()
+void PenTool::_bsplineSpiroOff()
{
if(!this->red_curve->is_empty()){
this->npoints = 5;
@@ -1387,7 +1387,7 @@ void PenTool::_bspline_spiro_off()
}
}
-void PenTool::_bspline_spiro_start_anchor(bool shift)
+void PenTool::_bsplineSpiroStartAnchor(bool shift)
{
if(this->sa->curve->is_empty()){
return;
@@ -1423,73 +1423,73 @@ void PenTool::_bspline_spiro_start_anchor(bool shift)
return;
if(shift)
- this->_bspline_spiro_start_anchor_off();
+ this->_bsplineSpiroStartAnchorOff();
else
- this->_bspline_spiro_start_anchor_on();
+ this->_bsplineSpiroStartAnchorOn();
}
-void PenTool::_bspline_spiro_start_anchor_on()
+void PenTool::_bsplineSpiroStartAnchorOn()
{
using Geom::X;
using Geom::Y;
- SPCurve *tmpCurve = new SPCurve();
- tmpCurve = this->sa->curve->copy();
+ SPCurve *tmp_curve = new SPCurve();
+ tmp_curve = this->sa->curve->copy();
if(this->sa->start)
- tmpCurve = tmpCurve->create_reverse();
- Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmpCurve->last_segment());
- SPCurve *lastSeg = new SPCurve();
- Geom::Point A = tmpCurve->last_segment()->initialPoint();
- Geom::Point D = tmpCurve->last_segment()->finalPoint();
- Geom::Point C = D + (1./3)*(A - D);
- C = Geom::Point(C[X] + handleCubicGap,C[Y] + handleCubicGap);
+ tmp_curve = tmp_curve ->create_reverse();
+ Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmp_curve ->last_segment());
+ SPCurve *last_segment = new SPCurve();
+ Geom::Point point_a = tmp_curve ->last_segment()->initialPoint();
+ Geom::Point point_d = tmp_curve ->last_segment()->finalPoint();
+ Geom::Point point_c = point_d + (1./3)*(point_a - point_d);
+ point_c = Geom::Point(point_c[X] + HANDLE_CUBIC_GAP, point_c[Y] + HANDLE_CUBIC_GAP);
if(cubic){
- lastSeg->moveto(A);
- lastSeg->curveto((*cubic)[1],C,D);
+ last_segment->moveto(point_a);
+ last_segment->curveto((*cubic)[1],point_c,point_d);
}else{
- lastSeg->moveto(A);
- lastSeg->curveto(A,C,D);
+ last_segment->moveto(point_a);
+ last_segment->curveto(point_a,point_c,point_d);
}
- if( tmpCurve->get_segment_count() == 1){
- tmpCurve = lastSeg;
+ if( tmp_curve ->get_segment_count() == 1){
+ tmp_curve = last_segment;
}else{
//we eliminate the last segment
- tmpCurve->backspace();
+ tmp_curve ->backspace();
//and we add it again with the recreation
- tmpCurve->append_continuous(lastSeg, 0.0625);
+ tmp_curve ->append_continuous(last_segment, 0.0625);
}
if (this->sa->start) {
- tmpCurve = tmpCurve->create_reverse();
+ tmp_curve = tmp_curve ->create_reverse();
}
- this->overwriteCurve = tmpCurve;
+ this->overwrite_curve = tmp_curve ;
}
-void PenTool::_bspline_spiro_start_anchor_off()
+void PenTool::_bsplineSpiroStartAnchorOff()
{
- SPCurve *tmpCurve = new SPCurve();
- tmpCurve = this->sa->curve->copy();
+ SPCurve *tmp_curve = new SPCurve();
+ tmp_curve = this->sa->curve->copy();
if(this->sa->start)
- tmpCurve = tmpCurve->create_reverse();
- Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmpCurve->last_segment());
+ tmp_curve = tmp_curve ->create_reverse();
+ Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmp_curve ->last_segment());
if(cubic){
- SPCurve *lastSeg = new SPCurve();
- lastSeg->moveto((*cubic)[0]);
- lastSeg->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]);
- if( tmpCurve->get_segment_count() == 1){
- tmpCurve = lastSeg;
+ SPCurve *last_segment = new SPCurve();
+ last_segment->moveto((*cubic)[0]);
+ last_segment->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]);
+ if( tmp_curve ->get_segment_count() == 1){
+ tmp_curve = last_segment;
}else{
//we eliminate the last segment
- tmpCurve->backspace();
+ tmp_curve ->backspace();
//and we add it again with the recreation
- tmpCurve->append_continuous(lastSeg, 0.0625);
+ tmp_curve ->append_continuous(last_segment, 0.0625);
}
}
if (this->sa->start) {
- tmpCurve = tmpCurve->create_reverse();
+ tmp_curve = tmp_curve ->create_reverse();
}
- this->overwriteCurve = tmpCurve;
+ this->overwrite_curve = tmp_curve ;
}
-void PenTool::_bspline_spiro_motion(bool shift){
+void PenTool::_bsplineSpiroMotion(bool shift){
if(!this->spiro && !this->bspline)
return;
@@ -1497,40 +1497,40 @@ void PenTool::_bspline_spiro_motion(bool shift){
using Geom::Y;
if(this->red_curve->is_empty()) return;
this->npoints = 5;
- SPCurve *tmpCurve = new SPCurve();
+ SPCurve *tmp_curve = new SPCurve();
this->p[2] = this->p[3] + (1./3)*(this->p[0] - this->p[3]);
- this->p[2] = Geom::Point(this->p[2][X] + handleCubicGap,this->p[2][Y] + handleCubicGap);
+ this->p[2] = Geom::Point(this->p[2][X] + HANDLE_CUBIC_GAP,this->p[2][Y] + HANDLE_CUBIC_GAP);
if(this->green_curve->is_empty() && !this->sa){
this->p[1] = this->p[0] + (1./3)*(this->p[3] - this->p[0]);
- this->p[1] = Geom::Point(this->p[1][X] + handleCubicGap,this->p[1][Y] + handleCubicGap);
+ this->p[1] = Geom::Point(this->p[1][X] + HANDLE_CUBIC_GAP,this->p[1][Y] + HANDLE_CUBIC_GAP);
if(shift){
this->p[2] = this->p[3];
}
}else if(!this->green_curve->is_empty()){
- tmpCurve = this->green_curve->copy();
+ tmp_curve = this->green_curve->copy();
}else{
- tmpCurve = this->overwriteCurve->copy();
+ tmp_curve = this->overwrite_curve->copy();
if(this->sa->start)
- tmpCurve = tmpCurve->create_reverse();
+ tmp_curve = tmp_curve ->create_reverse();
}
- if(!tmpCurve->is_empty()){
- Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmpCurve->last_segment());
+ if(!tmp_curve ->is_empty()){
+ Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmp_curve ->last_segment());
if(cubic){
if(this->bspline){
- SPCurve * WPower = new SPCurve();
- Geom::D2< Geom::SBasis > SBasisWPower;
- WPower->moveto(tmpCurve->last_segment()->finalPoint());
- WPower->lineto(tmpCurve->last_segment()->initialPoint());
- float WP = Geom::nearest_point((*cubic)[2],*WPower->first_segment());
- WPower->reset();
- WPower->moveto(this->red_curve->last_segment()->initialPoint());
- WPower->lineto(this->red_curve->last_segment()->finalPoint());
- SBasisWPower = WPower->first_segment()->toSBasis();
- WPower->reset();
- this->p[1] = SBasisWPower.valueAt(WP);
+ SPCurve * weight_power = new SPCurve();
+ Geom::D2< Geom::SBasis > SBasisweight_power;
+ weight_power->moveto(tmp_curve ->last_segment()->finalPoint());
+ weight_power->lineto(tmp_curve ->last_segment()->initialPoint());
+ float WP = Geom::nearest_point((*cubic)[2],*weight_power->first_segment());
+ weight_power->reset();
+ weight_power->moveto(this->red_curve->last_segment()->initialPoint());
+ weight_power->lineto(this->red_curve->last_segment()->finalPoint());
+ SBasisweight_power = weight_power->first_segment()->toSBasis();
+ weight_power->reset();
+ this->p[1] = SBasisweight_power.valueAt(WP);
if(!Geom::are_near(this->p[1],this->p[0])){
- this->p[1] = Geom::Point(this->p[1][X] + handleCubicGap,this->p[1][Y] + handleCubicGap);
+ this->p[1] = Geom::Point(this->p[1][X] + HANDLE_CUBIC_GAP,this->p[1][Y] + HANDLE_CUBIC_GAP);
} else {
this->p[1] = this->p[0];
}
@@ -1548,129 +1548,129 @@ void PenTool::_bspline_spiro_motion(bool shift){
if(this->anchor_statusbar && !this->red_curve->is_empty()){
if(shift){
- this->_bspline_spiro_end_anchor_off();
+ this->_bsplineSpiroEndAnchorOff();
}else{
- this->_bspline_spiro_end_anchor_on();
+ this->_bsplineSpiroEndAnchorOn();
}
}
- this->_bspline_spiro_build();
+ this->_bsplineSpiroBuild();
}
-void PenTool::_bspline_spiro_end_anchor_on()
+void PenTool::_bsplineSpiroEndAnchorOn()
{
using Geom::X;
using Geom::Y;
this->p[2] = this->p[3] + (1./3)*(this->p[0] - this->p[3]);
- this->p[2] = Geom::Point(this->p[2][X] + handleCubicGap,this->p[2][Y] + handleCubicGap);
- SPCurve *tmpCurve = new SPCurve();
- SPCurve *lastSeg = new SPCurve();
- Geom::Point C(0,0);
+ this->p[2] = Geom::Point(this->p[2][X] + HANDLE_CUBIC_GAP,this->p[2][Y] + HANDLE_CUBIC_GAP);
+ SPCurve *tmp_curve = new SPCurve();
+ SPCurve *last_segment = new SPCurve();
+ Geom::Point point_c(0,0);
bool reverse = false;
if( this->green_anchor && this->green_anchor->active ){
- tmpCurve = this->green_curve->create_reverse();
+ tmp_curve = this->green_curve->create_reverse();
if(this->green_curve->get_segment_count()==0){
return;
}
reverse = true;
} else if(this->sa){
- tmpCurve = this->overwriteCurve->copy();
+ tmp_curve = this->overwrite_curve->copy();
if(!this->sa->start){
- tmpCurve = tmpCurve->create_reverse();
+ tmp_curve = tmp_curve ->create_reverse();
reverse = true;
}
}else{
return;
}
- Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmpCurve->last_segment());
+ Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmp_curve ->last_segment());
if(this->bspline){
- C = tmpCurve->last_segment()->finalPoint() + (1./3)*(tmpCurve->last_segment()->initialPoint() - tmpCurve->last_segment()->finalPoint());
- C = Geom::Point(C[X] + handleCubicGap,C[Y] + handleCubicGap);
+ point_c = tmp_curve ->last_segment()->finalPoint() + (1./3)*(tmp_curve ->last_segment()->initialPoint() - tmp_curve ->last_segment()->finalPoint());
+ point_c = Geom::Point(point_c[X] + HANDLE_CUBIC_GAP, point_c[Y] + HANDLE_CUBIC_GAP);
}else{
- C = this->p[3] + this->p[3] - this->p[2];
+ point_c = this->p[3] + this->p[3] - this->p[2];
}
if(cubic){
- lastSeg->moveto((*cubic)[0]);
- lastSeg->curveto((*cubic)[1],C,(*cubic)[3]);
+ last_segment->moveto((*cubic)[0]);
+ last_segment->curveto((*cubic)[1],point_c,(*cubic)[3]);
}else{
- lastSeg->moveto(tmpCurve->last_segment()->initialPoint());
- lastSeg->lineto(tmpCurve->last_segment()->finalPoint());
+ last_segment->moveto(tmp_curve ->last_segment()->initialPoint());
+ last_segment->lineto(tmp_curve ->last_segment()->finalPoint());
}
- if( tmpCurve->get_segment_count() == 1){
- tmpCurve = lastSeg;
+ if( tmp_curve ->get_segment_count() == 1){
+ tmp_curve = last_segment;
}else{
//we eliminate the last segment
- tmpCurve->backspace();
+ tmp_curve ->backspace();
//and we add it again with the recreation
- tmpCurve->append_continuous(lastSeg, 0.0625);
+ tmp_curve ->append_continuous(last_segment, 0.0625);
}
if (reverse) {
- tmpCurve = tmpCurve->create_reverse();
+ tmp_curve = tmp_curve ->create_reverse();
}
if( this->green_anchor && this->green_anchor->active )
{
this->green_curve->reset();
- this->green_curve = tmpCurve;
+ this->green_curve = tmp_curve ;
}else{
- this->overwriteCurve->reset();
- this->overwriteCurve = tmpCurve;
+ this->overwrite_curve->reset();
+ this->overwrite_curve = tmp_curve ;
}
}
-void PenTool::_bspline_spiro_end_anchor_off()
+void PenTool::_bsplineSpiroEndAnchorOff()
{
- SPCurve *tmpCurve = new SPCurve();
- SPCurve *lastSeg = new SPCurve();
+ SPCurve *tmp_curve = new SPCurve();
+ SPCurve *last_segment = new SPCurve();
bool reverse = false;
this->p[2] = this->p[3];
if( this->green_anchor && this->green_anchor->active ){
- tmpCurve = this->green_curve->create_reverse();
+ tmp_curve = this->green_curve->create_reverse();
if(this->green_curve->get_segment_count()==0){
return;
}
reverse = true;
} else if(this->sa){
- tmpCurve = this->overwriteCurve->copy();
+ tmp_curve = this->overwrite_curve->copy();
if(!this->sa->start){
- tmpCurve = tmpCurve->create_reverse();
+ tmp_curve = tmp_curve ->create_reverse();
reverse = true;
}
}else{
return;
}
- Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmpCurve->last_segment());
+ Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmp_curve ->last_segment());
if(cubic){
- lastSeg->moveto((*cubic)[0]);
- lastSeg->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]);
+ last_segment->moveto((*cubic)[0]);
+ last_segment->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]);
}else{
- lastSeg->moveto(tmpCurve->last_segment()->initialPoint());
- lastSeg->lineto(tmpCurve->last_segment()->finalPoint());
+ last_segment->moveto(tmp_curve ->last_segment()->initialPoint());
+ last_segment->lineto(tmp_curve ->last_segment()->finalPoint());
}
- if( tmpCurve->get_segment_count() == 1){
- tmpCurve = lastSeg;
+ if( tmp_curve ->get_segment_count() == 1){
+ tmp_curve = last_segment;
}else{
//we eliminate the last segment
- tmpCurve->backspace();
+ tmp_curve ->backspace();
//and we add it again with the recreation
- tmpCurve->append_continuous(lastSeg, 0.0625);
+ tmp_curve ->append_continuous(last_segment, 0.0625);
}
if (reverse) {
- tmpCurve = tmpCurve->create_reverse();
+ tmp_curve = tmp_curve ->create_reverse();
}
if( this->green_anchor && this->green_anchor->active )
{
this->green_curve->reset();
- this->green_curve = tmpCurve;
+ this->green_curve = tmp_curve ;
}else{
- this->overwriteCurve->reset();
- this->overwriteCurve = tmpCurve;
+ this->overwrite_curve->reset();
+ this->overwrite_curve = tmp_curve ;
}
}
//prepares the curves for its transformation into BSpline curve.
-void PenTool::_bspline_spiro_build()
+void PenTool::_bsplineSpiroBuild()
{
if(!this->spiro && !this->bspline){
return;
@@ -1680,7 +1680,7 @@ void PenTool::_bspline_spiro_build()
SPCurve *curve = new SPCurve();
//If we continuate the existing curve we add it at the start
if(this->sa && !this->sa->curve->is_empty()){
- curve = this->overwriteCurve->copy();
+ curve = this->overwrite_curve->copy();
if (this->sa->start) {
curve = curve->create_reverse();
}
@@ -1715,9 +1715,9 @@ void PenTool::_bspline_spiro_build()
//Effect *spr = static_cast<Effect*> ( new LPEbspline(lpeobj) );
//spr->doEffect(curve);
if(this->bspline){
- this->_bspline_doEffect(curve);
+ this->_bsplineDoEffect(curve);
}else{
- this->_spiro_doEffect(curve);
+ this->_spiroDoEffect(curve);
}
sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->blue_bpath), curve);
@@ -1741,66 +1741,73 @@ void PenTool::_bspline_spiro_build()
}
}
-void PenTool::_bspline_doEffect(SPCurve * curve)
+//from LPE BSPLINE:
+void PenTool::_bsplineDoEffect(SPCurve * curve)
{
- // commenting the function doEffect in src/live_effects/lpe-bspline.cpp
- if (curve->get_segment_count() < 1){
+ const double NO_POWER = 0.0;
+ const double DEFAULT_START_POWER = 0.3334;
+ const double DEFAULT_END_POWER = 0.6667;
+ if (curve->get_segment_count() < 1) {
return;
}
// Make copy of old path as it is changed during processing
Geom::PathVector const original_pathv = curve->get_pathvector();
+
curve->reset();
- //Recorremos todos los paths a los que queremos aplicar el efecto, hasta el
- //penúltimo
for (Geom::PathVector::const_iterator path_it = original_pathv.begin();
path_it != original_pathv.end(); ++path_it) {
- //Si está vacío...
- if (path_it->empty())
+ if (path_it->empty()) {
continue;
- //Itreadores
-
+ }
Geom::Path::const_iterator curve_it1 = path_it->begin();
Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
- Geom::Path::const_iterator curve_endit = path_it->end_default();
- SPCurve *nCurve = new SPCurve();
+ Geom::Path::const_iterator curve_endit = path_it->end_default();
+ SPCurve *curve_n = new SPCurve();
Geom::Point previousNode(0, 0);
Geom::Point node(0, 0);
- Geom::Point pointAt1(0, 0);
- Geom::Point pointAt2(0, 0);
- Geom::Point nextPointAt1(0, 0);
- Geom::D2<Geom::SBasis> SBasisIn;
- Geom::D2<Geom::SBasis> SBasisOut;
- Geom::D2<Geom::SBasis> SBasisHelper;
+ Geom::Point point_at1(0, 0);
+ Geom::Point point_at2(0, 0);
+ Geom::Point next_point_at1(0, 0);
+ Geom::D2<Geom::SBasis> sbasis_in;
+ Geom::D2<Geom::SBasis> sbasis_out;
+ Geom::D2<Geom::SBasis> sbasis_helper;
Geom::CubicBezier const *cubic = NULL;
if (path_it->closed()) {
+ // if the path is closed, maybe we have to stop a bit earlier because the
+ // closing line segment has zerolength.
const Geom::Curve &closingline =
path_it->back_closed(); // the closing line segment is always of type
+ // Geom::LineSegment.
if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
+ // closingline.isDegenerate() did not work, because it only checks for
+ // *exact* zero length, which goes wrong for relative coordinates and
+ // rounding errors...
+ // the closing line segment has zero-length. So stop before that one!
curve_endit = path_it->end_open();
}
}
- nCurve->moveto(curve_it1->initialPoint());
+ curve_n->moveto(curve_it1->initialPoint());
while (curve_it1 != curve_endit) {
SPCurve *in = new SPCurve();
in->moveto(curve_it1->initialPoint());
in->lineto(curve_it1->finalPoint());
cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
if (cubic) {
- SBasisIn = in->first_segment()->toSBasis();
+ sbasis_in = in->first_segment()->toSBasis();
if(are_near((*cubic)[1],(*cubic)[0]) && !are_near((*cubic)[2],(*cubic)[3])) {
- pointAt1 = SBasisIn.valueAt(0.3334);
+ point_at1 = sbasis_in.valueAt(DEFAULT_START_POWER);
} else {
- pointAt1 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[1], *in->first_segment()));
+ point_at1 = sbasis_in.valueAt(Geom::nearest_point((*cubic)[1], *in->first_segment()));
}
if(are_near((*cubic)[2],(*cubic)[3]) && !are_near((*cubic)[1],(*cubic)[0])) {
- pointAt2 = SBasisIn.valueAt(0.6667);
+ point_at2 = sbasis_in.valueAt(DEFAULT_END_POWER);
} else {
- pointAt2 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[2], *in->first_segment()));
+ point_at2 = sbasis_in.valueAt(Geom::nearest_point((*cubic)[2], *in->first_segment()));
}
} else {
- pointAt1 = in->first_segment()->initialPoint();
- pointAt2 = in->first_segment()->finalPoint();
+ point_at1 = in->first_segment()->initialPoint();
+ point_at2 = in->first_segment()->finalPoint();
}
in->reset();
delete in;
@@ -1810,31 +1817,30 @@ void PenTool::_bspline_doEffect(SPCurve * curve)
out->lineto(curve_it2->finalPoint());
cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it2);
if (cubic) {
- SBasisOut = out->first_segment()->toSBasis();
+ sbasis_out = out->first_segment()->toSBasis();
if(are_near((*cubic)[1],(*cubic)[0]) && !are_near((*cubic)[2],(*cubic)[3])) {
- nextPointAt1 = SBasisIn.valueAt(0.3334);
+ next_point_at1 = sbasis_in.valueAt(DEFAULT_START_POWER);
} else {
- nextPointAt1 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[1], *out->first_segment()));
+ next_point_at1 = sbasis_out.valueAt(Geom::nearest_point((*cubic)[1], *out->first_segment()));
}
} else {
- nextPointAt1 = out->first_segment()->initialPoint();
+ next_point_at1 = out->first_segment()->initialPoint();
}
out->reset();
delete out;
}
- Geom::Point startNode = path_it->begin()->initialPoint();
if (path_it->closed() && curve_it2 == curve_endit) {
SPCurve *start = new SPCurve();
start->moveto(path_it->begin()->initialPoint());
start->lineto(path_it->begin()->finalPoint());
- Geom::D2<Geom::SBasis> SBasisStart = start->first_segment()->toSBasis();
- SPCurve *lineHelper = new SPCurve();
+ Geom::D2<Geom::SBasis> sbasis_start = start->first_segment()->toSBasis();
+ SPCurve *line_helper = new SPCurve();
cubic = dynamic_cast<Geom::CubicBezier const *>(&*path_it->begin());
if (cubic) {
- lineHelper->moveto(SBasisStart.valueAt(
+ line_helper->moveto(sbasis_start.valueAt(
Geom::nearest_point((*cubic)[1], *start->first_segment())));
} else {
- lineHelper->moveto(start->first_segment()->initialPoint());
+ line_helper->moveto(start->first_segment()->initialPoint());
}
start->reset();
delete start;
@@ -1842,55 +1848,56 @@ void PenTool::_bspline_doEffect(SPCurve * curve)
SPCurve *end = new SPCurve();
end->moveto(curve_it1->initialPoint());
end->lineto(curve_it1->finalPoint());
- Geom::D2<Geom::SBasis> SBasisEnd = end->first_segment()->toSBasis();
+ Geom::D2<Geom::SBasis> sbasis_end = end->first_segment()->toSBasis();
cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
if (cubic) {
- lineHelper->lineto(SBasisEnd.valueAt(
+ line_helper->lineto(sbasis_end.valueAt(
Geom::nearest_point((*cubic)[2], *end->first_segment())));
} else {
- lineHelper->lineto(end->first_segment()->finalPoint());
+ line_helper->lineto(end->first_segment()->finalPoint());
}
end->reset();
delete end;
- SBasisHelper = lineHelper->first_segment()->toSBasis();
- lineHelper->reset();
- delete lineHelper;
- startNode = SBasisHelper.valueAt(0.5);
- nCurve->curveto(pointAt1, pointAt2, startNode);
- nCurve->move_endpoints(startNode, startNode);
+ sbasis_helper = line_helper->first_segment()->toSBasis();
+ line_helper->reset();
+ delete line_helper;
+ node = sbasis_helper.valueAt(0.5);
+ curve_n->curveto(point_at1, point_at2, node);
+ curve_n->move_endpoints(node, node);
} else if ( curve_it2 == curve_endit) {
- nCurve->curveto(pointAt1, pointAt2, curve_it1->finalPoint());
- nCurve->move_endpoints(path_it->begin()->initialPoint(), curve_it1->finalPoint());
+ curve_n->curveto(point_at1, point_at2, curve_it1->finalPoint());
+ curve_n->move_endpoints(path_it->begin()->initialPoint(), curve_it1->finalPoint());
} else {
- SPCurve *lineHelper = new SPCurve();
- lineHelper->moveto(pointAt2);
- lineHelper->lineto(nextPointAt1);
- SBasisHelper = lineHelper->first_segment()->toSBasis();
- lineHelper->reset();
- delete lineHelper;
+ SPCurve *line_helper = new SPCurve();
+ line_helper->moveto(point_at2);
+ line_helper->lineto(next_point_at1);
+ sbasis_helper = line_helper->first_segment()->toSBasis();
+ line_helper->reset();
+ delete line_helper;
previousNode = node;
- node = SBasisHelper.valueAt(0.5);
+ node = sbasis_helper.valueAt(0.5);
Geom::CubicBezier const *cubic2 = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
if((cubic && are_near((*cubic)[0],(*cubic)[1])) || (cubic2 && are_near((*cubic2)[2],(*cubic2)[3]))) {
node = curve_it1->finalPoint();
}
- nCurve->curveto(pointAt1, pointAt2, node);
+ curve_n->curveto(point_at1, point_at2, node);
}
++curve_it1;
++curve_it2;
}
+ //y cerramos la curva
if (path_it->closed()) {
- nCurve->closepath_current();
+ curve_n->closepath_current();
}
- curve->append(nCurve, false);
- nCurve->reset();
- delete nCurve;
+ curve->append(curve_n, false);
+ curve_n->reset();
+ delete curve_n;
}
}
//Spiro function cloned from lpe-spiro.cpp
// commenting the function "doEffect" from src/live_effects/lpe-spiro.cpp
-void PenTool::_spiro_doEffect(SPCurve * curve)
+void PenTool::_spiroDoEffect(SPCurve * curve)
{
using Geom::X;
using Geom::Y;
@@ -2087,16 +2094,16 @@ void PenTool::_finishSegment(Geom::Point const p, guint const state) {
if (!this->red_curve->is_empty()) {
- this->_bspline_spiro(state & GDK_SHIFT_MASK);
+ this->_bsplineSpiro(state & GDK_SHIFT_MASK);
this->green_curve->append_continuous(this->red_curve, 0.0625);
SPCurve *curve = this->red_curve->copy();
/// \todo fixme:
- SPCanvasItem *cshape = sp_canvas_bpath_new(this->desktop->getSketch(), curve);
+ SPCanvasItem *canvas_shape = sp_canvas_bpath_new(this->desktop->getSketch(), curve);
curve->unref();
- sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+ sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvas_shape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
- this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape);
+ this->green_bpaths = g_slist_prepend(this->green_bpaths, canvas_shape);
this->p[0] = this->p[3];
this->p[1] = this->p[4];
@@ -2185,7 +2192,7 @@ bool PenTool::_undoLastPoint() {
pen_last_paraxial_dir = !pen_last_paraxial_dir;
//redraw
- this->_bspline_spiro_build();
+ this->_bsplineSpiroBuild();
ret = true;
}
@@ -2210,7 +2217,7 @@ void PenTool::_finish(gboolean const closed) {
// cancelate line without a created segment
this->red_curve->reset();
spdc_concat_colors_and_flush(this, closed);
- this->overwriteCurve = NULL;
+ this->overwrite_curve = NULL;
this->sa = NULL;
this->ea = NULL;
diff --git a/src/ui/tools/pen-tool.h b/src/ui/tools/pen-tool.h
index 2208005c5..0ae16caf0 100644
--- a/src/ui/tools/pen-tool.h
+++ b/src/ui/tools/pen-tool.h
@@ -89,33 +89,33 @@ private:
bool _handle2ButtonPress(GdkEventButton const &bevent);
bool _handleKeyPress(GdkEvent *event);
//adds spiro & bspline modes
- void _pen_context_set_mode(guint mode);
+ void _penContextSetMode(guint mode);
//this function changes the colors red, green and blue making them transparent or not depending on if the function uses spiro
- void _bspline_spiro_color();
+ void _bsplineSpiroColor();
//creates a node in bspline or spiro modes
- void _bspline_spiro(bool shift);
+ void _bsplineSpiro(bool shift);
//creates a node in bspline or spiro modes
- void _bspline_spiro_on();
+ void _bsplineSpiroOn();
//creates a CUSP node
- void _bspline_spiro_off();
+ void _bsplineSpiroOff();
//continues the existing curve in bspline or spiro mode
- void _bspline_spiro_start_anchor(bool shift);
+ void _bsplineSpiroStartAnchor(bool shift);
//continues the existing curve with the union node in bspline or spiro modes
- void _bspline_spiro_start_anchor_on();
+ void _bsplineSpiroStartAnchorOn();
//continues an existing curve with the union node in CUSP mode
- void _bspline_spiro_start_anchor_off();
+ void _bsplineSpiroStartAnchorOff();
//modifies the "red_curve" when it detects movement
- void _bspline_spiro_motion(bool shift);
+ void _bsplineSpiroMotion(bool shift);
//closes the curve with the last node in bspline or spiro mode
- void _bspline_spiro_end_anchor_on();
+ void _bsplineSpiroEndAnchorOn();
//closes the curve with the last node in CUSP mode
- void _bspline_spiro_end_anchor_off();
+ void _bsplineSpiroEndAnchorOff();
//CHECK: join all the curves "in game" and we call doEffect function
- void _bspline_spiro_build();
+ void _bsplineSpiroBuild();
//function bspline cloned from lpe-bspline.cpp
- void _bspline_doEffect(SPCurve * curve);
+ void _bsplineDoEffect(SPCurve * curve);
//function spiro cloned from lpe-spiro.cpp
- void _spiro_doEffect(SPCurve * curve);
+ void _spiroDoEffect(SPCurve * curve);
void _setInitialPoint(Geom::Point const p);
void _setSubsequentPoint(Geom::Point const p, bool statusbar, guint status = 0);
diff --git a/src/ui/tools/pencil-tool.cpp b/src/ui/tools/pencil-tool.cpp
index db24c7432..008804162 100644
--- a/src/ui/tools/pencil-tool.cpp
+++ b/src/ui/tools/pencil-tool.cpp
@@ -191,7 +191,7 @@ bool PencilTool::_handleButtonPress(GdkEventButton const &bevent) {
}
if (anchor) {
p = anchor->dp;
- this->overwriteCurve = anchor->curve;
+ this->overwrite_curve = anchor->curve;
desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Continuing selected path"));
} else {
m.setup(desktop);
@@ -663,11 +663,11 @@ void PencilTool::_interpolate() {
for (int c = 0; c < n_segs; c++) {
// if we are in BSpline we modify the trace to create adhoc nodes
if(mode == 2){
- Geom::Point BP = b[4*c+0] + (1./3)*(b[4*c+3] - b[4*c+0]);
- BP = Geom::Point(BP[X] + 0.0001,BP[Y] + 0.0001);
- Geom::Point CP = b[4*c+3] + (1./3)*(b[4*c+0] - b[4*c+3]);
- CP = Geom::Point(CP[X] + 0.0001,CP[Y] + 0.0001);
- this->green_curve->curveto(BP,CP,b[4*c+3]);
+ Geom::Point point_at1 = b[4*c+0] + (1./3)*(b[4*c+3] - b[4*c+0]);
+ point_at1 = Geom::Point(point_at1[X] + 0.0001,point_at1[Y] + 0.0001);
+ Geom::Point point_at2 = b[4*c+3] + (1./3)*(b[4*c+0] - b[4*c+3]);
+ point_at2 = Geom::Point(point_at2[X] + 0.0001,point_at2[Y] + 0.0001);
+ this->green_curve->curveto(point_at1,point_at2,b[4*c+3]);
}else{
this->green_curve->curveto(b[4 * c + 1], b[4 * c + 2], b[4 * c + 3]);
}
@@ -810,11 +810,11 @@ void PencilTool::_fitAndSplit() {
// if we are in BSpline we modify the trace to create adhoc nodes
guint mode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0);
if(mode == 2){
- Geom::Point B = b[0] + (1./3)*(b[3] - b[0]);
- B = Geom::Point(B[X] + 0.0001,B[Y] + 0.0001);
- Geom::Point C = b[3] + (1./3)*(b[0] - b[3]);
- C = Geom::Point(C[X] + 0.0001,C[Y] + 0.0001);
- this->red_curve->curveto(B,C,b[3]);
+ Geom::Point point_at1 = b[0] + (1./3)*(b[3] - b[0]);
+ point_at1 = Geom::Point(point_at1[X] + 0.0001,point_at1[Y] + 0.0001);
+ Geom::Point point_at2 = b[3] + (1./3)*(b[0] - b[3]);
+ point_at2 = Geom::Point(point_at2[X] + 0.0001,point_at2[Y] + 0.0001);
+ this->red_curve->curveto(point_at1,point_at2,b[3]);
}else{
this->red_curve->curveto(b[1], b[2], b[3]);
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-20 01:31:24 +0000