Fix coding style issues in perspective/envelope LPE

(bzr r14052)

2 files changed, 147 insertions, 144 deletions

diff --git a/src/live_effects/lpe-perspective-envelope.cpp b/src/live_effects/lpe-perspective-envelope.cpp
index b5885bdb3..4eac2d6eb 100644
--- a/src/live_effects/lpe-perspective-envelope.cpp
+++ b/src/live_effects/lpe-perspective-envelope.cpp
@@ -1,6 +1,6 @@
 /** \file
  * LPE <perspective-envelope> implementation
- 
+
  */
 /*
  * Authors:
@@ -8,8 +8,8 @@
  *   Aaron Spike, aaron@ekips.org from envelope and perspective phyton code
  *   Dmitry Platonov, shadowjack@mail.ru, 2006 perspective approach & math
  *   Jose Hevia (freon) Transform algorithm from envelope
- *   
- * Copyright (C) 2007-2014 Authors 
+ *
+ * Copyright (C) 2007-2014 Authors
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
@@ -27,8 +27,8 @@ namespace Inkscape {
 namespace LivePathEffect {
 
 enum DeformationType {
-  DEFORMATION_PERSPECTIVE,
-  DEFORMATION_ENVELOPE
+    DEFORMATION_PERSPECTIVE,
+    DEFORMATION_ENVELOPE
 };
 
 static const Util::EnumData<unsigned> DeformationTypeData[] = {
@@ -42,52 +42,53 @@ LPEPerspectiveEnvelope::LPEPerspectiveEnvelope(LivePathEffectObject *lpeobject)
     Effect(lpeobject),
     // initialise your parameters here:
     deform_type(_("Type"), _("Select the type of deformation"), "deform_type", DeformationTypeConverter, &wr, this, DEFORMATION_PERSPECTIVE),
-    Up_Left_Point(_("Top Left"), _("Top Left - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "Up_Left_Point", &wr, this),
-    Up_Right_Point(_("Top Right"), _("Top Right - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "Up_Right_Point", &wr, this),
-    Down_Left_Point(_("Down Left"), _("Down Left - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "Down_Left_Point", &wr, this),
-    Down_Right_Point(_("Down Right"), _("Down Right - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "Down_Right_Point", &wr, this)
+    up_left_point(_("Top Left"), _("Top Left - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "up_left_point", &wr, this),
+    up_right_point(_("Top Right"), _("Top Right - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "up_right_point", &wr, this),
+    down_left_point(_("Down Left"), _("Down Left - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "down_left_point", &wr, this),
+    down_right_point(_("Down Right"), _("Down Right - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "down_right_point", &wr, this)
 {
     // register all your parameters here, so Inkscape knows which parameters this effect has:
     registerParameter(&deform_type);
-    registerParameter(&Up_Left_Point);
-    registerParameter(&Up_Right_Point);
-    registerParameter(&Down_Left_Point);
-    registerParameter(&Down_Right_Point);
+    registerParameter(&up_left_point);
+    registerParameter(&up_right_point);
+    registerParameter(&down_left_point);
+    registerParameter(&down_right_point);
 }
 
 LPEPerspectiveEnvelope::~LPEPerspectiveEnvelope()
 {
 }
 
-void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) {
+void LPEPerspectiveEnvelope::doEffect(SPCurve *curve)
+{
     using Geom::X;
     using Geom::Y;
     double projmatrix[3][3];
-    if(deform_type == DEFORMATION_PERSPECTIVE){
+    if(deform_type == DEFORMATION_PERSPECTIVE) {
         std::vector<Geom::Point> handles(4);
-        handles[0] = Down_Left_Point;
-        handles[1] = Up_Left_Point;
-        handles[2] = Up_Right_Point;
-        handles[3] = Down_Right_Point;
-        std::vector<Geom::Point> sourceHandles(4);
-        sourceHandles[0] = Geom::Point(boundingbox_X.min(), boundingbox_Y.max());
-        sourceHandles[1] = Geom::Point(boundingbox_X.min(), boundingbox_Y.min());
-        sourceHandles[2] = Geom::Point(boundingbox_X.max(), boundingbox_Y.min());
-        sourceHandles[3] = Geom::Point(boundingbox_X.max(), boundingbox_Y.max());
+        handles[0] = down_left_point;
+        handles[1] = up_left_point;
+        handles[2] = up_right_point;
+        handles[3] = down_right_point;
+        std::vector<Geom::Point> source_handles(4);
+        source_handles[0] = Geom::Point(boundingbox_X.min(), boundingbox_Y.max());
+        source_handles[1] = Geom::Point(boundingbox_X.min(), boundingbox_Y.min());
+        source_handles[2] = Geom::Point(boundingbox_X.max(), boundingbox_Y.min());
+        source_handles[3] = Geom::Point(boundingbox_X.max(), boundingbox_Y.max());
         double solmatrix[8][8] = {{0}};
         double free_term[8] = {0};
         double gslSolmatrix[64];
-        for(unsigned int i = 0; i < 4; ++i){
-            solmatrix[i][0] = sourceHandles[i][X];
-            solmatrix[i][1] = sourceHandles[i][Y];
+        for(unsigned int i = 0; i < 4; ++i) {
+            solmatrix[i][0] = source_handles[i][X];
+            solmatrix[i][1] = source_handles[i][Y];
             solmatrix[i][2] = 1;
-            solmatrix[i][6] = -handles[i][X] * sourceHandles[i][X];
-            solmatrix[i][7] = -handles[i][X] * sourceHandles[i][Y];
-            solmatrix[i+4][3] = sourceHandles[i][X];
-            solmatrix[i+4][4] = sourceHandles[i][Y];
+            solmatrix[i][6] = -handles[i][X] * source_handles[i][X];
+            solmatrix[i][7] = -handles[i][X] * source_handles[i][Y];
+            solmatrix[i+4][3] = source_handles[i][X];
+            solmatrix[i+4][4] = source_handles[i][Y];
             solmatrix[i+4][5] = 1;
-            solmatrix[i+4][6] = -handles[i][Y] * sourceHandles[i][X];
-            solmatrix[i+4][7] = -handles[i][Y] * sourceHandles[i][Y];
+            solmatrix[i+4][6] = -handles[i][Y] * source_handles[i][X];
+            solmatrix[i+4][7] = -handles[i][Y] * source_handles[i][Y];
             free_term[i] = handles[i][X];
             free_term[i+4] = handles[i][Y];
         }
@@ -110,7 +111,7 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) {
         h = 0;
         for( int i = 0; i < 3; i++ ) {
             for( int j = 0; j < 3; j++ ) {
-                if(h==8){
+                if(h==8) {
                     projmatrix[2][2] = 1.0;
                     continue;
                 }
@@ -124,19 +125,19 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) {
     Geom::PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(curve->get_pathvector());
     curve->reset();
     Geom::CubicBezier const *cubic = NULL;
-    Geom::Point pointAt1(0, 0);
-    Geom::Point pointAt2(0, 0);
-    Geom::Point pointAt3(0, 0);
+    Geom::Point point_at1(0, 0);
+    Geom::Point point_at2(0, 0);
+    Geom::Point point_at3(0, 0);
     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())
-          continue;
+            continue;
         //Itreadores
         SPCurve *nCurve = new SPCurve();
         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();
-        
+
         if (path_it->closed()) {
             const Geom::Curve &closingline =
                 path_it->back_closed();
@@ -144,40 +145,40 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) {
                 curve_endit = path_it->end_open();
             }
         }
-        if(deform_type == DEFORMATION_PERSPECTIVE){
-            nCurve->moveto(project_point(curve_it1->initialPoint(),projmatrix));
-        }else{
-            nCurve->moveto(project_point(curve_it1->initialPoint()));
+        if(deform_type == DEFORMATION_PERSPECTIVE) {
+            nCurve->moveto(projectPoint(curve_it1->initialPoint(),projmatrix));
+        } else {
+            nCurve->moveto(projectPoint(curve_it1->initialPoint()));
         }
         while (curve_it1 != curve_endit) {
-          cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
-          if (cubic) {
-            pointAt1 = (*cubic)[1];
-            pointAt2 = (*cubic)[2];
-          } else {
-            pointAt1 = curve_it1->initialPoint();
-            pointAt2 = curve_it1->finalPoint();
-          }
-          pointAt3 = curve_it1->finalPoint();
-          if(deform_type == DEFORMATION_PERSPECTIVE){
-            pointAt1 = project_point(pointAt1,projmatrix);
-            pointAt2 = project_point(pointAt2,projmatrix);
-            pointAt3 = project_point(pointAt3,projmatrix);
-          }else{
-            pointAt1 = project_point(pointAt1);
-            pointAt2 = project_point(pointAt2);
-            pointAt3 = project_point(pointAt3);
-          }
-          nCurve->curveto(pointAt1, pointAt2, pointAt3);
-          ++curve_it1;
-          if(curve_it2 != curve_endit) {
-            ++curve_it2;
-          }
+            cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
+            if (cubic) {
+                point_at1 = (*cubic)[1];
+                point_at2 = (*cubic)[2];
+            } else {
+                point_at1 = curve_it1->initialPoint();
+                point_at2 = curve_it1->finalPoint();
+            }
+            point_at3 = curve_it1->finalPoint();
+            if(deform_type == DEFORMATION_PERSPECTIVE) {
+                point_at1 = projectPoint(point_at1,projmatrix);
+                point_at2 = projectPoint(point_at2,projmatrix);
+                point_at3 = projectPoint(point_at3,projmatrix);
+            } else {
+                point_at1 = projectPoint(point_at1);
+                point_at2 = projectPoint(point_at2);
+                point_at3 = projectPoint(point_at3);
+            }
+            nCurve->curveto(point_at1, point_at2, point_at3);
+            ++curve_it1;
+            if(curve_it2 != curve_endit) {
+                ++curve_it2;
+            }
         }
         //y cerramos la curva
         if (path_it->closed()) {
-          nCurve->move_endpoints(pointAt3, pointAt3);
-          nCurve->closepath_current();
+            nCurve->move_endpoints(point_at3, point_at3);
+            nCurve->closepath_current();
         }
         curve->append(nCurve, false);
         nCurve->reset();
@@ -185,41 +186,44 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) {
     }
 }
 
-Geom::Point 
-LPEPerspectiveEnvelope::project_point(Geom::Point p){
+Geom::Point
+LPEPerspectiveEnvelope::projectPoint(Geom::Point p)
+{
     double width = boundingbox_X.extent();
     double height = boundingbox_Y.extent();
     double delta_x = boundingbox_X.min() - p[X];
     double delta_y = boundingbox_Y.max() - p[Y];
-    Geom::Coord xratio = (delta_x * -1) / width;
-    Geom::Coord yratio = delta_y / height;
+    Geom::Coord x_ratio = (delta_x * -1) / width;
+    Geom::Coord y_ratio = delta_y / height;
     Geom::Line* horiz = new Geom::Line();
     Geom::Line* vert = new Geom::Line();
-    vert->setPoints (pointAtRatio(yratio,Down_Left_Point,Up_Left_Point),pointAtRatio(yratio,Down_Right_Point,Up_Right_Point));
-    horiz->setPoints (pointAtRatio(xratio,Down_Left_Point,Down_Right_Point),pointAtRatio(xratio,Up_Left_Point,Up_Right_Point));
+    vert->setPoints (pointAtRatio(y_ratio,down_left_point,up_left_point),pointAtRatio(y_ratio,down_right_point,up_right_point));
+    horiz->setPoints (pointAtRatio(x_ratio,down_left_point,down_right_point),pointAtRatio(x_ratio,up_left_point,up_right_point));
 
     OptCrossing crossPoint = intersection(*horiz,*vert);
-    if(crossPoint){
+    if(crossPoint) {
         return horiz->pointAt(Geom::Coord(crossPoint->ta));
-    }else{
+    } else {
         return p;
     }
 }
 
-Geom::Point 
-LPEPerspectiveEnvelope::project_point(Geom::Point p, double m[][3]){
+Geom::Point
+LPEPerspectiveEnvelope::projectPoint(Geom::Point p, double m[][3])
+{
     Geom::Coord x = p[0];
     Geom::Coord y = p[1];
     return Geom::Point(
-                Geom::Coord((x*m[0][0] + y*m[0][1] + m[0][2])/(x*m[2][0]+y*m[2][1]+m[2][2])),
-                Geom::Coord((x*m[1][0] + y*m[1][1] + m[1][2])/(x*m[2][0]+y*m[2][1]+m[2][2])));
+               Geom::Coord((x*m[0][0] + y*m[0][1] + m[0][2])/(x*m[2][0]+y*m[2][1]+m[2][2])),
+               Geom::Coord((x*m[1][0] + y*m[1][1] + m[1][2])/(x*m[2][0]+y*m[2][1]+m[2][2])));
 }
 
 Geom::Point
-LPEPerspectiveEnvelope::pointAtRatio(Geom::Coord ratio,Geom::Point A, Geom::Point B){
-        Geom::Coord x = A[X] + (ratio * (B[X]-A[X]));
-        Geom::Coord y = A[Y]+ (ratio * (B[Y]-A[Y]));
-        return Point(x, y);
+LPEPerspectiveEnvelope::pointAtRatio(Geom::Coord ratio,Geom::Point A, Geom::Point B)
+{
+    Geom::Coord x = A[X] + (ratio * (B[X]-A[X]));
+    Geom::Coord y = A[Y]+ (ratio * (B[Y]-A[Y]));
+    return Point(x, y);
 }
 
 
@@ -233,36 +237,35 @@ LPEPerspectiveEnvelope::newWidget()
     vbox->set_homogeneous(false);
     vbox->set_spacing(6);
     std::vector<Parameter *>::iterator it = param_vector.begin();
-    Gtk::HBox * hboxUpHandles = Gtk::manage(new Gtk::HBox(false,0));
-    Gtk::HBox * hboxDownHandles = Gtk::manage(new Gtk::HBox(false,0));
+    Gtk::HBox * hbox_up_handles = Gtk::manage(new Gtk::HBox(false,0));
+    Gtk::HBox * hbox_down_handles = Gtk::manage(new Gtk::HBox(false,0));
     while (it != param_vector.end()) {
         if ((*it)->widget_is_visible) {
             Parameter * param = *it;
             Gtk::Widget * widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
-            if (param->param_key == "Up_Left_Point" ||
-                param->param_key == "Up_Right_Point" ||
-                param->param_key == "Down_Left_Point" ||
-                param->param_key == "Down_Right_Point")
-            {
-                Gtk::HBox * pointParameter = dynamic_cast<Gtk::HBox *>(widg);
-                std::vector< Gtk::Widget* > childList = pointParameter->get_children();
-                Gtk::HBox * pointParameterHBox = dynamic_cast<Gtk::HBox *>(childList[0]);
-                std::vector< Gtk::Widget* > childList2 = pointParameterHBox->get_children();
-                pointParameterHBox->remove(childList2[0][0]);
+            if (param->param_key == "up_left_point" ||
+                    param->param_key == "up_right_point" ||
+                    param->param_key == "down_left_point" ||
+                    param->param_key == "down_right_point") {
+                Gtk::HBox * point_hbox = dynamic_cast<Gtk::HBox *>(widg);
+                std::vector< Gtk::Widget* > child_list = point_hbox->get_children();
+                Gtk::HBox * point_hboxHBox = dynamic_cast<Gtk::HBox *>(child_list[0]);
+                std::vector< Gtk::Widget* > child_list2 = point_hboxHBox->get_children();
+                point_hboxHBox->remove(child_list2[0][0]);
                 Glib::ustring * tip = param->param_getTooltip();
                 if (widg) {
-                    if(param->param_key == "Up_Left_Point"){
+                    if(param->param_key == "up_left_point") {
                         Gtk::Label* handles = Gtk::manage(new Gtk::Label(Glib::ustring(_("Handles:")),Gtk::ALIGN_START));
                         vbox->pack_start(*handles, false, false, 2);
-                        hboxUpHandles->pack_start(*widg, true, true, 2);
-                        hboxUpHandles->pack_start(*Gtk::manage(new Gtk::VSeparator()), Gtk::PACK_EXPAND_WIDGET);
-                    }else if(param->param_key == "Up_Right_Point"){
-                        hboxUpHandles->pack_start(*widg, true, true, 2);
-                    }else if(param->param_key == "Down_Left_Point"){
-                        hboxDownHandles->pack_start(*widg, true, true, 2);
-                        hboxDownHandles->pack_start(*Gtk::manage(new Gtk::VSeparator()), Gtk::PACK_EXPAND_WIDGET);
-                    }else{
-                        hboxDownHandles->pack_start(*widg, true, true, 2);
+                        hbox_up_handles->pack_start(*widg, true, true, 2);
+                        hbox_up_handles->pack_start(*Gtk::manage(new Gtk::VSeparator()), Gtk::PACK_EXPAND_WIDGET);
+                    } else if(param->param_key == "up_right_point") {
+                        hbox_up_handles->pack_start(*widg, true, true, 2);
+                    } else if(param->param_key == "down_left_point") {
+                        hbox_down_handles->pack_start(*widg, true, true, 2);
+                        hbox_down_handles->pack_start(*Gtk::manage(new Gtk::VSeparator()), Gtk::PACK_EXPAND_WIDGET);
+                    } else {
+                        hbox_down_handles->pack_start(*widg, true, true, 2);
                     }
                     if (tip) {
                         widg->set_tooltip_text(*tip);
@@ -271,7 +274,7 @@ LPEPerspectiveEnvelope::newWidget()
                         widg->set_has_tooltip(false);
                     }
                 }
-            }else{
+            } else {
                 Glib::ustring * tip = param->param_getTooltip();
                 if (widg) {
                     vbox->pack_start(*widg, true, true, 2);
@@ -287,18 +290,18 @@ LPEPerspectiveEnvelope::newWidget()
 
         ++it;
     }
-    vbox->pack_start(*hboxUpHandles,true, true, 2);
-    Gtk::HBox * hboxMiddle = Gtk::manage(new Gtk::HBox(true,2));
-    hboxMiddle->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET);
-    hboxMiddle->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET);
-    vbox->pack_start(*hboxMiddle, false, true, 2);
-    vbox->pack_start(*hboxDownHandles, true, true, 2);
+    vbox->pack_start(*hbox_up_handles,true, true, 2);
+    Gtk::HBox * hbox_middle = Gtk::manage(new Gtk::HBox(true,2));
+    hbox_middle->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET);
+    hbox_middle->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET);
+    vbox->pack_start(*hbox_middle, false, true, 2);
+    vbox->pack_start(*hbox_down_handles, true, true, 2);
     Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false,0));
-    Gtk::Button* resetButton = Gtk::manage(new Gtk::Button(Gtk::Stock::CLEAR));
-    resetButton->signal_clicked().connect(sigc::mem_fun (*this,&LPEPerspectiveEnvelope::resetGrid));
-    resetButton->set_size_request(140,30);
+    Gtk::Button* reset_button = Gtk::manage(new Gtk::Button(Gtk::Stock::CLEAR));
+    reset_button->signal_clicked().connect(sigc::mem_fun (*this,&LPEPerspectiveEnvelope::resetGrid));
+    reset_button->set_size_request(140,30);
     vbox->pack_start(*hbox, true,true,2);
-    hbox->pack_start(*resetButton, false, false,2);
+    hbox->pack_start(*reset_button, false, false,2);
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
@@ -315,24 +318,24 @@ LPEPerspectiveEnvelope::doBeforeEffect (SPLPEItem const* lpeitem)
 void
 LPEPerspectiveEnvelope::setDefaults()
 {
-    Geom::Point Up_Left(boundingbox_X.min(), boundingbox_Y.min());
-    Geom::Point Up_Right(boundingbox_X.max(), boundingbox_Y.min());
-    Geom::Point Down_Left(boundingbox_X.min(), boundingbox_Y.max());
-    Geom::Point Down_Right(boundingbox_X.max(), boundingbox_Y.max());
-
-    Up_Left_Point.param_update_default(Up_Left);
-    Up_Right_Point.param_update_default(Up_Right);
-    Down_Right_Point.param_update_default(Down_Right);
-    Down_Left_Point.param_update_default(Down_Left);
+    Geom::Point up_left(boundingbox_X.min(), boundingbox_Y.min());
+    Geom::Point up_right(boundingbox_X.max(), boundingbox_Y.min());
+    Geom::Point down_left(boundingbox_X.min(), boundingbox_Y.max());
+    Geom::Point down_right(boundingbox_X.max(), boundingbox_Y.max());
+
+    up_left_point.param_update_default(up_left);
+    up_right_point.param_update_default(up_right);
+    down_right_point.param_update_default(down_right);
+    down_left_point.param_update_default(down_left);
 }
 
 void
 LPEPerspectiveEnvelope::resetGrid()
 {
-    Up_Left_Point.param_set_default();
-    Up_Right_Point.param_set_default();
-    Down_Right_Point.param_set_default();
-    Down_Left_Point.param_set_default();
+    up_left_point.param_set_default();
+    up_right_point.param_set_default();
+    down_right_point.param_set_default();
+    down_left_point.param_set_default();
 }
 
 void
@@ -351,11 +354,11 @@ LPEPerspectiveEnvelope::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::v
 
     SPCurve *c = new SPCurve();
     c->reset();
-    c->moveto(Up_Left_Point);
-    c->lineto(Up_Right_Point);
-    c->lineto(Down_Right_Point);
-    c->lineto(Down_Left_Point);
-    c->lineto(Up_Left_Point);
+    c->moveto(up_left_point);
+    c->lineto(up_right_point);
+    c->lineto(down_right_point);
+    c->lineto(down_left_point);
+    c->lineto(up_left_point);
     hp_vec.push_back(c->get_pathvector());
 }
 
diff --git a/src/live_effects/lpe-perspective-envelope.h b/src/live_effects/lpe-perspective-envelope.h
index d3ff76445..e25f059a3 100644
--- a/src/live_effects/lpe-perspective-envelope.h
+++ b/src/live_effects/lpe-perspective-envelope.h
@@ -3,7 +3,7 @@
 
 /** \file
  * LPE <perspective-envelope> implementation , see lpe-perspective-envelope.cpp.
- 
+
  */
 /*
  * Authors:
@@ -11,8 +11,8 @@
  *   Aaron Spike, aaron@ekips.org from envelope and perspective phyton code
  *   Dmitry Platonov, shadowjack@mail.ru, 2006 perspective approach & math
  *   Jose Hevia (freon) Transform algorithm from envelope
- *   
- * Copyright (C) 2007-2014 Authors 
+ *
+ * Copyright (C) 2007-2014 Authors
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
@@ -34,9 +34,9 @@ public:
 
     virtual void doEffect(SPCurve *curve);
 
-    virtual Geom::Point project_point(Geom::Point p);
+    virtual Geom::Point projectPoint(Geom::Point p);
 
-    virtual Geom::Point project_point(Geom::Point p,  double m[][3]);
+    virtual Geom::Point projectPoint(Geom::Point p,  double m[][3]);
 
     virtual Geom::Point pointAtRatio(Geom::Coord ratio,Geom::Point A, Geom::Point B);
 
@@ -55,10 +55,10 @@ protected:
 private:
 
     EnumParam<unsigned> deform_type;
-    PointParam Up_Left_Point;
-    PointParam Up_Right_Point;
-    PointParam Down_Left_Point;
-    PointParam Down_Right_Point;
+    PointParam up_left_point;
+    PointParam up_right_point;
+    PointParam down_left_point;
+    PointParam down_right_point;
 
     LPEPerspectiveEnvelope(const LPEPerspectiveEnvelope&);
     LPEPerspectiveEnvelope& operator=(const LPEPerspectiveEnvelope&);