update to trunk

(bzr r12588.1.42)

26 files changed, 1411 insertions, 1330 deletions

diff --git a/share/extensions/hpgl_encoder.py b/share/extensions/hpgl_encoder.py
index a16561e97..83b1b7297 100644
--- a/share/extensions/hpgl_encoder.py
+++ b/share/extensions/hpgl_encoder.py
@@ -23,7 +23,6 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 import math
 import re
 import string
-#from StringIO import StringIO
 # local libraries
 import bezmisc
 import cspsubdiv
@@ -66,6 +65,7 @@ class hpglEncoder:
         self.sizeY = 'False'
         self.dryRun = True
         self.lastPoint = [0, 0, 0]
+        self.lastPen = -1
         self.offsetX = 0
         self.offsetY = 0
         self.scaleX = self.options.resolutionX / effect.unittouu("1.0in") # dots per inch to dots per user unit
@@ -109,7 +109,7 @@ class hpglEncoder:
         # dryRun to find edges
         groupmat = [[self.mirrorX * self.scaleX * self.viewBoxTransformX, 0.0, 0.0], [0.0, self.mirrorY * self.scaleY * self.viewBoxTransformY, 0.0]]
         groupmat = simpletransform.composeTransform(groupmat, simpletransform.parseTransform('rotate(' + self.options.orientation + ')'))
-        self.vData = [['', -1.0, -1.0], ['', -1.0, -1.0], ['', -1.0, -1.0], ['', -1.0, -1.0]]
+        self.vData = [['', 'False', 0, 0], ['', 'False', 0, 0], ['', 'False', 0, 0], ['', 'False', 0, 0]]
         self.processGroups(self.doc, groupmat)
         if self.divergenceX == 'False' or self.divergenceY == 'False' or self.sizeX == 'False' or self.sizeY == 'False':
             raise Exception('NO_PATHS')
@@ -156,11 +156,11 @@ class hpglEncoder:
         groupmat = [[self.mirrorX * self.scaleX * self.viewBoxTransformX, 0.0, -self.divergenceX + self.offsetX],
             [0.0, self.mirrorY * self.scaleY * self.viewBoxTransformY, -self.divergenceY + self.offsetY]]
         groupmat = simpletransform.composeTransform(groupmat, simpletransform.parseTransform('rotate(' + self.options.orientation + ')'))
-        self.vData = [['', -1.0, -1.0], ['', -1.0, -1.0], ['', -1.0, -1.0], ['', -1.0, -1.0]]
+        self.vData = [['', 'False', 0, 0], ['', 'False', 0, 0], ['', 'False', 0, 0], ['', 'False', 0, 0]]
         # add move to zero point and precut
         if self.toolOffset > 0.0 and self.options.precut:
             if self.options.center:
-                # position precut outside of drawing plus one times the tooloffset
+                # position precut outside of drawing plus one time the tooloffset
                 if self.offsetX >= 0.0:
                     precutX = self.offsetX + self.toolOffset
                 else:
@@ -169,17 +169,16 @@ class hpglEncoder:
                     precutY = self.offsetY + self.toolOffset
                 else:
                     precutY = self.offsetY - self.toolOffset
-                self.processOffset('PU', precutX, precutY)
-                self.processOffset('PD', precutX, precutY + self.toolOffset * 8)
+                self.processOffset('PU', precutX, precutY, self.options.pen)
+                self.processOffset('PD', precutX, precutY + self.toolOffset * 8, self.options.pen)
             else:
-                self.processOffset('PU', 0, 0)
-                self.processOffset('PD', 0, self.toolOffset * 8)
-        else:
-            self.processOffset('PU', 0, 0)
+                self.processOffset('PU', 0, 0, self.options.pen)
+                self.processOffset('PD', 0, self.toolOffset * 8, self.options.pen)
         # start conversion
         self.processGroups(self.doc, groupmat)
         # shift an empty node in in order to process last node in cache
-        self.processOffset('PU', 0, 0)
+        if self.toolOffset > 0.0 and not self.dryRun:
+            self.processOffset('PU', 0, 0, 0)
         if self.options.debug:
             return self.hpgl, self
         else:
@@ -190,7 +189,7 @@ class hpglEncoder:
         paths = []
         for node in doc:
             if (node.tag == inkex.addNS('g', 'svg') and self.isGroupVisible(node)) or node.tag == inkex.addNS('path', 'svg'):
-                paths.append([node.tag, node, self.mergeTransform(node, groupmat)])
+                paths.append([node.tag, node, self.mergeTransform(node, groupmat), self.getPenNumber(node)])
         doc = ''
         hasGroups = True
         while hasGroups:
@@ -200,11 +199,19 @@ class hpglEncoder:
                     hasGroups = True
                     for path in paths[i][1]:
                         if (path.tag == inkex.addNS('g', 'svg') and self.isGroupVisible(path)) or path.tag == inkex.addNS('path', 'svg'):
-                            paths.append([path.tag, path, self.mergeTransform(path, paths[i][2])])
+                            paths.insert(i + 1, [path.tag, path, self.mergeTransform(path, paths[i][2]), paths[i][3]])
                     paths[i][0] = ''
         for node in paths:
             if node[0] == inkex.addNS('path', 'svg'):
-                self.processPath(node[1], node[2])
+                self.processPath(node[1], node[2], node[3])
+
+    def getPenNumber(self, doc):
+        penNum = str(doc.get('{' + inkex.NSS['inkscape'] + '}label')).lower().strip(' \t\n\r')
+        if re.search(r'( |\A)pen *\d+( |\Z)', penNum):
+            penNum = re.sub(r'(.* |\A)pen *(\d+)( .*|\Z)', r'\2', penNum, 1)
+            return int(penNum)
+        else:
+            return self.options.pen
 
     def mergeTransform(self, doc, matrix):
         # get and merge two matrixes into one
@@ -222,7 +229,7 @@ class hpglEncoder:
                 return False
         return True
 
-    def processPath(self, node, mat):
+    def processPath(self, node, mat, pen):
         # process path
         path = node.get('d')
         if path:
@@ -239,7 +246,7 @@ class hpglEncoder:
                     posX, posY = singlePathPoint[1]
                     # check if point is repeating, if so, ignore
                     if int(round(posX)) != int(round(oldPosX)) or int(round(posY)) != int(round(oldPosY)):
-                        self.processOffset(cmd, posX, posY)
+                        self.processOffset(cmd, posX, posY, pen)
                         cmd = 'PD'
                         oldPosX = posX
                         oldPosY = posY
@@ -255,10 +262,10 @@ class hpglEncoder:
                                 overcutLength += self.getLength(oldPosX, oldPosY, posX, posY)
                                 if overcutLength >= self.overcut:
                                     newLength = self.changeLength(oldPosX, oldPosY, posX, posY, - (overcutLength - self.overcut))
-                                    self.processOffset(cmd, newLength[0], newLength[1])
+                                    self.processOffset(cmd, newLength[0], newLength[1], pen)
                                     break
                                 else:
-                                    self.processOffset(cmd, posX, posY)
+                                    self.processOffset(cmd, posX, posY, pen)
                                 oldPosX = posX
                                 oldPosY = posY
 
@@ -277,34 +284,34 @@ class hpglEncoder:
         y = y2 + (y2 - y1) / self.getLength(x1, y1, x2, y2, False) * offset
         return [x, y]
 
-    def processOffset(self, cmd, posX, posY):
+    def processOffset(self, cmd, posX, posY, pen):
         # calculate offset correction (or dont)
         if self.toolOffset == 0.0 or self.dryRun:
-            self.storePoint(cmd, posX, posY)
+            self.storePoint(cmd, posX, posY, pen)
         else:
             # insert data into cache
             self.vData.pop(0)
-            self.vData.insert(3, [cmd, posX, posY])
+            self.vData.insert(3, [cmd, posX, posY, pen])
             # decide if enough data is availabe
-            if self.vData[2][1] != -1.0:
-                if self.vData[1][1] == -1.0:
-                    self.storePoint(self.vData[2][0], self.vData[2][1], self.vData[2][2])
+            if self.vData[2][1] != 'False':
+                if self.vData[1][1] == 'False':
+                    self.storePoint(self.vData[2][0], self.vData[2][1], self.vData[2][2], self.vData[2][3])
                 else:
                     # perform tool offset correction (It's a *tad* complicated, if you want to understand it draw the data as lines on paper)
                     if self.vData[2][0] == 'PD': # If the 3rd entry in the cache is a pen down command make the line longer by the tool offset
                         pointThree = self.changeLength(self.vData[1][1], self.vData[1][2], self.vData[2][1], self.vData[2][2], self.toolOffset)
-                        self.storePoint('PD', pointThree[0], pointThree[1])
-                    elif self.vData[0][1] != -1.0:
+                        self.storePoint('PD', pointThree[0], pointThree[1], self.vData[2][3])
+                    elif self.vData[0][1] != 'False':
                         # Elif the 1st entry in the cache is filled with data and the 3rd entry is a pen up command shift
                         # the 3rd entry by the current tool offset position according to the 2nd command
                         pointThree = self.changeLength(self.vData[0][1], self.vData[0][2], self.vData[1][1], self.vData[1][2], self.toolOffset)
                         pointThree[0] = self.vData[2][1] - (self.vData[1][1] - pointThree[0])
                         pointThree[1] = self.vData[2][2] - (self.vData[1][2] - pointThree[1])
-                        self.storePoint('PU', pointThree[0], pointThree[1])
+                        self.storePoint('PU', pointThree[0], pointThree[1], self.vData[2][3])
                     else:
                         # Else just write the 3rd entry
                         pointThree = [self.vData[2][1], self.vData[2][2]]
-                        self.storePoint('PU', pointThree[0], pointThree[1])
+                        self.storePoint('PU', pointThree[0], pointThree[1], self.vData[2][3])
                     if self.vData[3][0] == 'PD':
                         # If the 4th entry in the cache is a pen down command guide tool to next line with a circle between the prolonged 3rd and 4th entry
                         if self.getLength(self.vData[2][1], self.vData[2][2], self.vData[3][1], self.vData[3][2]) >= self.toolOffset:
@@ -324,16 +331,16 @@ class hpglEncoder:
                         if angleVector >= 0:
                             angle = angleStart + self.toolOffsetFlat
                             while angle < angleStart + angleVector:
-                                self.storePoint('PD', self.vData[2][1] + math.cos(angle) * self.toolOffset, self.vData[2][2] + math.sin(angle) * self.toolOffset)
+                                self.storePoint('PD', self.vData[2][1] + math.cos(angle) * self.toolOffset, self.vData[2][2] + math.sin(angle) * self.toolOffset, self.vData[2][3])
                                 angle += self.toolOffsetFlat
                         else:
                             angle = angleStart - self.toolOffsetFlat
                             while angle > angleStart + angleVector:
-                                self.storePoint('PD', self.vData[2][1] + math.cos(angle) * self.toolOffset, self.vData[2][2] + math.sin(angle) * self.toolOffset)
+                                self.storePoint('PD', self.vData[2][1] + math.cos(angle) * self.toolOffset, self.vData[2][2] + math.sin(angle) * self.toolOffset, self.vData[2][3])
                                 angle -= self.toolOffsetFlat
-                        self.storePoint('PD', pointFour[0], pointFour[1])
+                        self.storePoint('PD', pointFour[0], pointFour[1], self.vData[3][3])
 
-    def storePoint(self, command, x, y):
+    def storePoint(self, command, x, y, pen):
         x = int(round(x))
         y = int(round(y))
         # skip when no change in movement
@@ -357,11 +364,15 @@ class hpglEncoder:
                     x = 0
                 if y < 0:
                     y = 0
+            # select correct pen
+            if self.lastPen != pen:
+                self.hpgl += ';SP%d' % pen
             # do not repeat command
-            if command == 'PD' and self.lastPoint[0] == 'PD':
+            if command == 'PD' and self.lastPoint[0] == 'PD' and self.lastPen == pen:
                 self.hpgl += ',%d,%d' % (x, y)
             else:
                 self.hpgl += ';%s%d,%d' % (command, x, y)
+            self.lastPen = pen
         self.lastPoint = [command, x, y]
 
 # vim: expandtab shiftwidth=4 tabstop=8 softtabstop=4 fileencoding=utf-8 textwidth=99
\ No newline at end of file
diff --git a/share/extensions/hpgl_output.inx b/share/extensions/hpgl_output.inx
index bfb3e3567..7fa900dc8 100644
--- a/share/extensions/hpgl_output.inx
+++ b/share/extensions/hpgl_output.inx
@@ -22,14 +22,16 @@
       </param>
       <param name="mirrorX" type="boolean" _gui-text="Mirror X axis" _gui-description="Check this to mirror the X axis (Default: Unchecked)">false</param>
       <param name="mirrorY" type="boolean" _gui-text="Mirror Y axis" _gui-description="Check this to mirror the Y axis (Default: Unchecked)">false</param>
-      <param name="center"  type="boolean" _gui-text="Center zero point" _gui-description="Check this if your plotter uses a centered zero point (Default: Unchecked)">false</param>
+      <param name="center" type="boolean" _gui-text="Center zero point" _gui-description="Check this if your plotter uses a centered zero point (Default: Unchecked)">false</param>
+      <param name="space" type="description">&#xa0;</param>
+      <_param name="multiplePensHelp" type="description">If you want to use multiple pens on your pen plotter create one layer for each pen, name the layers "Pen 1", "Pen 2", etc., and put your drawings in the corresponding layers. This overrules the pen number option above.</_param>
     </page>
     <page name="overcutToolOffset" _gui-text="Plot Features ">
-      <param name="overcut"    type="float" min="0.0" max="100.0" precision="2" _gui-text="Overcut (mm):" _gui-description="The distance in mm that will be cut over the starting point of the path to prevent open paths, set to 0.0 to omit command (Default: 1.00)">1.00</param>
-      <param name="toolOffset" type="float" min="0.0" max="20.0"  precision="2" _gui-text="Tool offset (mm):" _gui-description="The offset from the tool tip to the tool axis in mm, set to 0.0 to omit command (Default: 0.25)">0.25</param>
-      <param name="precut"     type="boolean" _gui-text="Use precut" _gui-description="Check this to cut a small line before the real drawing starts to correctly align the tool orientation. (Default: Checked)">true</param>
-      <param name="flat"       type="float" min="0.1" max="10.0"  precision="1" _gui-text="Curve flatness:" _gui-description="Curves are divided into lines, this number controls how fine the curves will be reproduced, the smaller the finer (Default: '1.2')">1.2</param>
-      <param name="autoAlign"  type="boolean" _gui-text="Auto align" _gui-description="Check this to auto align the drawing to the zero point (Plus the tool offset if used). If unchecked you have to make sure that all parts of your drawing are within the document border! (Default: Checked)">true</param>
+      <param name="overcut" type="float" min="0.0" max="100.0" precision="2" _gui-text="Overcut (mm):" _gui-description="The distance in mm that will be cut over the starting point of the path to prevent open paths, set to 0.0 to omit command (Default: 1.00)">1.00</param>
+      <param name="toolOffset" type="float" min="0.0" max="20.0" precision="2" _gui-text="Tool offset (mm):" _gui-description="The offset from the tool tip to the tool axis in mm, set to 0.0 to omit command (Default: 0.25)">0.25</param>
+      <param name="precut" type="boolean" _gui-text="Use precut" _gui-description="Check this to cut a small line before the real drawing starts to correctly align the tool orientation. (Default: Checked)">true</param>
+      <param name="flat" type="float" min="0.1" max="10.0" precision="1" _gui-text="Curve flatness:" _gui-description="Curves are divided into lines, this number controls how fine the curves will be reproduced, the smaller the finer (Default: '1.2')">1.2</param>
+      <param name="autoAlign" type="boolean" _gui-text="Auto align" _gui-description="Check this to auto align the drawing to the zero point (Plus the tool offset if used). If unchecked you have to make sure that all parts of your drawing are within the document border! (Default: Checked)">true</param>
     </page>
   </param>
   <_param name="settingsHelp" type="description">All these settings depend on the plotter you use, for more information please consult the manual or homepage for your plotter.</_param>
diff --git a/share/extensions/hpgl_output.py b/share/extensions/hpgl_output.py
index c6713cb65..fc4f248af 100755
--- a/share/extensions/hpgl_output.py
+++ b/share/extensions/hpgl_output.py
@@ -62,12 +62,12 @@ class HpglOutput(inkex.Effect):
                 type, value, traceback = sys.exc_info()
                 raise ValueError, ("", type, value), traceback
         # convert raw HPGL to HPGL
-        hpglInit = 'IN;SP%d' % self.options.pen
+        hpglInit = 'IN'
         if self.options.force > 0:
             hpglInit += ';FS%d' % self.options.force
         if self.options.speed > 0:
             hpglInit += ';VS%d' % self.options.speed
-        self.hpgl = hpglInit + self.hpgl + ';PU0,0;SP0;IN;'
+        self.hpgl = hpglInit + self.hpgl + ';SP0;PU0,0;IN; '
 
     def output(self):
         # print to file
diff --git a/share/extensions/plotter.inx b/share/extensions/plotter.inx
index 5a6d8ce06..17b2ff185 100644
--- a/share/extensions/plotter.inx
+++ b/share/extensions/plotter.inx
@@ -27,7 +27,25 @@
         <item value="57600">57600</item>
         <item value="115200">115200</item>
       </param>
-      <param name="flowControl" type="enum" _gui-text="Flow control:" _gui-description="The Software / Hardware flow control of your serial connection (Default: Software)">
+      <param name="serialByteSize" type="enum" _gui-text="Serial byte size:" _gui-description="The Byte size of your serial connection, 99% of all plotters use the default setting (Default: 8 Bits)">
+        <item value="eight">8 Bits</item>
+        <item value="seven">7 Bits</item>
+        <item value="six">6 Bits</item>
+        <item value="five">5 Bits</item>
+      </param>
+      <param name="serialStopBits" type="enum" _gui-text="Serial stop bits:" _gui-description="The Stop bits of your serial connection, 99% of all plotters use the default setting (Default: 1 Bit)">
+        <item value="one">1 Bit</item>
+        <item value="onePointFive">1.5 Bits</item>
+        <item value="two">2 Bits</item>
+      </param>
+      <param name="serialParity" type="enum" _gui-text="Serial parity:" _gui-description="The Parity of your serial connection, 99% of all plotters use the default setting (Default: None)">
+        <item value="none">None</item>
+        <item value="even">Even</item>
+        <item value="odd">Odd</item>
+        <item value="mark">Mark</item>
+        <item value="space">Space</item>
+      </param>
+      <param name="serialFlowControl" type="enum" _gui-text="Serial flow control:" _gui-description="The Software / Hardware flow control of your serial connection (Default: Software)">
         <_item value="xonxoff">Software (XON/XOFF)</_item>
         <_item value="rtscts">Hardware (RTS/CTS)</_item>
         <_item value="dsrdtrrtscts">Hardware (DSR/DTR + RTS/CTS)</_item>
@@ -47,9 +65,9 @@
     <page name="plotter" _gui-text="Plotter Settings ">
       <param name="resolutionX" type="float" min="1.0" max="4096.0" precision="1" _gui-text="Resolution X (dpi):" _gui-description="The amount of steps the plotter moves if it moves for 1 inch on the X axis (Default: 1016.0)">1016.0</param>
       <param name="resolutionY" type="float" min="1.0" max="4096.0" precision="1" _gui-text="Resolution Y (dpi):" _gui-description="The amount of steps the plotter moves if it moves for 1 inch on the Y axis (Default: 1016.0)">1016.0</param>
-      <param name="pen"         type="int"   min="0"   max="99"    _gui-text="Pen number:" _gui-description="The number of the pen (tool) to use (Standard: '1')">1</param>
-      <param name="force"       type="int"   min="0"   max="1000"  _gui-text="Pen force (g):" _gui-description="The amount of force pushing down the pen in grams, set to 0 to omit command; most plotters ignore this command (Default: 0)">0</param>
-      <param name="speed"       type="int"   min="0"   max="10000" _gui-text="Pen speed (cm/s or mm/s):" _gui-description="The speed the pen will move with in centimeters or millimeters per second (depending on your plotter model), set to 0 to omit command. Most plotters ignore this command. (Default: 0)">0</param>
+      <param name="pen" type="int" min="0" max="99" _gui-text="Pen number:" _gui-description="The number of the pen (tool) to use (Standard: '1')">1</param>
+      <param name="force" type="int" min="0" max="1000" _gui-text="Pen force (g):" _gui-description="The amount of force pushing down the pen in grams, set to 0 to omit command; most plotters ignore this command (Default: 0)">0</param>
+      <param name="speed" type="int" min="0" max="10000" _gui-text="Pen speed (cm/s or mm/s):" _gui-description="The speed the pen will move with in centimeters or millimeters per second (depending on your plotter model), set to 0 to omit command. Most plotters ignore this command. (Default: 0)">0</param>
       <param name="orientation" type="enum" _gui-text="Rotation (°, clockwise):" _gui-description="Rotation of the drawing (Default: 0°)">
         <item value="0">0</item>
         <item value="90">90</item>
@@ -58,16 +76,18 @@
       </param>
       <param name="mirrorX" type="boolean" _gui-text="Mirror X axis" _gui-description="Check this to mirror the X axis (Default: Unchecked)">false</param>
       <param name="mirrorY" type="boolean" _gui-text="Mirror Y axis" _gui-description="Check this to mirror the Y axis (Default: Unchecked)">false</param>
-      <param name="center"  type="boolean" _gui-text="Center zero point" _gui-description="Check this if your plotter uses a centered zero point (Default: Unchecked)">false</param>
+      <param name="center" type="boolean" _gui-text="Center zero point" _gui-description="Check this if your plotter uses a centered zero point (Default: Unchecked)">false</param>
+      <param name="space" type="description">&#xa0;</param>
+      <_param name="multiplePensHelp" type="description">If you want to use multiple pens on your pen plotter create one layer for each pen, name the layers "Pen 1", "Pen 2", etc., and put your drawings in the corresponding layers. This overrules the pen number option above.</_param>
     </page>
     <page name="misc" _gui-text="Plot Features ">
-      <param name="overcut"    type="float" min="0.0" max="100.0" precision="2" _gui-text="Overcut (mm):" _gui-description="The distance in mm that will be cut over the starting point of the path to prevent open paths, set to 0.0 to omit command (Default: 1.00)">1.00</param>
-      <param name="toolOffset" type="float" min="0.0" max="20.0"  precision="2" _gui-text="Tool offset (mm):" _gui-description="The offset from the tool tip to the tool axis in mm, set to 0.0 to omit command (Default: 0.25)">0.25</param>
-      <param name="precut"     type="boolean" _gui-text="Use precut" _gui-description="Check this to cut a small line before the real drawing starts to correctly align the tool orientation. (Default: Checked)">true</param>
-      <param name="flat"       type="float" min="0.1" max="10.0"  precision="1" _gui-text="Curve flatness:" _gui-description="Curves are divided into lines, this number controls how fine the curves will be reproduced, the smaller the finer (Default: '1.2')">1.2</param>
-      <param name="autoAlign"  type="boolean" _gui-text="Auto align" _gui-description="Check this to auto align the drawing to the zero point (Plus the tool offset if used). If unchecked you have to make sure that all parts of your drawing are within the document border! (Default: Checked)">true</param>
-      <param name="space"      type="description">&#xa0;</param>
-      <param name="debug"      type="boolean" _gui-text="Show debug information" _gui-description="Check this to get verbose information about the plot without actually sending something to the plotter (A.k.a. data dump) (Default: Unchecked)">false</param>
+      <param name="overcut" type="float" min="0.0" max="100.0" precision="2" _gui-text="Overcut (mm):" _gui-description="The distance in mm that will be cut over the starting point of the path to prevent open paths, set to 0.0 to omit command (Default: 1.00)">1.00</param>
+      <param name="toolOffset" type="float" min="0.0" max="20.0" precision="2" _gui-text="Tool offset (mm):" _gui-description="The offset from the tool tip to the tool axis in mm, set to 0.0 to omit command (Default: 0.25)">0.25</param>
+      <param name="precut" type="boolean" _gui-text="Use precut" _gui-description="Check this to cut a small line before the real drawing starts to correctly align the tool orientation. (Default: Checked)">true</param>
+      <param name="flat" type="float" min="0.1" max="10.0" precision="1" _gui-text="Curve flatness:" _gui-description="Curves are divided into lines, this number controls how fine the curves will be reproduced, the smaller the finer (Default: '1.2')">1.2</param>
+      <param name="autoAlign" type="boolean" _gui-text="Auto align" _gui-description="Check this to auto align the drawing to the zero point (Plus the tool offset if used). If unchecked you have to make sure that all parts of your drawing are within the document border! (Default: Checked)">true</param>
+      <param name="space" type="description">&#xa0;</param>
+      <param name="debug" type="boolean" _gui-text="Show debug information" _gui-description="Check this to get verbose information about the plot without actually sending something to the plotter (A.k.a. data dump) (Default: Unchecked)">false</param>
     </page>
   </param>
   <_param name="settingsHelp" type="description">All these settings depend on the plotter you use, for more information please consult the manual or homepage for your plotter.</_param>
diff --git a/share/extensions/plotter.py b/share/extensions/plotter.py
index 7e24d0824..c0f180f60 100644
--- a/share/extensions/plotter.py
+++ b/share/extensions/plotter.py
@@ -34,27 +34,30 @@ class Plot(inkex.Effect):
 
     def __init__(self):
         inkex.Effect.__init__(self)
-        self.OptionParser.add_option('--tab',             action='store', type='string',  dest='tab')
-        self.OptionParser.add_option('--serialPort',      action='store', type='string',  dest='serialPort',      default='COM1',  help='Serial port')
-        self.OptionParser.add_option('--serialBaudRate',  action='store', type='string',  dest='serialBaudRate',  default='9600',  help='Serial Baud rate')
-        self.OptionParser.add_option('--flowControl',     action='store', type='string',  dest='flowControl',     default='0',     help='Flow control')
-        self.OptionParser.add_option('--commandLanguage', action='store', type='string',  dest='commandLanguage', default='hpgl',  help='Command Language')
-        self.OptionParser.add_option('--initCommands',    action='store', type='string',  dest='initCommands',    default='',      help='Initialization commands')
-        self.OptionParser.add_option('--resolutionX',     action='store', type='float',   dest='resolutionX',     default=1016.0,  help='Resolution X (dpi)')
-        self.OptionParser.add_option('--resolutionY',     action='store', type='float',   dest='resolutionY',     default=1016.0,  help='Resolution Y (dpi)')
-        self.OptionParser.add_option('--pen',             action='store', type='int',     dest='pen',             default=1,       help='Pen number')
-        self.OptionParser.add_option('--force',           action='store', type='int',     dest='force',           default=24,      help='Pen force (g)')
-        self.OptionParser.add_option('--speed',           action='store', type='int',     dest='speed',           default=20,      help='Pen speed (cm/s)')
-        self.OptionParser.add_option('--orientation',     action='store', type='string',  dest='orientation',     default='90',    help='Rotation (Clockwise)')
-        self.OptionParser.add_option('--mirrorX',         action='store', type='inkbool', dest='mirrorX',         default='FALSE', help='Mirror X axis')
-        self.OptionParser.add_option('--mirrorY',         action='store', type='inkbool', dest='mirrorY',         default='FALSE', help='Mirror Y axis')
-        self.OptionParser.add_option('--center',          action='store', type='inkbool', dest='center',          default='FALSE', help='Center zero point')
-        self.OptionParser.add_option('--overcut',         action='store', type='float',   dest='overcut',         default=1.0,     help='Overcut (mm)')
-        self.OptionParser.add_option('--toolOffset',      action='store', type='float',   dest='toolOffset',      default=0.25,    help='Tool offset (mm)')
-        self.OptionParser.add_option('--precut',          action='store', type='inkbool', dest='precut',          default='TRUE',  help='Use precut')
-        self.OptionParser.add_option('--flat',            action='store', type='float',   dest='flat',            default=1.2,     help='Curve flatness')
-        self.OptionParser.add_option('--autoAlign',       action='store', type='inkbool', dest='autoAlign',       default='TRUE',  help='Auto align')
-        self.OptionParser.add_option('--debug',           action='store', type='inkbool', dest='debug',           default='FALSE', help='Show debug information')
+        self.OptionParser.add_option('--tab',               action='store', type='string',  dest='tab')
+        self.OptionParser.add_option('--serialPort',        action='store', type='string',  dest='serialPort',        default='COM1',  help='Serial port')
+        self.OptionParser.add_option('--serialBaudRate',    action='store', type='string',  dest='serialBaudRate',    default='9600',  help='Serial Baud rate')
+        self.OptionParser.add_option('--serialByteSize',    action='store', type='string',  dest='serialByteSize',    default='eight', help='Serial byte size')
+        self.OptionParser.add_option('--serialStopBits',    action='store', type='string',  dest='serialStopBits',    default='one',   help='Serial stop bits')
+        self.OptionParser.add_option('--serialParity',      action='store', type='string',  dest='serialParity',      default='none',  help='Serial parity')
+        self.OptionParser.add_option('--serialFlowControl', action='store', type='string',  dest='serialFlowControl', default='0',     help='Flow control')
+        self.OptionParser.add_option('--commandLanguage',   action='store', type='string',  dest='commandLanguage',   default='hpgl',  help='Command Language')
+        self.OptionParser.add_option('--initCommands',      action='store', type='string',  dest='initCommands',      default='',      help='Initialization commands')
+        self.OptionParser.add_option('--resolutionX',       action='store', type='float',   dest='resolutionX',       default=1016.0,  help='Resolution X (dpi)')
+        self.OptionParser.add_option('--resolutionY',       action='store', type='float',   dest='resolutionY',       default=1016.0,  help='Resolution Y (dpi)')
+        self.OptionParser.add_option('--pen',               action='store', type='int',     dest='pen',               default=1,       help='Pen number')
+        self.OptionParser.add_option('--force',             action='store', type='int',     dest='force',             default=24,      help='Pen force (g)')
+        self.OptionParser.add_option('--speed',             action='store', type='int',     dest='speed',             default=20,      help='Pen speed (cm/s)')
+        self.OptionParser.add_option('--orientation',       action='store', type='string',  dest='orientation',       default='90',    help='Rotation (Clockwise)')
+        self.OptionParser.add_option('--mirrorX',           action='store', type='inkbool', dest='mirrorX',           default='FALSE', help='Mirror X axis')
+        self.OptionParser.add_option('--mirrorY',           action='store', type='inkbool', dest='mirrorY',           default='FALSE', help='Mirror Y axis')
+        self.OptionParser.add_option('--center',            action='store', type='inkbool', dest='center',            default='FALSE', help='Center zero point')
+        self.OptionParser.add_option('--overcut',           action='store', type='float',   dest='overcut',           default=1.0,     help='Overcut (mm)')
+        self.OptionParser.add_option('--toolOffset',        action='store', type='float',   dest='toolOffset',        default=0.25,    help='Tool offset (mm)')
+        self.OptionParser.add_option('--precut',            action='store', type='inkbool', dest='precut',            default='TRUE',  help='Use precut')
+        self.OptionParser.add_option('--flat',              action='store', type='float',   dest='flat',              default=1.2,     help='Curve flatness')
+        self.OptionParser.add_option('--autoAlign',         action='store', type='inkbool', dest='autoAlign',         default='TRUE',  help='Auto align')
+        self.OptionParser.add_option('--debug',             action='store', type='inkbool', dest='debug',             default='FALSE', help='Show debug information')
 
     def effect(self):
         # get hpgl data
@@ -98,12 +101,12 @@ class Plot(inkex.Effect):
 
     def convertToHpgl(self):
         # convert raw HPGL to HPGL
-        hpglInit = 'IN;SP%d' % self.options.pen
+        hpglInit = 'IN'
         if self.options.force > 0:
             hpglInit += ';FS%d' % self.options.force
         if self.options.speed > 0:
             hpglInit += ';VS%d' % self.options.speed
-        self.hpgl = hpglInit + self.hpgl + ';PU0,0;SP0;IN; '
+        self.hpgl = hpglInit + self.hpgl + ';SP0;PU0,0;IN; '
 
     def convertToDmpl(self):
         # convert HPGL to DMPL
@@ -119,22 +122,23 @@ class Plot(inkex.Effect):
         # Z = Reset plotter
         # n,n, = Coordinate pair
         self.hpgl = self.hpgl.replace(';', ',')
+        self.hpgl = self.hpgl.replace('SP', 'P')
         self.hpgl = self.hpgl.replace('PU', 'U')
         self.hpgl = self.hpgl.replace('PD', 'D')
-        dmplInit = ';:HAL0P%d' % self.options.pen
+        dmplInit = ';:HAL0'
         if self.options.speed > 0:
             dmplInit += 'V%d' % self.options.speed
         dmplInit += 'EC1'
-        self.hpgl = dmplInit + self.hpgl[1:] + ',U0,0,P0Z '
+        self.hpgl = dmplInit + self.hpgl[1:] + ',P0,U0,0,Z '
 
     def convertToKNK(self):
         # convert HPGL to KNK Plotter Language
-        hpglInit = 'ZG;SP%d' % self.options.pen
+        hpglInit = 'ZG'
         if self.options.force > 0:
             hpglInit += ';FS%d' % self.options.force
         if self.options.speed > 0:
             hpglInit += ';VS%d' % self.options.speed
-        self.hpgl = hpglInit + self.hpgl + ';PU0,0;SP0;@ '
+        self.hpgl = hpglInit + self.hpgl + ';SP0;PU0,0;@ '
 
     def sendHpglToSerial(self):
         # gracefully exit script when pySerial is missing
@@ -146,17 +150,49 @@ class Plot(inkex.Effect):
                 + "\n2. Extract the \"serial\" subfolder from the zip to the following folder: C:\\[Program files]\\inkscape\\python\\Lib\\"
                 + "\n3. Restart Inkscape."))
             return
-        # send data to plotter
+        # init serial framework
         mySerial = serial.Serial()
+        # set serial port
         mySerial.port = self.options.serialPort
+        # set baudrate
         mySerial.baudrate = self.options.serialBaudRate
+        # set bytesize
+        if self.options.serialByteSize == 'five':
+            mySerial.bytesize = serial.FIVEBITS
+        if self.options.serialByteSize == 'six':
+            mySerial.bytesize = serial.SIXBITS
+        if self.options.serialByteSize == 'seven':
+            mySerial.bytesize = serial.SEVENBITS
+        if self.options.serialByteSize == 'eight':
+            mySerial.bytesize = serial.EIGHTBITS
+        # set stopbits
+        if self.options.serialStopBits == 'one':
+            mySerial.stopbits = serial.STOPBITS_ONE
+        if self.options.serialStopBits == 'onePointFive':
+            mySerial.stopbits = serial.STOPBITS_ONE_POINT_FIVE
+        if self.options.serialStopBits == 'two':
+            mySerial.stopbits = serial.STOPBITS_TWO
+        # set parity
+        if self.options.serialParity == 'none':
+            mySerial.parity = serial.PARITY_NONE
+        if self.options.serialParity == 'even':
+            mySerial.parity = serial.PARITY_EVEN
+        if self.options.serialParity == 'odd':
+            mySerial.parity = serial.PARITY_ODD
+        if self.options.serialParity == 'mark':
+            mySerial.parity = serial.PARITY_MARK
+        if self.options.serialParity == 'space':
+            mySerial.parity = serial.PARITY_SPACE
+        # set short timeout to avoid locked up interface
         mySerial.timeout = 0.1
-        if self.options.flowControl == 'xonxoff':
+        # set flow control
+        if self.options.serialFlowControl == 'xonxoff':
             mySerial.xonxoff = True
-        if self.options.flowControl == 'rtscts' or self.options.flowControl == 'dsrdtrrtscts':
+        if self.options.serialFlowControl == 'rtscts' or self.options.serialFlowControl == 'dsrdtrrtscts':
             mySerial.rtscts = True
-        if self.options.flowControl == 'dsrdtrrtscts':
+        if self.options.serialFlowControl == 'dsrdtrrtscts':
             mySerial.dsrdtr = True
+        # try to establish connection
         try:
             mySerial.open()
         except Exception as inst:
@@ -166,6 +202,7 @@ class Plot(inkex.Effect):
             else:
                 type, value, traceback = sys.exc_info()
                 raise ValueError, ('', type, value), traceback
+        # send data to plotter
         if self.options.initCommands != '':
             mySerial.write(self.options.initCommands.decode('string_escape'))
         mySerial.write(self.hpgl)
@@ -177,7 +214,10 @@ class Plot(inkex.Effect):
         inkex.errormsg("---------------------------------\nDebug information\n---------------------------------\n\nSettings:\n")
         inkex.errormsg('  Serial Port: ' + self.options.serialPort)
         inkex.errormsg('  Serial baud rate: ' + self.options.serialBaudRate)
-        inkex.errormsg('  Flow control: ' + self.options.flowControl)
+        inkex.errormsg('  Serial byte size: ' + self.options.serialByteSize + ' Bits')
+        inkex.errormsg('  Serial stop bits: ' + self.options.serialStopBits + ' Bits')
+        inkex.errormsg('  Serial parity: ' + self.options.serialParity)
+        inkex.errormsg('  Serial Flow control: ' + self.options.serialFlowControl)
         inkex.errormsg('  Command language: ' + self.options.commandLanguage)
         inkex.errormsg('  Initialization commands: ' + self.options.initCommands)
         inkex.errormsg('  Resolution X (dpi): ' + str(self.options.resolutionX))
@@ -223,7 +263,7 @@ class Plot(inkex.Effect):
         inkex.errormsg('  Flatness: ' + str(debugObject.flat) + ' plotter steps')
         inkex.errormsg('  Tool offset flatness: ' + str(debugObject.toolOffsetFlat) + ' plotter steps')
         inkex.errormsg("\n" + self.options.commandLanguage + " data:\n")
-        inkex.errormsg(self.hpgl)
+        inkex.errormsg(self.options.initCommands + self.hpgl)
 
 if __name__ == '__main__':
     # start extension
diff --git a/src/live_effects/lpe-bspline.cpp b/src/live_effects/lpe-bspline.cpp
index 5d5a6e616..ecbfef76a 100644
--- a/src/live_effects/lpe-bspline.cpp
+++ b/src/live_effects/lpe-bspline.cpp
@@ -15,26 +15,26 @@
 namespace Inkscape {
 namespace LivePathEffect {
 
-const double handleCubicGap = 0.01;
-const double noPower = 0.0;
-const double defaultStartPower = 0.3334;
-const double defaultEndPower = 0.6667;
+const double HANDLE_CUBIC_GAP = 0.01;
+const double NO_POWER = 0.0;
+const double DEFAULT_START_POWER = 0.3334;
+const double DEFAULT_END_POWER = 0.6667;
 
 LPEBSpline::LPEBSpline(LivePathEffectObject *lpeobject)
     : Effect(lpeobject),
       steps(_("Steps with CTRL:"), _("Change number of steps with CTRL pressed"), "steps", &wr, this, 2),
       helper_size(_("Helper size:"), _("Helper size"), "helper_size", &wr, this, 0),
-      ignoreCusp(_("Ignore cusp nodes"), _("Change ignoring cusp nodes"), "ignoreCusp", &wr, this, true),
-      onlySelected(_("Change only selected nodes"), _("Change only selected nodes"), "onlySelected", &wr, this, false),
-      weight(_("Change weight:"), _("Change weight of the effect"), "weight", &wr, this, defaultStartPower)
+      ignore_cusp(_("Ignore cusp nodes"), _("Change ignoring cusp nodes"), "ignore_cusp", &wr, this, true),
+      only_selected(_("Change only selected nodes"), _("Change only selected nodes"), "only_selected", &wr, this, false),
+      weight(_("Change weight:"), _("Change weight of the effect"), "weight", &wr, this, DEFAULT_START_POWER)
 {
     registerParameter(&weight);
     registerParameter(&steps);
     registerParameter(&helper_size);
-    registerParameter(&ignoreCusp);
-    registerParameter(&onlySelected);
+    registerParameter(&ignore_cusp);
+    registerParameter(&only_selected);
 
-    weight.param_set_range(noPower, 1);
+    weight.param_set_range(NO_POWER, 1);
     weight.param_set_increments(0.1, 0.1);
     weight.param_set_digits(4);
 
@@ -51,7 +51,7 @@ LPEBSpline::~LPEBSpline() {}
 
 void LPEBSpline::doBeforeEffect (SPLPEItem const* /*lpeitem*/)
 {
-    if(!hp.empty()){
+    if(!hp.empty()) {
         hp.clear();
     }
 }
@@ -69,7 +69,7 @@ void LPEBSpline::doOnApply(SPLPEItem const* lpeitem)
 void LPEBSpline::doEffect(SPCurve *curve)
 {
 
-    if (curve->get_segment_count() < 1){
+    if (curve->get_segment_count() < 1) {
         return;
     }
     // Make copy of old path as it is changed during processing
@@ -79,22 +79,22 @@ void LPEBSpline::doEffect(SPCurve *curve)
 
     for (Geom::PathVector::const_iterator path_it = original_pathv.begin();
             path_it != original_pathv.end(); ++path_it) {
-        if (path_it->empty()){
+        if (path_it->empty()) {
             continue;
         }
         hp.push_back(*path_it);
         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();
+        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
@@ -110,27 +110,27 @@ void LPEBSpline::doEffect(SPCurve *curve)
                 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(defaultStartPower);
+                    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(defaultEndPower);
+                    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;
@@ -140,14 +140,14 @@ void LPEBSpline::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(defaultStartPower);
+                        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;
@@ -156,14 +156,14 @@ void LPEBSpline::doEffect(SPCurve *curve)
                 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;
@@ -171,41 +171,41 @@ void LPEBSpline::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;
-                node = SBasisHelper.valueAt(0.5);
-                nCurve->curveto(pointAt1, pointAt2, node);
-                nCurve->move_endpoints(node, node);
+                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);
             }
-            if(!are_near(node,curve_it1->finalPoint()) && helper_size > 0.0){
+            if(!are_near(node,curve_it1->finalPoint()) && helper_size > 0.0) {
                 drawHandle(node, helper_size);
             }
             ++curve_it1;
@@ -213,15 +213,15 @@ void LPEBSpline::doEffect(SPCurve *curve)
         }
         //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;
     }
-    if(helper_size > 0.0){
+    if(helper_size > 0.0) {
         Geom::PathVector const pathv = curve->get_pathvector();
-         hp.push_back(pathv[0]);
+        hp.push_back(pathv[0]);
     }
 }
 
@@ -256,40 +256,40 @@ Gtk::Widget *LPEBSpline::newWidget()
             Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
             if (param->param_key == "weight") {
                 Gtk::HBox * buttons = Gtk::manage(new Gtk::HBox(true,0));
-                Gtk::Button *defaultWeight =
+                Gtk::Button *default_weight =
                     Gtk::manage(new Gtk::Button(Glib::ustring(_("Default weight"))));
-                defaultWeight->signal_clicked()
+                default_weight->signal_clicked()
                 .connect(sigc::mem_fun(*this, &LPEBSpline::toDefaultWeight));
-                buttons->pack_start(*defaultWeight, true, true, 2);
-                Gtk::Button *makeCusp =
+                buttons->pack_start(*default_weight, true, true, 2);
+                Gtk::Button *make_cusp =
                     Gtk::manage(new Gtk::Button(Glib::ustring(_("Make cusp"))));
-                makeCusp->signal_clicked()
+                make_cusp->signal_clicked()
                 .connect(sigc::mem_fun(*this, &LPEBSpline::toMakeCusp));
-                buttons->pack_start(*makeCusp, true, true, 2);
+                buttons->pack_start(*make_cusp, true, true, 2);
                 vbox->pack_start(*buttons, true, true, 2);
             }
             if (param->param_key == "weight" || param->param_key == "steps") {
-                Inkscape::UI::Widget::Scalar *widgRegistered =
+                Inkscape::UI::Widget::Scalar *widg_registered =
                     Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
-                widgRegistered->signal_value_changed()
+                widg_registered->signal_value_changed()
                 .connect(sigc::mem_fun(*this, &LPEBSpline::toWeight));
-                widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
+                widg = dynamic_cast<Gtk::Widget *>(widg_registered);
                 if (widg) {
-                    Gtk::HBox * scalarParameter = dynamic_cast<Gtk::HBox *>(widg);
-                    std::vector< Gtk::Widget* > childList = scalarParameter->get_children();
-                    Gtk::Entry* entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
-                    entryWidg->set_width_chars(6);
+                    Gtk::HBox * hbox_weight_steps = dynamic_cast<Gtk::HBox *>(widg);
+                    std::vector< Gtk::Widget* > childList = hbox_weight_steps->get_children();
+                    Gtk::Entry* entry_widget = dynamic_cast<Gtk::Entry *>(childList[1]);
+                    entry_widget->set_width_chars(6);
                 }
             }
-            if (param->param_key == "onlySelected") {
-                Gtk::CheckButton *widgRegistered =
+            if (param->param_key == "only_selected") {
+                Gtk::CheckButton *widg_registered =
                     Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
-                widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
+                widg = dynamic_cast<Gtk::Widget *>(widg_registered);
             }
-            if (param->param_key == "ignoreCusp") {
-                Gtk::CheckButton *widgRegistered =
+            if (param->param_key == "ignore_cusp") {
+                Gtk::CheckButton *widg_registered =
                     Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
-                widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
+                widg = dynamic_cast<Gtk::Widget *>(widg_registered);
             }
             Glib::ustring *tip = param->param_getTooltip();
             if (widg) {
@@ -310,12 +310,12 @@ Gtk::Widget *LPEBSpline::newWidget()
 
 void LPEBSpline::toDefaultWeight()
 {
-    changeWeight(defaultStartPower);
+    changeWeight(DEFAULT_START_POWER);
 }
 
 void LPEBSpline::toMakeCusp()
 {
-    changeWeight(noPower);
+    changeWeight(NO_POWER);
 }
 
 void LPEBSpline::toWeight()
@@ -323,22 +323,22 @@ void LPEBSpline::toWeight()
     changeWeight(weight);
 }
 
-void LPEBSpline::changeWeight(double weightValue)
+void LPEBSpline::changeWeight(double weight_ammount)
 {
     SPPath *path = dynamic_cast<SPPath *>(sp_lpe_item);
-    if(path){
+    if(path) {
         SPCurve *curve = path->get_curve_for_edit();
-        LPEBSpline::doBSplineFromWidget(curve, weightValue);
+        doBSplineFromWidget(curve, weight_ammount);
         gchar *str = sp_svg_write_path(curve->get_pathvector());
         path->getRepr()->setAttribute("inkscape:original-d", str);
     }
 }
 
-void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue)
+void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weight_ammount)
 {
     using Geom::X;
     using Geom::Y;
-    
+
     if (curve->get_segment_count() < 1)
         return;
     // Make copy of old path as it is changed during processing
@@ -348,20 +348,20 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue)
     for (Geom::PathVector::const_iterator path_it = original_pathv.begin();
             path_it != original_pathv.end(); ++path_it) {
 
-        if (path_it->empty()){
+        if (path_it->empty()) {
             continue;
         }
         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::Point pointAt0(0, 0);
-        Geom::Point pointAt1(0, 0);
-        Geom::Point pointAt2(0, 0);
-        Geom::Point pointAt3(0, 0);
-        Geom::D2<Geom::SBasis> SBasisIn;
-        Geom::D2<Geom::SBasis> SBasisOut;
+        SPCurve *curve_n = new SPCurve();
+        Geom::Point point_at0(0, 0);
+        Geom::Point point_at1(0, 0);
+        Geom::Point point_at2(0, 0);
+        Geom::Point point_at3(0, 0);
+        Geom::D2<Geom::SBasis> sbasis_in;
+        Geom::D2<Geom::SBasis> sbasis_out;
         Geom::CubicBezier const *cubic = NULL;
         if (path_it->closed()) {
             // if the path is closed, maybe we have to stop a bit earlier because the
@@ -377,120 +377,120 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue)
                 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);
-            pointAt0 = in->first_segment()->initialPoint();
-            pointAt3 = in->first_segment()->finalPoint();
-            SBasisIn = in->first_segment()->toSBasis();
-            if (!onlySelected) {
+            point_at0 = in->first_segment()->initialPoint();
+            point_at3 = in->first_segment()->finalPoint();
+            sbasis_in = in->first_segment()->toSBasis();
+            if (!only_selected) {
                 if (cubic) {
-                    if (!ignoreCusp || !Geom::are_near((*cubic)[1], pointAt0)) {
-                        pointAt1 = SBasisIn.valueAt(weightValue);
-                        if (weightValue != noPower) {
-                            pointAt1 =
-                                Geom::Point(pointAt1[X] + handleCubicGap, pointAt1[Y] + handleCubicGap);
+                    if (!ignore_cusp || !Geom::are_near((*cubic)[1], point_at0)) {
+                        point_at1 = sbasis_in.valueAt(weight_ammount);
+                        if (weight_ammount != NO_POWER) {
+                            point_at1 =
+                                Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP);
                         }
                     } else {
-                        pointAt1 = in->first_segment()->initialPoint();
+                        point_at1 = in->first_segment()->initialPoint();
                     }
-                    if (!ignoreCusp || !Geom::are_near((*cubic)[2], pointAt3)) {
-                        pointAt2 = SBasisIn.valueAt(1 - weightValue);
-                        if (weightValue != noPower) {
-                            pointAt2 =
-                                Geom::Point(pointAt2[X] + handleCubicGap, pointAt2[Y] + handleCubicGap);
+                    if (!ignore_cusp || !Geom::are_near((*cubic)[2], point_at3)) {
+                        point_at2 = sbasis_in.valueAt(1 - weight_ammount);
+                        if (weight_ammount != NO_POWER) {
+                            point_at2 =
+                                Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP);
                         }
                     } else {
-                        pointAt2 = in->first_segment()->finalPoint();
+                        point_at2 = in->first_segment()->finalPoint();
                     }
                 } else {
-                    if (!ignoreCusp && weightValue != noPower) {
-                        pointAt1 = SBasisIn.valueAt(weightValue);
-                        if (weightValue != noPower) {
-                            pointAt1 =
-                                Geom::Point(pointAt1[X] + handleCubicGap, pointAt1[Y] + handleCubicGap);
+                    if (!ignore_cusp && weight_ammount != NO_POWER) {
+                        point_at1 = sbasis_in.valueAt(weight_ammount);
+                        if (weight_ammount != NO_POWER) {
+                            point_at1 =
+                                Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP);
                         }
-                        pointAt2 = SBasisIn.valueAt(1 - weightValue);
-                        if (weightValue != noPower) {
-                            pointAt2 =
-                                Geom::Point(pointAt2[X] + handleCubicGap, pointAt2[Y] + handleCubicGap);
+                        point_at2 = sbasis_in.valueAt(1 - weight_ammount);
+                        if (weight_ammount != NO_POWER) {
+                            point_at2 =
+                                Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP);
                         }
                     } else {
-                        pointAt1 = in->first_segment()->initialPoint();
-                        pointAt2 = in->first_segment()->finalPoint();
+                        point_at1 = in->first_segment()->initialPoint();
+                        point_at2 = in->first_segment()->finalPoint();
                     }
                 }
             } else {
                 if (cubic) {
-                    if (!ignoreCusp || !Geom::are_near((*cubic)[1], pointAt0)) {
-                        if (isNodePointSelected(pointAt0)) {
-                            pointAt1 = SBasisIn.valueAt(weightValue);
-                            if (weightValue != noPower) {
-                                pointAt1 =
-                                    Geom::Point(pointAt1[X] + handleCubicGap, pointAt1[Y] + handleCubicGap);
+                    if (!ignore_cusp || !Geom::are_near((*cubic)[1], point_at0)) {
+                        if (isNodePointSelected(point_at0)) {
+                            point_at1 = sbasis_in.valueAt(weight_ammount);
+                            if (weight_ammount != NO_POWER) {
+                                point_at1 =
+                                    Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP);
                             }
                         } else {
-                            pointAt1 = (*cubic)[1];
+                            point_at1 = (*cubic)[1];
                         }
                     } else {
-                        pointAt1 = in->first_segment()->initialPoint();
+                        point_at1 = in->first_segment()->initialPoint();
                     }
-                    if (!ignoreCusp || !Geom::are_near((*cubic)[2], pointAt3)) {
-                        if (isNodePointSelected(pointAt3)) {
-                            pointAt2 = SBasisIn.valueAt(1 - weightValue);
-                            if (weightValue != noPower) {
-                                pointAt2 =
-                                    Geom::Point(pointAt2[X] + handleCubicGap, pointAt2[Y] + handleCubicGap);
+                    if (!ignore_cusp || !Geom::are_near((*cubic)[2], point_at3)) {
+                        if (isNodePointSelected(point_at3)) {
+                            point_at2 = sbasis_in.valueAt(1 - weight_ammount);
+                            if (weight_ammount != NO_POWER) {
+                                point_at2 =
+                                    Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP);
                             }
                         } else {
-                            pointAt2 = (*cubic)[2];
+                            point_at2 = (*cubic)[2];
                         }
                     } else {
-                        pointAt2 = in->first_segment()->finalPoint();
+                        point_at2 = in->first_segment()->finalPoint();
                     }
                 } else {
-                    if (!ignoreCusp && weightValue != noPower) {
-                        if (isNodePointSelected(pointAt0)) {
-                            pointAt1 = SBasisIn.valueAt(weightValue);
-                            pointAt1 =
-                                Geom::Point(pointAt1[X] + handleCubicGap, pointAt1[Y] + handleCubicGap);
+                    if (!ignore_cusp && weight_ammount != NO_POWER) {
+                        if (isNodePointSelected(point_at0)) {
+                            point_at1 = sbasis_in.valueAt(weight_ammount);
+                            point_at1 =
+                                Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP);
                         } else {
-                            pointAt1 = in->first_segment()->initialPoint();
+                            point_at1 = in->first_segment()->initialPoint();
                         }
-                        if (isNodePointSelected(pointAt3)) {
-                            pointAt2 = SBasisIn.valueAt(weightValue);
-                            pointAt2 =
-                                Geom::Point(pointAt2[X] + handleCubicGap, pointAt2[Y] + handleCubicGap);
+                        if (isNodePointSelected(point_at3)) {
+                            point_at2 = sbasis_in.valueAt(weight_ammount);
+                            point_at2 =
+                                Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP);
                         } else {
-                            pointAt2 = in->first_segment()->finalPoint();
+                            point_at2 = in->first_segment()->finalPoint();
                         }
                     } 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;
-            nCurve->curveto(pointAt1, pointAt2, pointAt3);
+            curve_n->curveto(point_at1, point_at2, point_at3);
             ++curve_it1;
             ++curve_it2;
         }
         if (path_it->closed()) {
-            nCurve->move_endpoints(path_it->begin()->initialPoint(),
+            curve_n->move_endpoints(path_it->begin()->initialPoint(),
                                    path_it->begin()->initialPoint());
         } else {
-            nCurve->move_endpoints(path_it->begin()->initialPoint(), pointAt3);
+            curve_n->move_endpoints(path_it->begin()->initialPoint(), point_at3);
         }
         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;
     }
 }
 
diff --git a/src/live_effects/lpe-bspline.h b/src/live_effects/lpe-bspline.h
index 8017e39ef..fc0f66353 100644
--- a/src/live_effects/lpe-bspline.h
+++ b/src/live_effects/lpe-bspline.h
@@ -18,7 +18,8 @@ public:
     LPEBSpline(LivePathEffectObject *lpeobject);
     virtual ~LPEBSpline();
 
-    virtual LPEPathFlashType pathFlashType() const {
+    virtual LPEPathFlashType pathFlashType() const
+    {
         return SUPPRESS_FLASH;
     }
     virtual void doOnApply(SPLPEItem const* lpeitem);
@@ -38,8 +39,8 @@ public:
 
 private:
     ScalarParam helper_size;
-    BoolParam ignoreCusp;
-    BoolParam onlySelected;
+    BoolParam ignore_cusp;
+    BoolParam only_selected;
     ScalarParam weight;
     Geom::PathVector hp;
 
diff --git a/src/live_effects/lpe-lattice2.cpp b/src/live_effects/lpe-lattice2.cpp
index 08bbbd504..abd6e7786 100644
--- a/src/live_effects/lpe-lattice2.cpp
+++ b/src/live_effects/lpe-lattice2.cpp
@@ -1,6 +1,6 @@
 /** \file
  * LPE <lattice2> implementation
- 
+
  */
 /*
  * Authors:
@@ -11,7 +11,7 @@
  *   ~suv
  *   Jabiertxo Arraiza
 *
-* Copyright (C) 2007-2008 Authors 
+* Copyright (C) 2007-2008 Authors
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
@@ -42,63 +42,63 @@ namespace LivePathEffect {
 
 LPELattice2::LPELattice2(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
-    horizontalMirror(_("Mirror movements in horizontal"), _("Mirror movements in horizontal"), "horizontalMirror", &wr, this, false),
-    verticalMirror(_("Mirror movements in vertical"), _("Mirror movements in vertical"), "verticalMirror", &wr, this, false),
-    grid_point0(_("Control 0:"), _("Control 0 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint0", &wr, this),
-    grid_point1(_("Control 1:"), _("Control 1 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint1", &wr, this),
-    grid_point2(_("Control 2:"), _("Control 2 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint2", &wr, this),
-    grid_point3(_("Control 3:"), _("Control 3 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint3", &wr, this),
-    grid_point4(_("Control 4:"), _("Control 4 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint4", &wr, this),
-    grid_point5(_("Control 5:"), _("Control 5 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint5", &wr, this),
-    grid_point6(_("Control 6:"), _("Control 6 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint6", &wr, this),
-    grid_point7(_("Control 7:"), _("Control 7 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint7", &wr, this),
-    grid_point8x9(_("Control 8x9:"), _("Control 8x9 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint8x9", &wr, this),
-    grid_point10x11(_("Control 10x11:"), _("Control 10x11 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint10x11", &wr, this),
-    grid_point12(_("Control 12:"), _("Control 12 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint12", &wr, this),
-    grid_point13(_("Control 13:"), _("Control 13 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint13", &wr, this),
-    grid_point14(_("Control 14:"), _("Control 14 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint14", &wr, this),
-    grid_point15(_("Control 15:"), _("Control 15 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint15", &wr, this),
-    grid_point16(_("Control 16:"), _("Control 16 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint16", &wr, this),
-    grid_point17(_("Control 17:"), _("Control 17 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint17", &wr, this),
-    grid_point18(_("Control 18:"), _("Control 18 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint18", &wr, this),
-    grid_point19(_("Control 19:"), _("Control 19 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint19", &wr, this),
-    grid_point20x21(_("Control 20x21:"), _("Control 20x21 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint20x21", &wr, this),
-    grid_point22x23(_("Control 22x23:"), _("Control 22x23 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint22x23", &wr, this),
-    grid_point24x26(_("Control 24x26:"), _("Control 24x26 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint24x26", &wr, this),
-    grid_point25x27(_("Control 25x27:"), _("Control 25x27 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint25x27", &wr, this),
-    grid_point28x30(_("Control 28x30:"), _("Control 28x30 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint28x30", &wr, this),
-    grid_point29x31(_("Control 29x31:"), _("Control 29x31 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint29x31", &wr, this),
-    grid_point32x33x34x35(_("Control 32x33x34x35:"), _("Control 32x33x34x35 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint32x33x34x35", &wr, this),
+    horizontal_mirror(_("Mirror movements in horizontal"), _("Mirror movements in horizontal"), "horizontal_mirror", &wr, this, false),
+    vertical_mirror(_("Mirror movements in vertical"), _("Mirror movements in vertical"), "vertical_mirror", &wr, this, false),
+    grid_point_0(_("Control 0:"), _("Control 0 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint0", &wr, this),
+    grid_point_1(_("Control 1:"), _("Control 1 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint1", &wr, this),
+    grid_point_2(_("Control 2:"), _("Control 2 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint2", &wr, this),
+    grid_point_3(_("Control 3:"), _("Control 3 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint3", &wr, this),
+    grid_point_4(_("Control 4:"), _("Control 4 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint4", &wr, this),
+    grid_point_5(_("Control 5:"), _("Control 5 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint5", &wr, this),
+    grid_point_6(_("Control 6:"), _("Control 6 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint6", &wr, this),
+    grid_point_7(_("Control 7:"), _("Control 7 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint7", &wr, this),
+    grid_point_8x9(_("Control 8x9:"), _("Control 8x9 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint8x9", &wr, this),
+    grid_point_10x11(_("Control 10x11:"), _("Control 10x11 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint10x11", &wr, this),
+    grid_point_12(_("Control 12:"), _("Control 12 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint12", &wr, this),
+    grid_point_13(_("Control 13:"), _("Control 13 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint13", &wr, this),
+    grid_point_14(_("Control 14:"), _("Control 14 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint14", &wr, this),
+    grid_point_15(_("Control 15:"), _("Control 15 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint15", &wr, this),
+    grid_point_16(_("Control 16:"), _("Control 16 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint16", &wr, this),
+    grid_point_17(_("Control 17:"), _("Control 17 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint17", &wr, this),
+    grid_point_18(_("Control 18:"), _("Control 18 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint18", &wr, this),
+    grid_point_19(_("Control 19:"), _("Control 19 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint19", &wr, this),
+    grid_point_20x21(_("Control 20x21:"), _("Control 20x21 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint20x21", &wr, this),
+    grid_point_22x23(_("Control 22x23:"), _("Control 22x23 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint22x23", &wr, this),
+    grid_point_24x26(_("Control 24x26:"), _("Control 24x26 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint24x26", &wr, this),
+    grid_point_25x27(_("Control 25x27:"), _("Control 25x27 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint25x27", &wr, this),
+    grid_point_28x30(_("Control 28x30:"), _("Control 28x30 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint28x30", &wr, this),
+    grid_point_29x31(_("Control 29x31:"), _("Control 29x31 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint29x31", &wr, this),
+    grid_point_32x33x34x35(_("Control 32x33x34x35:"), _("Control 32x33x34x35 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint32x33x34x35", &wr, this),
     expanded(false)
 {
     // register all your parameters here, so Inkscape knows which parameters this effect has:
-    registerParameter(&horizontalMirror);
-    registerParameter(&verticalMirror);
-    registerParameter(&grid_point0);
-    registerParameter(&grid_point1);
-    registerParameter(&grid_point2);
-    registerParameter(&grid_point3);
-    registerParameter(&grid_point4);
-    registerParameter(&grid_point5);
-    registerParameter(&grid_point6);
-    registerParameter(&grid_point7);
-    registerParameter(&grid_point8x9);
-    registerParameter(&grid_point10x11);
-    registerParameter(&grid_point12);
-    registerParameter(&grid_point13);
-    registerParameter(&grid_point14);
-    registerParameter(&grid_point15);
-    registerParameter(&grid_point16);
-    registerParameter(&grid_point17);
-    registerParameter(&grid_point18);
-    registerParameter(&grid_point19);
-    registerParameter(&grid_point20x21);
-    registerParameter(&grid_point22x23);
-    registerParameter(&grid_point24x26);
-    registerParameter(&grid_point25x27);
-    registerParameter(&grid_point28x30);
-    registerParameter(&grid_point29x31);
-    registerParameter(&grid_point32x33x34x35);
+    registerParameter(&horizontal_mirror);
+    registerParameter(&vertical_mirror);
+    registerParameter(&grid_point_0);
+    registerParameter(&grid_point_1);
+    registerParameter(&grid_point_2);
+    registerParameter(&grid_point_3);
+    registerParameter(&grid_point_4);
+    registerParameter(&grid_point_5);
+    registerParameter(&grid_point_6);
+    registerParameter(&grid_point_7);
+    registerParameter(&grid_point_8x9);
+    registerParameter(&grid_point_10x11);
+    registerParameter(&grid_point_12);
+    registerParameter(&grid_point_13);
+    registerParameter(&grid_point_14);
+    registerParameter(&grid_point_15);
+    registerParameter(&grid_point_16);
+    registerParameter(&grid_point_17);
+    registerParameter(&grid_point_18);
+    registerParameter(&grid_point_19);
+    registerParameter(&grid_point_20x21);
+    registerParameter(&grid_point_22x23);
+    registerParameter(&grid_point_24x26);
+    registerParameter(&grid_point_25x27);
+    registerParameter(&grid_point_28x30);
+    registerParameter(&grid_point_29x31);
+    registerParameter(&grid_point_32x33x34x35);
 }
 
 LPELattice2::~LPELattice2()
@@ -113,7 +113,7 @@ LPELattice2::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd
     PathVector cubic = pathv_to_cubicbezier(pathv);
     Geom::Piecewise<Geom::D2<Geom::SBasis> > const &pwd2_in_linear_and_cubic = paths_to_pw(cubic);
     D2<SBasis2d> sb2;
-    
+
     //Initialisation of the sb2
     for(unsigned dim = 0; dim < 2; dim++) {
         sb2[dim].us = 3;
@@ -125,46 +125,46 @@ LPELattice2::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd
     //Grouping the point params in a convenient vector
 
     std::vector<Geom::Point > handles(36);
-    
-    handles[0] = grid_point0;
-    handles[1] = grid_point1;
-    handles[2] = grid_point2;
-    handles[3] = grid_point3;
-    handles[4] = grid_point4;
-    handles[5] = grid_point5;
-    handles[6] = grid_point6;
-    handles[7] = grid_point7;
-    handles[8] = grid_point8x9;
-    handles[9] = grid_point8x9;
-    handles[10] = grid_point10x11;
-    handles[11] = grid_point10x11;
-    handles[12] = grid_point12;
-    handles[13] = grid_point13;
-    handles[14] = grid_point14;
-    handles[15] = grid_point15;
-    handles[16] = grid_point16;
-    handles[17] = grid_point17;
-    handles[18] = grid_point18;
-    handles[19] = grid_point19;
-    handles[20] = grid_point20x21;
-    handles[21] = grid_point20x21;
-    handles[22] = grid_point22x23;
-    handles[23] = grid_point22x23;
-    handles[24] = grid_point24x26;
-    handles[25] = grid_point25x27;
-    handles[26] = grid_point24x26;
-    handles[27] = grid_point25x27;
-    handles[28] = grid_point28x30;
-    handles[29] = grid_point29x31;
-    handles[30] = grid_point28x30;
-    handles[31] = grid_point29x31;
-    handles[32] = grid_point32x33x34x35;
-    handles[33] = grid_point32x33x34x35;
-    handles[34] = grid_point32x33x34x35;
-    handles[35] = grid_point32x33x34x35;
+
+    handles[0] = grid_point_0;
+    handles[1] = grid_point_1;
+    handles[2] = grid_point_2;
+    handles[3] = grid_point_3;
+    handles[4] = grid_point_4;
+    handles[5] = grid_point_5;
+    handles[6] = grid_point_6;
+    handles[7] = grid_point_7;
+    handles[8] = grid_point_8x9;
+    handles[9] = grid_point_8x9;
+    handles[10] = grid_point_10x11;
+    handles[11] = grid_point_10x11;
+    handles[12] = grid_point_12;
+    handles[13] = grid_point_13;
+    handles[14] = grid_point_14;
+    handles[15] = grid_point_15;
+    handles[16] = grid_point_16;
+    handles[17] = grid_point_17;
+    handles[18] = grid_point_18;
+    handles[19] = grid_point_19;
+    handles[20] = grid_point_20x21;
+    handles[21] = grid_point_20x21;
+    handles[22] = grid_point_22x23;
+    handles[23] = grid_point_22x23;
+    handles[24] = grid_point_24x26;
+    handles[25] = grid_point_25x27;
+    handles[26] = grid_point_24x26;
+    handles[27] = grid_point_25x27;
+    handles[28] = grid_point_28x30;
+    handles[29] = grid_point_29x31;
+    handles[30] = grid_point_28x30;
+    handles[31] = grid_point_29x31;
+    handles[32] = grid_point_32x33x34x35;
+    handles[33] = grid_point_32x33x34x35;
+    handles[34] = grid_point_32x33x34x35;
+    handles[35] = grid_point_32x33x34x35;
 
     Geom::Point origin = Geom::Point(boundingbox_X.min(),boundingbox_Y.min());
-      
+
     double width = boundingbox_X.extent();
     double height = boundingbox_Y.extent();
 
@@ -178,16 +178,16 @@ LPELattice2::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd
                     for(unsigned iu = 0; iu < 2; iu++) {
                         unsigned corner = iu + 2*iv;
                         unsigned i = ui + vi*sb2[dim].us;
-                        
+
                         //This is the offset from the Upperleft point
                         Geom::Point base(   (ui + iu*(4-2*ui))*width/4.,
                                             (vi + iv*(4-2*vi))*height/4.);
-                        
+
                         //Special action for corners
                         if(vi == 0 && ui == 0) {
                             base = Geom::Point(0,0);
                         }
-                        
+
                         // i = Upperleft corner of the considerated rectangle
                         // corner = actual corner of the rectangle
                         // origin = Upperleft point
@@ -198,7 +198,7 @@ LPELattice2::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd
             }
         }
     }
-   
+
     Piecewise<D2<SBasis> >  output;
     output.push_cut(0.);
     for(unsigned i = 0; i < pwd2_in_linear_and_cubic.size(); i++) {
@@ -228,28 +228,28 @@ LPELattice2::newWidget()
     vbox->set_homogeneous(false);
     vbox->set_spacing(6);
     Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false,0));
-    Gtk::VBox * vboxExpander = Gtk::manage( new Gtk::VBox(Effect::newWidget()) );
-    vboxExpander->set_border_width(0);
-    vboxExpander->set_spacing(2);
-    Gtk::Button * resetButton = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset grid"))));
-    resetButton->signal_clicked().connect(sigc::mem_fun (*this,&LPELattice2::resetGrid));
-    resetButton->set_size_request(140,30);
+    Gtk::VBox * vbox_expander = Gtk::manage( new Gtk::VBox(Effect::newWidget()) );
+    vbox_expander->set_border_width(0);
+    vbox_expander->set_spacing(2);
+    Gtk::Button * reset_button = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset grid"))));
+    reset_button->signal_clicked().connect(sigc::mem_fun (*this,&LPELattice2::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);
     std::vector<Parameter *>::iterator it = param_vector.begin();
     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 == "grid"){
+            if(param->param_key == "grid") {
                 widg = NULL;
             }
             Glib::ustring * tip = param->param_getTooltip();
             if (widg) {
-                if (param->param_key == "horizontalMirror" || param->param_key == "verticalMirror") {
+                if (param->param_key == "horizontal_mirror" || param->param_key == "vertical_mirror") {
                     vbox->pack_start(*widg, true, true, 2);
                 } else {
-                    vboxExpander->pack_start(*widg, true, true, 2);
+                    vbox_expander->pack_start(*widg, true, true, 2);
                 }
                 if (tip) {
                     widg->set_tooltip_text(*tip);
@@ -262,63 +262,65 @@ LPELattice2::newWidget()
 
         ++it;
     }
-     
+
     expander = Gtk::manage(new Gtk::Expander(Glib::ustring(_("Show Points"))));
-    expander->add(*vboxExpander);
+    expander->add(*vbox_expander);
     expander->set_expanded(expanded);
     vbox->pack_start(*expander, true, true, 2);
-    expander->property_expanded().signal_changed().connect(sigc::mem_fun(*this, &LPELattice2::on_expander_changed) );
+    expander->property_expanded().signal_changed().connect(sigc::mem_fun(*this, &LPELattice2::onExpanderChanged) );
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
 void
-LPELattice2::on_expander_changed()
+LPELattice2::onExpanderChanged()
 {
     expanded = expander->get_expanded();
-    if(expander->get_expanded()){
+    if(expander->get_expanded()) {
         expander->set_label (Glib::ustring(_("Hide Points")));
     } else {
         expander->set_label (Glib::ustring(_("Show Points")));
     }
 }
 void
-LPELattice2::vertical(PointParam &paramA, PointParam &paramB, Geom::Line vert){
-    Geom::Point A = paramA;
-    Geom::Point B = paramB;
+LPELattice2::vertical(PointParam &param_one, PointParam &param_two, Geom::Line vert)
+{
+    Geom::Point A = param_one;
+    Geom::Point B = param_two;
     double Y = (A[Geom::Y] + B[Geom::Y])/2;
     A[Geom::Y] = Y;
     B[Geom::Y] = Y;
     Geom::Point nearest = vert.pointAt(vert.nearestPoint(A));
-    double distA = Geom::distance(A,nearest);
-    double distB = Geom::distance(B,nearest);
-    double distanceMed = (distA + distB)/2;
-    if(A[Geom::X] > B[Geom::X]){
-        distanceMed *= -1;
+    double distance_one = Geom::distance(A,nearest);
+    double distance_two = Geom::distance(B,nearest);
+    double distance_middle = (distance_one + distance_two)/2;
+    if(A[Geom::X] > B[Geom::X]) {
+        distance_middle *= -1;
     }
-    A[Geom::X] = nearest[Geom::X] - distanceMed;
-    B[Geom::X] = nearest[Geom::X] + distanceMed;
-    paramA.param_setValue(A, true);
-    paramB.param_setValue(B, true);
+    A[Geom::X] = nearest[Geom::X] - distance_middle;
+    B[Geom::X] = nearest[Geom::X] + distance_middle;
+    param_one.param_setValue(A, true);
+    param_two.param_setValue(B, true);
 }
 
 void
-LPELattice2::horizontal(PointParam &paramA, PointParam &paramB, Geom::Line horiz){
-    Geom::Point A = paramA;
-    Geom::Point B = paramB;
+LPELattice2::horizontal(PointParam &param_one, PointParam &param_two, Geom::Line horiz)
+{
+    Geom::Point A = param_one;
+    Geom::Point B = param_two;
     double X = (A[Geom::X] + B[Geom::X])/2;
     A[Geom::X] = X;
     B[Geom::X] = X;
     Geom::Point nearest = horiz.pointAt(horiz.nearestPoint(A));
-    double distA = Geom::distance(A,nearest);
-    double distB = Geom::distance(B,nearest);
-    double distanceMed = (distA + distB)/2;
-    if(A[Geom::Y] > B[Geom::Y]){
-        distanceMed *= -1;
+    double distance_one = Geom::distance(A,nearest);
+    double distance_two = Geom::distance(B,nearest);
+    double distance_middle = (distance_one + distance_two)/2;
+    if(A[Geom::Y] > B[Geom::Y]) {
+        distance_middle *= -1;
     }
-    A[Geom::Y] = nearest[Geom::Y] - distanceMed;
-    B[Geom::Y] = nearest[Geom::Y] + distanceMed;
-    paramA.param_setValue(A, true);
-    paramB.param_setValue(B, true);
+    A[Geom::Y] = nearest[Geom::Y] - distance_middle;
+    B[Geom::Y] = nearest[Geom::Y] + distance_middle;
+    param_one.param_setValue(A, true);
+    param_two.param_setValue(B, true);
 }
 
 void
@@ -326,31 +328,31 @@ LPELattice2::doBeforeEffect (SPLPEItem const* lpeitem)
 {
     original_bbox(lpeitem);
     setDefaults();
-    Geom::Line vert(grid_point8x9.param_get_default(),grid_point10x11.param_get_default());
-    Geom::Line horiz(grid_point24x26.param_get_default(),grid_point25x27.param_get_default());
-    if(verticalMirror){
-        vertical(grid_point0, grid_point1,vert);
-        vertical(grid_point2, grid_point3,vert);
-        vertical(grid_point4, grid_point5,vert);
-        vertical(grid_point6, grid_point7,vert);
-        vertical(grid_point12, grid_point13,vert);
-        vertical(grid_point14, grid_point15,vert);
-        vertical(grid_point16, grid_point17,vert);
-        vertical(grid_point18, grid_point19,vert);
-        vertical(grid_point24x26, grid_point25x27,vert);
-        vertical(grid_point28x30, grid_point29x31,vert);
+    Geom::Line vert(grid_point_8x9.param_get_default(),grid_point_10x11.param_get_default());
+    Geom::Line horiz(grid_point_24x26.param_get_default(),grid_point_25x27.param_get_default());
+    if(vertical_mirror) {
+        vertical(grid_point_0, grid_point_1,vert);
+        vertical(grid_point_2, grid_point_3,vert);
+        vertical(grid_point_4, grid_point_5,vert);
+        vertical(grid_point_6, grid_point_7,vert);
+        vertical(grid_point_12, grid_point_13,vert);
+        vertical(grid_point_14, grid_point_15,vert);
+        vertical(grid_point_16, grid_point_17,vert);
+        vertical(grid_point_18, grid_point_19,vert);
+        vertical(grid_point_24x26, grid_point_25x27,vert);
+        vertical(grid_point_28x30, grid_point_29x31,vert);
     }
-    if(horizontalMirror){
-        horizontal(grid_point0, grid_point2,horiz);
-        horizontal(grid_point1, grid_point3,horiz);
-        horizontal(grid_point4, grid_point6,horiz);
-        horizontal(grid_point5, grid_point7,horiz);
-        horizontal(grid_point8x9, grid_point10x11,horiz);
-        horizontal(grid_point12, grid_point14,horiz);
-        horizontal(grid_point13, grid_point15,horiz);
-        horizontal(grid_point16, grid_point18,horiz);
-        horizontal(grid_point17, grid_point19,horiz);
-        horizontal(grid_point20x21, grid_point22x23,horiz);
+    if(horizontal_mirror) {
+        horizontal(grid_point_0, grid_point_2,horiz);
+        horizontal(grid_point_1, grid_point_3,horiz);
+        horizontal(grid_point_4, grid_point_6,horiz);
+        horizontal(grid_point_5, grid_point_7,horiz);
+        horizontal(grid_point_8x9, grid_point_10x11,horiz);
+        horizontal(grid_point_12, grid_point_14,horiz);
+        horizontal(grid_point_13, grid_point_15,horiz);
+        horizontal(grid_point_16, grid_point_18,horiz);
+        horizontal(grid_point_17, grid_point_19,horiz);
+        horizontal(grid_point_20x21, grid_point_22x23,horiz);
     }
     SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
     item->apply_to_clippath(item);
@@ -385,111 +387,111 @@ LPELattice2::setDefaults()
                     (boundingbox_Y.max()-boundingbox_Y.min())/4*4+boundingbox_Y.min());
 
     Geom::Point gp8x9((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*0+boundingbox_Y.min());
+                      (boundingbox_Y.max()-boundingbox_Y.min())/4*0+boundingbox_Y.min());
 
     Geom::Point gp10x11((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*4+boundingbox_Y.min());
+                        (boundingbox_Y.max()-boundingbox_Y.min())/4*4+boundingbox_Y.min());
 
     Geom::Point gp12((boundingbox_X.max()-boundingbox_X.min())/4*0+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
+                     (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
 
     Geom::Point gp13((boundingbox_X.max()-boundingbox_X.min())/4*4+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
+                     (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
 
     Geom::Point gp14((boundingbox_X.max()-boundingbox_X.min())/4*0+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
+                     (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
 
     Geom::Point gp15((boundingbox_X.max()-boundingbox_X.min())/4*4+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
+                     (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
 
     Geom::Point gp16((boundingbox_X.max()-boundingbox_X.min())/4*1+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
+                     (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
 
     Geom::Point gp17((boundingbox_X.max()-boundingbox_X.min())/4*3+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
+                     (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
 
     Geom::Point gp18((boundingbox_X.max()-boundingbox_X.min())/4*1+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
+                     (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
 
     Geom::Point gp19((boundingbox_X.max()-boundingbox_X.min())/4*3+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
+                     (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
 
     Geom::Point gp20x21((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
+                        (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min());
 
     Geom::Point gp22x23((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
+                        (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min());
 
     Geom::Point gp24x26((boundingbox_X.max()-boundingbox_X.min())/4*0+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
+                        (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
 
     Geom::Point gp25x27((boundingbox_X.max()-boundingbox_X.min())/4*4+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
+                        (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
 
     Geom::Point gp28x30((boundingbox_X.max()-boundingbox_X.min())/4*1+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
+                        (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
 
     Geom::Point gp29x31((boundingbox_X.max()-boundingbox_X.min())/4*3+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
+                        (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
 
     Geom::Point gp32x33x34x35((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(),
-                    (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
-
-    grid_point0.param_update_default(gp0);
-    grid_point1.param_update_default(gp1);
-    grid_point2.param_update_default(gp2);
-    grid_point3.param_update_default(gp3);
-    grid_point4.param_update_default(gp4);
-    grid_point5.param_update_default(gp5);
-    grid_point6.param_update_default(gp6);
-    grid_point7.param_update_default(gp7);
-    grid_point8x9.param_update_default(gp8x9);
-    grid_point10x11.param_update_default(gp10x11);
-    grid_point12.param_update_default(gp12);
-    grid_point13.param_update_default(gp13);
-    grid_point14.param_update_default(gp14);
-    grid_point15.param_update_default(gp15);
-    grid_point16.param_update_default(gp16);
-    grid_point17.param_update_default(gp17);
-    grid_point18.param_update_default(gp18);
-    grid_point19.param_update_default(gp19);
-    grid_point20x21.param_update_default(gp20x21);
-    grid_point22x23.param_update_default(gp22x23);
-    grid_point24x26.param_update_default(gp24x26);
-    grid_point25x27.param_update_default(gp25x27);
-    grid_point28x30.param_update_default(gp28x30);
-    grid_point29x31.param_update_default(gp29x31);
-    grid_point32x33x34x35.param_update_default(gp32x33x34x35);
+                              (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min());
+
+    grid_point_0.param_update_default(gp0);
+    grid_point_1.param_update_default(gp1);
+    grid_point_2.param_update_default(gp2);
+    grid_point_3.param_update_default(gp3);
+    grid_point_4.param_update_default(gp4);
+    grid_point_5.param_update_default(gp5);
+    grid_point_6.param_update_default(gp6);
+    grid_point_7.param_update_default(gp7);
+    grid_point_8x9.param_update_default(gp8x9);
+    grid_point_10x11.param_update_default(gp10x11);
+    grid_point_12.param_update_default(gp12);
+    grid_point_13.param_update_default(gp13);
+    grid_point_14.param_update_default(gp14);
+    grid_point_15.param_update_default(gp15);
+    grid_point_16.param_update_default(gp16);
+    grid_point_17.param_update_default(gp17);
+    grid_point_18.param_update_default(gp18);
+    grid_point_19.param_update_default(gp19);
+    grid_point_20x21.param_update_default(gp20x21);
+    grid_point_22x23.param_update_default(gp22x23);
+    grid_point_24x26.param_update_default(gp24x26);
+    grid_point_25x27.param_update_default(gp25x27);
+    grid_point_28x30.param_update_default(gp28x30);
+    grid_point_29x31.param_update_default(gp29x31);
+    grid_point_32x33x34x35.param_update_default(gp32x33x34x35);
 }
 
 void
 LPELattice2::resetGrid()
 {
-    grid_point0.param_set_default();
-    grid_point1.param_set_default();
-    grid_point2.param_set_default();
-    grid_point3.param_set_default();
-    grid_point4.param_set_default();
-    grid_point5.param_set_default();
-    grid_point6.param_set_default();
-    grid_point7.param_set_default();
-    grid_point8x9.param_set_default();
-    grid_point10x11.param_set_default();
-    grid_point12.param_set_default();
-    grid_point13.param_set_default();
-    grid_point14.param_set_default();
-    grid_point15.param_set_default();
-    grid_point16.param_set_default();
-    grid_point17.param_set_default();
-    grid_point18.param_set_default();
-    grid_point19.param_set_default();
-    grid_point20x21.param_set_default();
-    grid_point22x23.param_set_default();
-    grid_point24x26.param_set_default();
-    grid_point25x27.param_set_default();
-    grid_point28x30.param_set_default();
-    grid_point29x31.param_set_default();
-    grid_point32x33x34x35.param_set_default();
+    grid_point_0.param_set_default();
+    grid_point_1.param_set_default();
+    grid_point_2.param_set_default();
+    grid_point_3.param_set_default();
+    grid_point_4.param_set_default();
+    grid_point_5.param_set_default();
+    grid_point_6.param_set_default();
+    grid_point_7.param_set_default();
+    grid_point_8x9.param_set_default();
+    grid_point_10x11.param_set_default();
+    grid_point_12.param_set_default();
+    grid_point_13.param_set_default();
+    grid_point_14.param_set_default();
+    grid_point_15.param_set_default();
+    grid_point_16.param_set_default();
+    grid_point_17.param_set_default();
+    grid_point_18.param_set_default();
+    grid_point_19.param_set_default();
+    grid_point_20x21.param_set_default();
+    grid_point_22x23.param_set_default();
+    grid_point_24x26.param_set_default();
+    grid_point_25x27.param_set_default();
+    grid_point_28x30.param_set_default();
+    grid_point_29x31.param_set_default();
+    grid_point_32x33x34x35.param_set_default();
 }
 
 void
@@ -519,55 +521,55 @@ LPELattice2::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom:
     hp_vec.clear();
 
     SPCurve *c = new SPCurve();
-    calculateCurve(grid_point0,grid_point4, c,true, true);
-    calculateCurve(grid_point4,grid_point8x9, c,true, false);
-    calculateCurve(grid_point8x9,grid_point5, c,true, false);
-    calculateCurve(grid_point5,grid_point1, c,true, false);
-
-    calculateCurve(grid_point12,grid_point16, c,true, true);
-    calculateCurve(grid_point16,grid_point20x21, c,true, false);
-    calculateCurve(grid_point20x21,grid_point17, c,true, false);
-    calculateCurve(grid_point17,grid_point13, c,true, false);
-
-    calculateCurve(grid_point24x26,grid_point28x30, c,true, true);
-    calculateCurve(grid_point28x30,grid_point32x33x34x35, c,true, false);
-    calculateCurve(grid_point32x33x34x35,grid_point29x31, c,true, false);
-    calculateCurve(grid_point29x31,grid_point25x27, c,true, false);
-
-    calculateCurve(grid_point14,grid_point18, c,true, true);
-    calculateCurve(grid_point18,grid_point22x23, c,true, false);
-    calculateCurve(grid_point22x23,grid_point19, c,true, false);
-    calculateCurve(grid_point19,grid_point15, c,true, false);
-
-    calculateCurve(grid_point2,grid_point6, c,true, true);
-    calculateCurve(grid_point6,grid_point10x11, c,true, false);
-    calculateCurve(grid_point10x11,grid_point7, c,true, false);
-    calculateCurve(grid_point7,grid_point3, c,true, false);
-
-    calculateCurve(grid_point0,grid_point12, c,false, true);
-    calculateCurve(grid_point12,grid_point24x26, c,false, false);
-    calculateCurve(grid_point24x26,grid_point14, c,false, false);
-    calculateCurve(grid_point14,grid_point2, c,false, false);
-
-    calculateCurve(grid_point4,grid_point16, c,false, true);
-    calculateCurve(grid_point16,grid_point28x30, c,false, false);
-    calculateCurve(grid_point28x30,grid_point18, c,false, false);
-    calculateCurve(grid_point18,grid_point6, c,false, false);
-
-    calculateCurve(grid_point8x9,grid_point20x21, c,false, true);
-    calculateCurve(grid_point20x21,grid_point32x33x34x35, c,false, false);
-    calculateCurve(grid_point32x33x34x35,grid_point22x23, c,false, false);
-    calculateCurve(grid_point22x23,grid_point10x11, c,false, false);
-
-    calculateCurve(grid_point5,grid_point17, c, false, true);
-    calculateCurve(grid_point17,grid_point29x31, c,false, false);
-    calculateCurve(grid_point29x31,grid_point19, c,false, false);
-    calculateCurve(grid_point19,grid_point7, c,false, false);
-
-    calculateCurve(grid_point1,grid_point13, c, false, true);
-    calculateCurve(grid_point13,grid_point25x27, c,false, false);
-    calculateCurve(grid_point25x27,grid_point15, c,false, false);
-    calculateCurve(grid_point15,grid_point3, c, false, false);
+    calculateCurve(grid_point_0,grid_point_4, c,true, true);
+    calculateCurve(grid_point_4,grid_point_8x9, c,true, false);
+    calculateCurve(grid_point_8x9,grid_point_5, c,true, false);
+    calculateCurve(grid_point_5,grid_point_1, c,true, false);
+
+    calculateCurve(grid_point_12,grid_point_16, c,true, true);
+    calculateCurve(grid_point_16,grid_point_20x21, c,true, false);
+    calculateCurve(grid_point_20x21,grid_point_17, c,true, false);
+    calculateCurve(grid_point_17,grid_point_13, c,true, false);
+
+    calculateCurve(grid_point_24x26,grid_point_28x30, c,true, true);
+    calculateCurve(grid_point_28x30,grid_point_32x33x34x35, c,true, false);
+    calculateCurve(grid_point_32x33x34x35,grid_point_29x31, c,true, false);
+    calculateCurve(grid_point_29x31,grid_point_25x27, c,true, false);
+
+    calculateCurve(grid_point_14,grid_point_18, c,true, true);
+    calculateCurve(grid_point_18,grid_point_22x23, c,true, false);
+    calculateCurve(grid_point_22x23,grid_point_19, c,true, false);
+    calculateCurve(grid_point_19,grid_point_15, c,true, false);
+
+    calculateCurve(grid_point_2,grid_point_6, c,true, true);
+    calculateCurve(grid_point_6,grid_point_10x11, c,true, false);
+    calculateCurve(grid_point_10x11,grid_point_7, c,true, false);
+    calculateCurve(grid_point_7,grid_point_3, c,true, false);
+
+    calculateCurve(grid_point_0,grid_point_12, c,false, true);
+    calculateCurve(grid_point_12,grid_point_24x26, c,false, false);
+    calculateCurve(grid_point_24x26,grid_point_14, c,false, false);
+    calculateCurve(grid_point_14,grid_point_2, c,false, false);
+
+    calculateCurve(grid_point_4,grid_point_16, c,false, true);
+    calculateCurve(grid_point_16,grid_point_28x30, c,false, false);
+    calculateCurve(grid_point_28x30,grid_point_18, c,false, false);
+    calculateCurve(grid_point_18,grid_point_6, c,false, false);
+
+    calculateCurve(grid_point_8x9,grid_point_20x21, c,false, true);
+    calculateCurve(grid_point_20x21,grid_point_32x33x34x35, c,false, false);
+    calculateCurve(grid_point_32x33x34x35,grid_point_22x23, c,false, false);
+    calculateCurve(grid_point_22x23,grid_point_10x11, c,false, false);
+
+    calculateCurve(grid_point_5,grid_point_17, c, false, true);
+    calculateCurve(grid_point_17,grid_point_29x31, c,false, false);
+    calculateCurve(grid_point_29x31,grid_point_19, c,false, false);
+    calculateCurve(grid_point_19,grid_point_7, c,false, false);
+
+    calculateCurve(grid_point_1,grid_point_13, c, false, true);
+    calculateCurve(grid_point_13,grid_point_25x27, c,false, false);
+    calculateCurve(grid_point_25x27,grid_point_15, c,false, false);
+    calculateCurve(grid_point_15,grid_point_3, c, false, false);
     hp_vec.push_back(c->get_pathvector());
 }
 
diff --git a/src/live_effects/lpe-lattice2.h b/src/live_effects/lpe-lattice2.h
index 086bdab7e..ff2e75641 100644
--- a/src/live_effects/lpe-lattice2.h
+++ b/src/live_effects/lpe-lattice2.h
@@ -34,7 +34,7 @@ public:
     virtual ~LPELattice2();
 
     virtual Geom::Piecewise<Geom::D2<Geom::SBasis> > doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in);
-    
+
     virtual void resetDefaults(SPItem const* item);
 
     virtual void doBeforeEffect(SPLPEItem const* lpeitem);
@@ -49,46 +49,41 @@ public:
 
     virtual void setDefaults();
 
-    virtual void on_expander_changed();
+    virtual void onExpanderChanged();
 
     virtual void resetGrid();
 
-    //virtual void original_bbox(SPLPEItem const* lpeitem, bool absolute = false);
-
-    //virtual void addCanvasIndicators(SPLPEItem const*/*lpeitem*/, std::vector<Geom::PathVector> &/*hp_vec*/);
-
-    //virtual std::vector<Geom::PathVector> getHelperPaths(SPLPEItem const* lpeitem);
 protected:
     void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec);
 private:
 
-    BoolParam horizontalMirror;
-    BoolParam verticalMirror;
-    PointParam grid_point0;
-    PointParam grid_point1;
-    PointParam grid_point2;
-    PointParam grid_point3;
-    PointParam grid_point4;
-    PointParam grid_point5;
-    PointParam grid_point6;
-    PointParam grid_point7;
-    PointParam grid_point8x9;
-    PointParam grid_point10x11;
-    PointParam grid_point12;
-    PointParam grid_point13;
-    PointParam grid_point14;
-    PointParam grid_point15;
-    PointParam grid_point16;
-    PointParam grid_point17;
-    PointParam grid_point18;
-    PointParam grid_point19;
-    PointParam grid_point20x21;
-    PointParam grid_point22x23;
-    PointParam grid_point24x26;
-    PointParam grid_point25x27;
-    PointParam grid_point28x30;
-    PointParam grid_point29x31;
-    PointParam grid_point32x33x34x35; 
+    BoolParam horizontal_mirror;
+    BoolParam vertical_mirror;
+    PointParam grid_point_0;
+    PointParam grid_point_1;
+    PointParam grid_point_2;
+    PointParam grid_point_3;
+    PointParam grid_point_4;
+    PointParam grid_point_5;
+    PointParam grid_point_6;
+    PointParam grid_point_7;
+    PointParam grid_point_8x9;
+    PointParam grid_point_10x11;
+    PointParam grid_point_12;
+    PointParam grid_point_13;
+    PointParam grid_point_14;
+    PointParam grid_point_15;
+    PointParam grid_point_16;
+    PointParam grid_point_17;
+    PointParam grid_point_18;
+    PointParam grid_point_19;
+    PointParam grid_point_20x21;
+    PointParam grid_point_22x23;
+    PointParam grid_point_24x26;
+    PointParam grid_point_25x27;
+    PointParam grid_point_28x30;
+    PointParam grid_point_29x31;
+    PointParam grid_point_32x33x34x35;
 
     bool expanded;
     Gtk::Expander * expander;
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&);
diff --git a/src/live_effects/lpe-roughen.cpp b/src/live_effects/lpe-roughen.cpp
index 8cef9a3a3..9d1c3152b 100644
--- a/src/live_effects/lpe-roughen.cpp
+++ b/src/live_effects/lpe-roughen.cpp
@@ -39,36 +39,36 @@ LPERoughen::LPERoughen(LivePathEffectObject *lpeobject)
       unit(_("Unit"), _("Unit"), "unit", &wr, this),
       method(_("Method"), _("Division method"), "method", DMConverter, &wr,
              this, DM_SEGMENTS),
-      maxSegmentSize(_("Max. segment size"), _("Max. segment size"),
-                     "maxSegmentSize", &wr, this, 10.),
+      max_segment_size(_("Max. segment size"), _("Max. segment size"),
+                     "max_segment_size", &wr, this, 10.),
       segments(_("Number of segments"), _("Number of segments"), "segments",
                &wr, this, 2),
-      displaceX(_("Max. displacement in X"), _("Max. displacement in X"),
-                "displaceX", &wr, this, 10.),
-      displaceY(_("Max. displacement in Y"), _("Max. displacement in Y"),
-                "displaceY", &wr, this, 10.),
-      globalRandomize(_("Global randomize"), _("Global randomize"),
-                     "globalRandomize", &wr, this, 1.),
-      shiftNodes(_("Shift nodes"), _("Shift nodes"), "shiftNodes", &wr, this,
+      displace_x(_("Max. displacement in X"), _("Max. displacement in X"),
+                "displace_x", &wr, this, 10.),
+      displace_y(_("Max. displacement in Y"), _("Max. displacement in Y"),
+                "displace_y", &wr, this, 10.),
+      global_randomize(_("Global randomize"), _("Global randomize"),
+                      "global_randomize", &wr, this, 1.),
+      shift_nodes(_("Shift nodes"), _("Shift nodes"), "shift_nodes", &wr, this,
                  true),
-      shiftNodeHandles(_("Shift node handles"), _("Shift node handles"),
-                       "shiftNodeHandles", &wr, this, true)
+      shift_node_handles(_("Shift node handles"), _("Shift node handles"),
+                       "shift_node_handles", &wr, this, true)
 {
     registerParameter(&unit);
     registerParameter(&method);
-    registerParameter(&maxSegmentSize);
+    registerParameter(&max_segment_size);
     registerParameter(&segments);
-    registerParameter(&displaceX);
-    registerParameter(&displaceY);
-    registerParameter(&globalRandomize);
-    registerParameter(&shiftNodes);
-    registerParameter(&shiftNodeHandles);
-    displaceX.param_set_range(0., Geom::infinity());
-    displaceY.param_set_range(0., Geom::infinity());
-    globalRandomize.param_set_range(0., Geom::infinity());
-    maxSegmentSize.param_set_range(0., Geom::infinity());
-    maxSegmentSize.param_set_increments(1, 1);
-    maxSegmentSize.param_set_digits(1);
+    registerParameter(&displace_x);
+    registerParameter(&displace_y);
+    registerParameter(&global_randomize);
+    registerParameter(&shift_nodes);
+    registerParameter(&shift_node_handles);
+    displace_x.param_set_range(0., Geom::infinity());
+    displace_y.param_set_range(0., Geom::infinity());
+    global_randomize.param_set_range(0., Geom::infinity());
+    max_segment_size.param_set_range(0., Geom::infinity());
+    max_segment_size.param_set_increments(1, 1);
+    max_segment_size.param_set_digits(1);
     segments.param_set_range(1, Geom::infinity());
     segments.param_set_increments(1, 1);
     segments.param_set_digits(0);
@@ -78,9 +78,9 @@ LPERoughen::~LPERoughen() {}
 
 void LPERoughen::doBeforeEffect(SPLPEItem const *lpeitem)
 {
-    displaceX.resetRandomizer();
-    displaceY.resetRandomizer();
-    globalRandomize.resetRandomizer();
+    displace_x.resetRandomizer();
+    displace_y.resetRandomizer();
+    global_randomize.resetRandomizer();
     srand(1);
     SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
     item->apply_to_clippath(item);
@@ -99,37 +99,37 @@ Gtk::Widget *LPERoughen::newWidget()
             Parameter *param = *it;
             Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
             if (param->param_key == "unit") {
-                Gtk::Label *unitLabel = Gtk::manage(new Gtk::Label(
+                Gtk::Label *unit_label = Gtk::manage(new Gtk::Label(
                                                         Glib::ustring(_("<b>Roughen unit</b>")), Gtk::ALIGN_START));
-                unitLabel->set_use_markup(true);
-                vbox->pack_start(*unitLabel, false, false, 2);
+                unit_label->set_use_markup(true);
+                vbox->pack_start(*unit_label, false, false, 2);
                 vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
                                  Gtk::PACK_EXPAND_WIDGET);
             }
             if (param->param_key == "method") {
-                Gtk::Label *methodLabel = Gtk::manage(new Gtk::Label(
+                Gtk::Label *method_label = Gtk::manage(new Gtk::Label(
                         Glib::ustring(_("<b>Add nodes</b> Subdivide each segment")),
                         Gtk::ALIGN_START));
-                methodLabel->set_use_markup(true);
-                vbox->pack_start(*methodLabel, false, false, 2);
+                method_label->set_use_markup(true);
+                vbox->pack_start(*method_label, false, false, 2);
                 vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
                                  Gtk::PACK_EXPAND_WIDGET);
             }
-            if (param->param_key == "displaceX") {
-                Gtk::Label *displaceXLabel = Gtk::manage(new Gtk::Label(
+            if (param->param_key == "displace_x") {
+                Gtk::Label *displace_x_label = Gtk::manage(new Gtk::Label(
                                                  Glib::ustring(_("<b>Jitter nodes</b> Move nodes/handles")),
                                                  Gtk::ALIGN_START));
-                displaceXLabel->set_use_markup(true);
-                vbox->pack_start(*displaceXLabel, false, false, 2);
+                displace_x_label->set_use_markup(true);
+                vbox->pack_start(*displace_x_label, false, false, 2);
                 vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
                                  Gtk::PACK_EXPAND_WIDGET);
             }
-            if (param->param_key == "globalRandomize") {
-                Gtk::Label *displaceXLabel = Gtk::manage(new Gtk::Label(
+            if (param->param_key == "global_randomize") {
+                Gtk::Label *global_rand = Gtk::manage(new Gtk::Label(
                                                  Glib::ustring(_("<b>Extra roughen</b> Add a extra layer of rough")),
                                                  Gtk::ALIGN_START));
-                displaceXLabel->set_use_markup(true);
-                vbox->pack_start(*displaceXLabel, false, false, 2);
+                global_rand->set_use_markup(true);
+                vbox->pack_start(*global_rand, false, false, 2);
                 vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
                                  Gtk::PACK_EXPAND_WIDGET);
             }
@@ -150,23 +150,23 @@ Gtk::Widget *LPERoughen::newWidget()
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
-double LPERoughen::sign(double randNumber)
+double LPERoughen::sign(double random_number)
 {
     if (rand() % 100 < 49) {
-        randNumber *= -1.;
+        random_number *= -1.;
     }
-    return randNumber;
+    return random_number;
 }
 
 Geom::Point LPERoughen::randomize()
 {
     Inkscape::Util::Unit const *svg_units = SP_ACTIVE_DESKTOP->namedview->svg_units;
-    double displaceXParsed = Inkscape::Util::Quantity::convert(
-                                 displaceX * globalRandomize, unit.get_abbreviation(), svg_units->abbr);
-    double displaceYParsed = Inkscape::Util::Quantity::convert(
-                                 displaceY * globalRandomize, unit.get_abbreviation(), svg_units->abbr);
+    double displace_x_parsed = Inkscape::Util::Quantity::convert(
+                                 displace_x * global_randomize, unit.get_abbreviation(), svg_units->abbr);
+    double displace_y_parsed = Inkscape::Util::Quantity::convert(
+                                 displace_y * global_randomize, unit.get_abbreviation(), svg_units->abbr);
 
-    Geom::Point output = Geom::Point(sign(displaceXParsed), sign(displaceYParsed));
+    Geom::Point output = Geom::Point(sign(displace_x_parsed), sign(displace_y_parsed));
     return output;
 }
 
@@ -193,32 +193,32 @@ void LPERoughen::doEffect(SPCurve *curve)
             }
         }
         Geom::Point initialMove(0, 0);
-        if (shiftNodes) {
+        if (shift_nodes) {
             initialMove = randomize();
         }
         Geom::Point initialPoint = curve_it1->initialPoint() + initialMove;
         nCurve->moveto(initialPoint);
-        Geom::Point A0(0, 0);
-        Geom::Point A1(0, 0);
-        Geom::Point A2(0, 0);
-        Geom::Point A3(0, 0);
+        Geom::Point point0(0, 0);
+        Geom::Point point1(0, 0);
+        Geom::Point point2(0, 0);
+        Geom::Point point3(0, 0);
         bool first = true;
         while (curve_it1 != curve_endit) {
             Geom::CubicBezier const *cubic = NULL;
-            A0 = curve_it1->initialPoint();
-            A1 = curve_it1->initialPoint();
-            A2 = curve_it1->finalPoint();
-            A3 = curve_it1->finalPoint();
+            point0 = curve_it1->initialPoint();
+            point1 = curve_it1->initialPoint();
+            point2 = curve_it1->finalPoint();
+            point3 = curve_it1->finalPoint();
             cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
             if (cubic) {
-                A1 = (*cubic)[1];
-                if (shiftNodes && first) {
-                    A1 = (*cubic)[1] + initialMove;
+                point1 = (*cubic)[1];
+                if (shift_nodes && first) {
+                    point1 = (*cubic)[1] + initialMove;
                 }
-                A2 = (*cubic)[2];
-                nCurve->curveto(A1, A2, A3);
+                point2 = (*cubic)[2];
+                nCurve->curveto(point1, point2, point3);
             } else {
-                nCurve->lineto(A3);
+                nCurve->lineto(point3);
             }
             double length = Inkscape::Util::Quantity::convert(
                                 curve_it1->length(0.001), svg_units->abbr, unit.get_abbreviation());
@@ -226,7 +226,7 @@ void LPERoughen::doEffect(SPCurve *curve)
             if (method == DM_SEGMENTS) {
                 splits = segments;
             } else {
-                splits = ceil(length / maxSegmentSize);
+                splits = ceil(length / max_segment_size);
             }
             for (unsigned int t = splits; t >= 1; t--) {
                 if (t == 1 && splits != 1) {
@@ -265,42 +265,42 @@ SPCurve *LPERoughen::addNodesAndJitter(const Geom::Curve *A, double t)
 {
     SPCurve *out = new SPCurve();
     Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(&*A);
-    Geom::Point A1(0, 0);
-    Geom::Point A2(0, 0);
-    Geom::Point A3(0, 0);
-    Geom::Point B1(0, 0);
-    Geom::Point B2(0, 0);
-    Geom::Point B3(0, 0);
-    if (shiftNodes) {
-        A3 = randomize();
-        B3 = randomize();
+    Geom::Point point1(0, 0);
+    Geom::Point point2(0, 0);
+    Geom::Point point3(0, 0);
+    Geom::Point point_b1(0, 0);
+    Geom::Point point_b2(0, 0);
+    Geom::Point point_b3(0, 0);
+    if (shift_nodes) {
+        point3 = randomize();
+        point_b3 = randomize();
     }
-    if (shiftNodeHandles) {
-        A1 = randomize();
-        A2 = randomize();
-        B1 = randomize();
-        B2 = randomize();
+    if (shift_node_handles) {
+        point1 = randomize();
+        point2 = randomize();
+        point_b1 = randomize();
+        point_b2 = randomize();
     } else {
-        A2 = A3;
-        B1 = A3;
-        B2 = B3;
+        point2 = point3;
+        point_b1 = point3;
+        point_b2 = point_b3;
     }
     if (cubic) {
         std::pair<Geom::CubicBezier, Geom::CubicBezier> div = cubic->subdivide(t);
         std::vector<Geom::Point> seg1 = div.first.points(),
                                  seg2 = div.second.points();
         out->moveto(seg1[0]);
-        out->curveto(seg1[1] + A1, seg1[2] + A2, seg1[3] + A3);
-        out->curveto(seg2[1] + B1, seg2[2], seg2[3]);
-    } else if (shiftNodeHandles) {
+        out->curveto(seg1[1] + point1, seg1[2] + point2, seg1[3] + point3);
+        out->curveto(seg2[1] + point_b1, seg2[2], seg2[3]);
+    } else if (shift_node_handles) {
         out->moveto(A->initialPoint());
-        out->curveto(A->pointAt(t / 3) + A1, A->pointAt((t / 3) * 2) + A2,
-                     A->pointAt(t) + A3);
-        out->curveto(A->pointAt(t + (t / 3)) + B1, A->pointAt(t + ((t / 3) * 2)),
+        out->curveto(A->pointAt(t / 3) + point1, A->pointAt((t / 3) * 2) + point2,
+                     A->pointAt(t) + point3);
+        out->curveto(A->pointAt(t + (t / 3)) + point_b1, A->pointAt(t + ((t / 3) * 2)),
                      A->finalPoint());
     } else {
         out->moveto(A->initialPoint());
-        out->lineto(A->pointAt(t) + A3);
+        out->lineto(A->pointAt(t) + point3);
         out->lineto(A->finalPoint());
     }
     return out;
@@ -310,33 +310,33 @@ SPCurve *LPERoughen::jitter(const Geom::Curve *A)
 {
     SPCurve *out = new SPCurve();
     Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(&*A);
-    Geom::Point A1(0, 0);
-    Geom::Point A2(0, 0);
-    Geom::Point A3(0, 0);
-    if (shiftNodes) {
-        A3 = randomize();
+    Geom::Point point1(0, 0);
+    Geom::Point point2(0, 0);
+    Geom::Point point3(0, 0);
+    if (shift_nodes) {
+        point3 = randomize();
     }
-    if (shiftNodeHandles) {
-        A1 = randomize();
-        A2 = randomize();
+    if (shift_node_handles) {
+        point1 = randomize();
+        point2 = randomize();
     } else {
-        A2 = A3;
+        point2 = point3;
     }
     if (cubic) {
         out->moveto((*cubic)[0]);
-        out->curveto((*cubic)[1] + A1, (*cubic)[2] + A2, (*cubic)[3] + A3);
-    } else if (shiftNodeHandles) {
+        out->curveto((*cubic)[1] + point1, (*cubic)[2] + point2, (*cubic)[3] + point3);
+    } else if (shift_node_handles) {
         out->moveto(A->initialPoint());
-        out->curveto(A->pointAt(0.3333) + A1, A->pointAt(0.6666) + A2,
-                     A->finalPoint() + A3);
+        out->curveto(A->pointAt(0.3333) + point1, A->pointAt(0.6666) + point2,
+                     A->finalPoint() + point3);
     } else {
         out->moveto(A->initialPoint());
-        out->lineto(A->finalPoint() + A3);
+        out->lineto(A->finalPoint() + point3);
     }
     return out;
 }
 
-Geom::Point LPERoughen::tpoint(Geom::Point A, Geom::Point B, double t)
+Geom::Point LPERoughen::tPoint(Geom::Point A, Geom::Point B, double t)
 {
     using Geom::X;
     using Geom::Y;
diff --git a/src/live_effects/lpe-roughen.h b/src/live_effects/lpe-roughen.h
index 74331f1ef..ed9f06cf7 100644
--- a/src/live_effects/lpe-roughen.h
+++ b/src/live_effects/lpe-roughen.h
@@ -41,19 +41,19 @@ public:
     virtual void doBeforeEffect(SPLPEItem const * lpeitem);
     virtual SPCurve *addNodesAndJitter(const Geom::Curve *A, double t);
     virtual SPCurve *jitter(const Geom::Curve *A);
-    virtual Geom::Point tpoint(Geom::Point A, Geom::Point B, double t = 0.5);
+    virtual Geom::Point tPoint(Geom::Point A, Geom::Point B, double t = 0.5);
     virtual Gtk::Widget *newWidget();
 
 private:
     UnitParam unit;
     EnumParam<DivisionMethod> method;
-    ScalarParam maxSegmentSize;
+    ScalarParam max_segment_size;
     ScalarParam segments;
-    RandomParam displaceX;
-    RandomParam displaceY;
-    RandomParam globalRandomize;
-    BoolParam shiftNodes;
-    BoolParam shiftNodeHandles;
+    RandomParam displace_x;
+    RandomParam displace_y;
+    RandomParam global_randomize;
+    BoolParam shift_nodes;
+    BoolParam shift_node_handles;
 
     LPERoughen(const LPERoughen &);
     LPERoughen &operator=(const LPERoughen &);
diff --git a/src/live_effects/lpe-show_handles.cpp b/src/live_effects/lpe-show_handles.cpp
index 2d8148730..2638f312e 100644
--- a/src/live_effects/lpe-show_handles.cpp
+++ b/src/live_effects/lpe-show_handles.cpp
@@ -24,25 +24,25 @@ LPEShowHandles::LPEShowHandles(LivePathEffectObject *lpeobject)
     : Effect(lpeobject),
       nodes(_("Show nodes"), _("Show nodes"), "nodes", &wr, this, true),
       handles(_("Show handles"), _("Show handles"), "handles", &wr, this, true),
-      originalPath(_("Show path"), _("Show path"), "originalPath", &wr, this, true),
-      scaleNodesAndHandles(_("Scale nodes and handles"), _("Scale nodes and handles"), "scaleNodesAndHandles", &wr, this, 10),
-      rotateNodes(_("Rotate nodes"), _("Rotate nodes"), "rotateNodes", &wr, this, 0)
+      original_path(_("Show path"), _("Show path"), "original_path", &wr, this, true),
+      scale_nodes_and_handles(_("Scale nodes and handles"), _("Scale nodes and handles"), "scale_nodes_and_handles", &wr, this, 10),
+      rotate_nodes(_("Rotate nodes"), _("Rotate nodes"), "rotate_nodes", &wr, this, 0)
 {
-    registerParameter(dynamic_cast<Parameter *>(&nodes));
-    registerParameter(dynamic_cast<Parameter *>(&handles));
-    registerParameter(dynamic_cast<Parameter *>(&originalPath));
-    registerParameter(dynamic_cast<Parameter *>(&scaleNodesAndHandles));
-    registerParameter(dynamic_cast<Parameter *>(&rotateNodes));
-    scaleNodesAndHandles.param_set_range(0, 500.);
-    scaleNodesAndHandles.param_set_increments(1, 1);
-    scaleNodesAndHandles.param_set_digits(2);
-    rotateNodes.param_set_range(0, 365);
-    rotateNodes.param_set_increments(1, 1);
-    rotateNodes.param_set_digits(0);
-    strokeWidth = 1.0;
+    registerParameter(&nodes);
+    registerParameter(&handles);
+    registerParameter(&original_path);
+    registerParameter(&scale_nodes_and_handles);
+    registerParameter(&rotate_nodes);
+    scale_nodes_and_handles.param_set_range(0, 500.);
+    scale_nodes_and_handles.param_set_increments(1, 1);
+    scale_nodes_and_handles.param_set_digits(2);
+    rotate_nodes.param_set_range(0, 365);
+    rotate_nodes.param_set_increments(1, 1);
+    rotate_nodes.param_set_digits(0);
+    stroke_width = 1.0;
 }
 
-bool LPEShowHandles::alertsOff = false;
+bool LPEShowHandles::alerts_off = false;
 
 /**
  * Sets default styles to element
@@ -51,11 +51,11 @@ bool LPEShowHandles::alertsOff = false;
 
 void LPEShowHandles::doOnApply(SPLPEItem const* lpeitem)
 {
-    if(!alertsOff) {
+    if(!alerts_off) {
         char *msg = _("The \"show handles\" path effect will remove any custom style on the object you are applying it to. If this is not what you want, click Cancel.");
         Gtk::MessageDialog dialog(msg, false, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_OK_CANCEL, true);
         gint response = dialog.run();
-        alertsOff = true;
+        alerts_off = true;
         if(response == GTK_RESPONSE_CANCEL) {
             SPLPEItem* item = const_cast<SPLPEItem*>(lpeitem);
             item->removeCurrentPathEffect(false);
@@ -76,24 +76,24 @@ void LPEShowHandles::doOnApply(SPLPEItem const* lpeitem)
 void LPEShowHandles::doBeforeEffect (SPLPEItem const* lpeitem)
 {
     SPItem const* item = SP_ITEM(lpeitem);
-    strokeWidth = item->style->stroke_width.computed;
+    stroke_width = item->style->stroke_width.computed;
 }
 
 std::vector<Geom::Path> LPEShowHandles::doEffect_path (std::vector<Geom::Path> const & path_in)
 {
     std::vector<Geom::Path> path_out;
     Geom::PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(path_in);
-    if(originalPath) {
+    if(original_path) {
         for (unsigned int i=0; i < path_in.size(); i++) {
             path_out.push_back(path_in[i]);
         }
     }
-    if(!outlinepath.empty()) {
-        outlinepath.clear();
+    if(!outline_path.empty()) {
+        outline_path.clear();
     }
     generateHelperPath(original_pathv);
-    for (unsigned int i=0; i < outlinepath.size(); i++) {
-        path_out.push_back(outlinepath[i]);
+    for (unsigned int i=0; i < outline_path.size(); i++) {
+        path_out.push_back(outline_path[i]);
     }
     return path_out;
 }
@@ -136,11 +136,11 @@ LPEShowHandles::generateHelperPath(Geom::PathVector result)
             cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
             if (cubic) {
                 if(handles) {
-                    if(!are_near((*cubic)[0],(*cubic)[1])){
+                    if(!are_near((*cubic)[0],(*cubic)[1])) {
                         drawHandle((*cubic)[1]);
                         drawHandleLine((*cubic)[0],(*cubic)[1]);
                     }
-                    if(!are_near((*cubic)[3],(*cubic)[2])){
+                    if(!are_near((*cubic)[3],(*cubic)[2])) {
                         drawHandle((*cubic)[2]);
                         drawHandleLine((*cubic)[3],(*cubic)[2]);
                     }
@@ -150,7 +150,7 @@ LPEShowHandles::generateHelperPath(Geom::PathVector result)
                 drawNode(curve_it1->finalPoint());
             }
             ++curve_it1;
-            if(curve_it2 != curve_endit){
+            if(curve_it2 != curve_endit) {
                 ++curve_it2;
             }
         }
@@ -160,30 +160,30 @@ LPEShowHandles::generateHelperPath(Geom::PathVector result)
 void
 LPEShowHandles::drawNode(Geom::Point p)
 {
-    if(strokeWidth * scaleNodesAndHandles > 0.0) {
-        double diameter = strokeWidth * scaleNodesAndHandles;
+    if(stroke_width * scale_nodes_and_handles > 0.0) {
+        double diameter = stroke_width * scale_nodes_and_handles;
         char const * svgd;
         svgd = "M 0.05,0 A 0.05,0.05 0 0 1 0,0.05 0.05,0.05 0 0 1 -0.05,0 0.05,0.05 0 0 1 0,-0.05 0.05,0.05 0 0 1 0.05,0 Z M -0.5,-0.5 0.5,-0.5 0.5,0.5 -0.5,0.5 Z";
         Geom::PathVector pathv = sp_svg_read_pathv(svgd);
-        pathv *= Geom::Rotate::from_degrees(rotateNodes);
+        pathv *= Geom::Rotate::from_degrees(rotate_nodes);
         pathv *= Geom::Scale (diameter);
         pathv += p;
-        outlinepath.push_back(pathv[0]);
-        outlinepath.push_back(pathv[1]);
+        outline_path.push_back(pathv[0]);
+        outline_path.push_back(pathv[1]);
     }
 }
 
 void
 LPEShowHandles::drawHandle(Geom::Point p)
 {
-    if(strokeWidth * scaleNodesAndHandles > 0.0) {
-        double diameter = strokeWidth * scaleNodesAndHandles;
+    if(stroke_width * scale_nodes_and_handles > 0.0) {
+        double diameter = stroke_width * scale_nodes_and_handles;
         char const * svgd;
         svgd = "M 0.7,0.35 A 0.35,0.35 0 0 1 0.35,0.7 0.35,0.35 0 0 1 0,0.35 0.35,0.35 0 0 1 0.35,0 0.35,0.35 0 0 1 0.7,0.35 Z";
         Geom::PathVector pathv = sp_svg_read_pathv(svgd);
         pathv *= Geom::Scale (diameter);
         pathv += p-Geom::Point(diameter * 0.35,diameter * 0.35);
-        outlinepath.push_back(pathv[0]);
+        outline_path.push_back(pathv[0]);
     }
 }
 
@@ -192,14 +192,14 @@ void
 LPEShowHandles::drawHandleLine(Geom::Point p,Geom::Point p2)
 {
     Geom::Path path;
-    double diameter = strokeWidth * scaleNodesAndHandles;
-    if(diameter > 0.0 && Geom::distance(p,p2) > (diameter * 0.35)){
+    double diameter = stroke_width * scale_nodes_and_handles;
+    if(diameter > 0.0 && Geom::distance(p,p2) > (diameter * 0.35)) {
         Geom::Ray ray2(p, p2);
         p2 =  p2 - Geom::Point::polar(ray2.angle(),(diameter * 0.35));
     }
     path.start( p );
     path.appendNew<Geom::LineSegment>( p2 );
-    outlinepath.push_back(path);
+    outline_path.push_back(path);
 }
 
 }; //namespace LivePathEffect
diff --git a/src/live_effects/lpe-show_handles.h b/src/live_effects/lpe-show_handles.h
index a405c26ee..77b28e77a 100644
--- a/src/live_effects/lpe-show_handles.h
+++ b/src/live_effects/lpe-show_handles.h
@@ -20,7 +20,7 @@ class LPEShowHandles : public Effect , GroupBBoxEffect {
 
 public:
     LPEShowHandles(LivePathEffectObject *lpeobject);
-    virtual ~LPEShowHandles(){}
+    virtual ~LPEShowHandles() {}
 
     virtual void doOnApply(SPLPEItem const* lpeitem);
 
@@ -42,13 +42,13 @@ private:
 
     BoolParam nodes;
     BoolParam handles;
-    BoolParam originalPath;
-    ScalarParam scaleNodesAndHandles;
-    ScalarParam rotateNodes;
-    double strokeWidth;
-    static bool alertsOff;
+    BoolParam original_path;
+    ScalarParam scale_nodes_and_handles;
+    ScalarParam rotate_nodes;
+    double stroke_width;
+    static bool alerts_off;
 
-    Geom::PathVector outlinepath;
+    Geom::PathVector outline_path;
 
     LPEShowHandles(const LPEShowHandles &);
     LPEShowHandles &operator=(const LPEShowHandles &);
diff --git a/src/live_effects/lpe-simplify.cpp b/src/live_effects/lpe-simplify.cpp
index 1fe18dd5e..7fc20ede1 100644
--- a/src/live_effects/lpe-simplify.cpp
+++ b/src/live_effects/lpe-simplify.cpp
@@ -27,39 +27,39 @@ namespace LivePathEffect {
 
 LPESimplify::LPESimplify(LivePathEffectObject *lpeobject)
     : Effect(lpeobject),
-            steps(_("Steps:"),_("Change number of simplify steps "), "steps", &wr, this,1),
-            threshold(_("Roughly threshold:"), _("Roughly threshold:"), "threshold", &wr, this, 0.003),
-            smooth_angles(_("Smooth angles:"), _("Max degree difference on handles to preform a smooth"), "smooth_angles", &wr, this, 20.),
-            helper_size(_("Helper size:"), _("Helper size"), "helper_size", &wr, this, 5),
-            simplifyindividualpaths(_("Paths separately"), _("Simplifying paths (separately)"), "simplifyindividualpaths", &wr, this, false,
-                                    "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")),
-            simplifyJustCoalesce(_("Just coalesce"), _("Simplify just coalesce"), "simplifyJustCoalesce", &wr, this, false,
-                                 "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off"))
-            {
-                registerParameter(&steps);
-                registerParameter(&threshold);
-                registerParameter(&smooth_angles);
-                registerParameter(&helper_size);
-                registerParameter(&simplifyindividualpaths);
-                registerParameter(&simplifyJustCoalesce);
+      steps(_("Steps:"),_("Change number of simplify steps "), "steps", &wr, this,1),
+      threshold(_("Roughly threshold:"), _("Roughly threshold:"), "threshold", &wr, this, 0.003),
+      smooth_angles(_("Smooth angles:"), _("Max degree difference on handles to preform a smooth"), "smooth_angles", &wr, this, 20.),
+      helper_size(_("Helper size:"), _("Helper size"), "helper_size", &wr, this, 5),
+      simplify_individual_paths(_("Paths separately"), _("Simplifying paths (separately)"), "simplify_individual_paths", &wr, this, false,
+                              "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")),
+      simplify_just_coalesce(_("Just coalesce"), _("Simplify just coalesce"), "simplify_just_coalesce", &wr, this, false,
+                           "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off"))
+{
+    registerParameter(&steps);
+    registerParameter(&threshold);
+    registerParameter(&smooth_angles);
+    registerParameter(&helper_size);
+    registerParameter(&simplify_individual_paths);
+    registerParameter(&simplify_just_coalesce);
 
-                threshold.param_set_range(0.0001, Geom::infinity());
-                threshold.param_set_increments(0.0001, 0.0001);
-                threshold.param_set_digits(6);
+    threshold.param_set_range(0.0001, Geom::infinity());
+    threshold.param_set_increments(0.0001, 0.0001);
+    threshold.param_set_digits(6);
 
-                steps.param_set_range(0, 100);
-                steps.param_set_increments(1, 1);
-                steps.param_set_digits(0);
+    steps.param_set_range(0, 100);
+    steps.param_set_increments(1, 1);
+    steps.param_set_digits(0);
 
-                smooth_angles.param_set_range(0.0, 365.0);
-                smooth_angles.param_set_increments(10, 10);
-                smooth_angles.param_set_digits(2);
+    smooth_angles.param_set_range(0.0, 365.0);
+    smooth_angles.param_set_increments(10, 10);
+    smooth_angles.param_set_digits(2);
 
-                helper_size.param_set_range(0.0, 999.0);
-                helper_size.param_set_increments(5, 5);
-                helper_size.param_set_digits(2);
+    helper_size.param_set_range(0.0, 999.0);
+    helper_size.param_set_increments(5, 5);
+    helper_size.param_set_digits(2);
 
-                radiusHelperNodes = 6.0;
+    radius_helper_nodes = 6.0;
 }
 
 LPESimplify::~LPESimplify() {}
@@ -67,12 +67,12 @@ LPESimplify::~LPESimplify() {}
 void
 LPESimplify::doBeforeEffect (SPLPEItem const* lpeitem)
 {
-    if(!hp.empty()){
+    if(!hp.empty()) {
         hp.clear();
     }
     bbox = SP_ITEM(lpeitem)->visualBounds();
     SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
-    radiusHelperNodes = helper_size;
+    radius_helper_nodes = helper_size;
     item->apply_to_clippath(item);
     item->apply_to_mask(item);
 }
@@ -91,9 +91,8 @@ LPESimplify::newWidget()
         if ((*it)->widget_is_visible) {
             Parameter * param = *it;
             Gtk::Widget * widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
-            if (param->param_key == "simplifyindividualpaths" || 
-                param->param_key == "simplifyJustCoalesce")
-            {
+            if (param->param_key == "simplify_individual_paths" ||
+                    param->param_key == "simplify_just_coalesce") {
                 Glib::ustring * tip = param->param_getTooltip();
                 if (widg) {
                     buttons->pack_start(*widg, true, true, 2);
@@ -104,13 +103,13 @@ LPESimplify::newWidget()
                         widg->set_has_tooltip(false);
                     }
                 }
-            } else{
+            } else {
                 Glib::ustring * tip = param->param_getTooltip();
                 if (widg) {
-                    Gtk::HBox * scalarParameter = dynamic_cast<Gtk::HBox *>(widg);
-                    std::vector< Gtk::Widget* > childList = scalarParameter->get_children();
-                    Gtk::Entry* entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
-                    entryWidg->set_width_chars(8);
+                    Gtk::HBox * horizontal_box = dynamic_cast<Gtk::HBox *>(widg);
+                    std::vector< Gtk::Widget* > child_list = horizontal_box->get_children();
+                    Gtk::Entry* entry_widg = dynamic_cast<Gtk::Entry *>(child_list[1]);
+                    entry_widg->set_width_chars(8);
                     vbox->pack_start(*widg, true, true, 2);
                     if (tip) {
                         widg->set_tooltip_text(*tip);
@@ -128,28 +127,29 @@ LPESimplify::newWidget()
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
-void 
-LPESimplify::doEffect(SPCurve *curve) {
+void
+LPESimplify::doEffect(SPCurve *curve)
+{
     Geom::PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(curve->get_pathvector());
     gdouble size  = Geom::L2(bbox->dimensions());
     //size /= Geom::Affine(0,0,0,0,0,0).descrim();
     Path* pathliv = Path_for_pathvector(original_pathv);
-    if(simplifyindividualpaths){
+    if(simplify_individual_paths) {
         size = Geom::L2(Geom::bounds_fast(original_pathv)->dimensions());
     }
-    for (int unsigned i = 0; i < steps; i++){
-        if ( simplifyJustCoalesce ) {
-           pathliv->Coalesce(threshold * size);
-        }else{
-           pathliv->ConvertEvenLines(threshold * size);
-           pathliv->Simplify(threshold * size);
+    for (int unsigned i = 0; i < steps; i++) {
+        if ( simplify_just_coalesce ) {
+            pathliv->Coalesce(threshold * size);
+        } else {
+            pathliv->ConvertEvenLines(threshold * size);
+            pathliv->Simplify(threshold * size);
         }
     }
     Geom::PathVector result = Geom::parse_svg_path(pathliv->svg_dump_path());
     generateHelperPathAndSmooth(result);
     curve->set_pathvector(result);
     SPDesktop* desktop = SP_ACTIVE_DESKTOP;
-    if(desktop && INK_IS_NODE_TOOL(desktop->event_context)){
+    if(desktop && INK_IS_NODE_TOOL(desktop->event_context)) {
         Inkscape::UI::Tools::NodeTool *nt = static_cast<Inkscape::UI::Tools::NodeTool*>(desktop->event_context);
         nt->update_helperpath();
     }
@@ -158,15 +158,15 @@ LPESimplify::doEffect(SPCurve *curve) {
 void
 LPESimplify::generateHelperPathAndSmooth(Geom::PathVector &result)
 {
-    if(steps < 1){
+    if(steps < 1) {
         return;
     }
-    Geom::PathVector tmpPath;
+    Geom::PathVector tmp_path;
     Geom::CubicBezier const *cubic = NULL;
     for (Geom::PathVector::iterator path_it = result.begin(); path_it != result.end(); ++path_it) {
         //Si está vacío...
-        if (path_it->empty()){
-          continue;
+        if (path_it->empty()) {
+            continue;
         }
         //Itreadores
         Geom::Path::const_iterator curve_it1 = path_it->begin(); // incoming curve
@@ -174,68 +174,68 @@ LPESimplify::generateHelperPathAndSmooth(Geom::PathVector &result)
         Geom::Path::const_iterator curve_endit = path_it->end_default(); // this determines when the loop has to stop
         SPCurve *nCurve = new SPCurve();
         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();
-          }
+            // 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();
+            }
         }
-        if(helper_size > 0){
+        if(helper_size > 0) {
             drawNode(curve_it1->initialPoint());
         }
         nCurve->moveto(curve_it1->initialPoint());
         Geom::Point start = Geom::Point(0,0);
         while (curve_it1 != curve_endit) {
             cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
-            Geom::Point pointAt1 = curve_it1->initialPoint();
-            Geom::Point pointAt2 = curve_it1->finalPoint();
-            Geom::Point pointAt3 = curve_it1->finalPoint();
-            Geom::Point pointAt4 = curve_it1->finalPoint();
+            Geom::Point point_at1 = curve_it1->initialPoint();
+            Geom::Point point_at2 = curve_it1->finalPoint();
+            Geom::Point point_at3 = curve_it1->finalPoint();
+            Geom::Point point_at4 = curve_it1->finalPoint();
             if (cubic) {
-                pointAt1 = (*cubic)[1];
-                pointAt2 = (*cubic)[2];
+                point_at1 = (*cubic)[1];
+                point_at2 = (*cubic)[2];
             }
-            if(start == Geom::Point(0,0)){
-                start = pointAt1;
+            if(start == Geom::Point(0,0)) {
+                start = point_at1;
             }
-            
-            if(path_it->closed() && curve_it2 == curve_endit){
-                pointAt4 = start;
+
+            if(path_it->closed() && curve_it2 == curve_endit) {
+                point_at4 = start;
             }
-            if(curve_it2 != curve_endit){
+            if(curve_it2 != curve_endit) {
                 cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it2);
                 if (cubic) {
-                    pointAt4 = (*cubic)[1];
+                    point_at4 = (*cubic)[1];
                 }
             }
-            Geom::Ray ray1(pointAt2, pointAt3);
-            Geom::Ray ray2(pointAt3, pointAt4);
+            Geom::Ray ray1(point_at2, point_at3);
+            Geom::Ray ray2(point_at3, point_at4);
             double angle1 = Geom::rad_to_deg(ray1.angle());
             double angle2 = Geom::rad_to_deg(ray2.angle());
-            if((smooth_angles  >= angle2 - angle1) && !are_near(pointAt4,pointAt3) && !are_near(pointAt2,pointAt3)){
-                double dist = Geom::distance(pointAt2,pointAt3);
+            if((smooth_angles  >= angle2 - angle1) && !are_near(point_at4,point_at3) && !are_near(point_at2,point_at3)) {
+                double dist = Geom::distance(point_at2,point_at3);
                 Geom::Angle angleFixed = ray2.angle();
                 angleFixed -= Geom::Angle::from_degrees(180.0);
-                pointAt2 =  Geom::Point::polar(angleFixed,dist) + pointAt3;
+                point_at2 =  Geom::Point::polar(angleFixed,dist) + point_at3;
             }
-            nCurve->curveto(pointAt1, pointAt2, curve_it1->finalPoint());
+            nCurve->curveto(point_at1, point_at2, curve_it1->finalPoint());
             cubic = dynamic_cast<Geom::CubicBezier const *>(nCurve->last_segment());
             if (cubic) {
-                pointAt1 = (*cubic)[1];
-                pointAt2 = (*cubic)[2];
+                point_at1 = (*cubic)[1];
+                point_at2 = (*cubic)[2];
                 if(helper_size > 0) {
-                    if(!are_near((*cubic)[0],(*cubic)[1])){
+                    if(!are_near((*cubic)[0],(*cubic)[1])) {
                         drawHandle((*cubic)[1]);
                         drawHandleLine((*cubic)[0],(*cubic)[1]);
                     }
-                    if(!are_near((*cubic)[3],(*cubic)[2])){
+                    if(!are_near((*cubic)[3],(*cubic)[2])) {
                         drawHandle((*cubic)[2]);
                         drawHandleLine((*cubic)[3],(*cubic)[2]);
                     }
@@ -250,17 +250,17 @@ LPESimplify::generateHelperPathAndSmooth(Geom::PathVector &result)
         if (path_it->closed()) {
             nCurve->closepath_current();
         }
-        tmpPath.push_back(nCurve->get_pathvector()[0]);
+        tmp_path.push_back(nCurve->get_pathvector()[0]);
         nCurve->reset();
         delete nCurve;
     }
-    result = tmpPath;
+    result = tmp_path;
 }
 
-void 
+void
 LPESimplify::drawNode(Geom::Point p)
 {
-    double r = radiusHelperNodes;
+    double r = radius_helper_nodes;
     char const * svgd;
     svgd = "M 0.55,0.5 A 0.05,0.05 0 0 1 0.5,0.55 0.05,0.05 0 0 1 0.45,0.5 0.05,0.05 0 0 1 0.5,0.45 0.05,0.05 0 0 1 0.55,0.5 Z M 0,0 1,0 1,1 0,1 Z";
     Geom::PathVector pathv = sp_svg_read_pathv(svgd);
@@ -273,7 +273,7 @@ LPESimplify::drawNode(Geom::Point p)
 void
 LPESimplify::drawHandle(Geom::Point p)
 {
-    double r = radiusHelperNodes;
+    double r = radius_helper_nodes;
     char const * svgd;
     svgd = "M 0.7,0.35 A 0.35,0.35 0 0 1 0.35,0.7 0.35,0.35 0 0 1 0,0.35 0.35,0.35 0 0 1 0.35,0 0.35,0.35 0 0 1 0.7,0.35 Z";
     Geom::PathVector pathv = sp_svg_read_pathv(svgd);
@@ -288,8 +288,8 @@ LPESimplify::drawHandleLine(Geom::Point p,Geom::Point p2)
 {
     Geom::Path path;
     path.start( p );
-    double diameter = radiusHelperNodes;
-    if(helper_size > 0 && Geom::distance(p,p2) > (diameter * 0.35)){
+    double diameter = radius_helper_nodes;
+    if(helper_size > 0 && Geom::distance(p,p2) > (diameter * 0.35)) {
         Geom::Ray ray2(p, p2);
         p2 =  p2 - Geom::Point::polar(ray2.angle(),(diameter * 0.35));
     }
diff --git a/src/live_effects/lpe-simplify.h b/src/live_effects/lpe-simplify.h
index c18c3ecdf..294d77b35 100644
--- a/src/live_effects/lpe-simplify.h
+++ b/src/live_effects/lpe-simplify.h
@@ -14,43 +14,43 @@
 namespace Inkscape {
 namespace LivePathEffect {
 
-class LPESimplify : public Effect , GroupBBoxEffect{
+class LPESimplify : public Effect , GroupBBoxEffect {
 
 public:
-  LPESimplify(LivePathEffectObject *lpeobject);
-  virtual ~LPESimplify();
+    LPESimplify(LivePathEffectObject *lpeobject);
+    virtual ~LPESimplify();
 
-  virtual void doEffect(SPCurve *curve);
+    virtual void doEffect(SPCurve *curve);
 
-  virtual void doBeforeEffect (SPLPEItem const* lpeitem);
+    virtual void doBeforeEffect (SPLPEItem const* lpeitem);
 
-  virtual void generateHelperPathAndSmooth(Geom::PathVector &result);
+    virtual void generateHelperPathAndSmooth(Geom::PathVector &result);
 
-  virtual Gtk::Widget * newWidget();
+    virtual Gtk::Widget * newWidget();
 
-  virtual void drawNode(Geom::Point p);
-  
-  virtual void drawHandle(Geom::Point p);
+    virtual void drawNode(Geom::Point p);
 
-  virtual void drawHandleLine(Geom::Point p,Geom::Point p2);
+    virtual void drawHandle(Geom::Point p);
+
+    virtual void drawHandleLine(Geom::Point p,Geom::Point p2);
 
 protected:
     void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec);
 
 private:
-  ScalarParam steps;
-  ScalarParam threshold;
-  ScalarParam smooth_angles;
-  ScalarParam helper_size;
-  ToggleButtonParam simplifyindividualpaths;
-  ToggleButtonParam simplifyJustCoalesce;
-
-  double radiusHelperNodes;
-  Geom::PathVector hp;
-  Geom::OptRect bbox;
-
-  LPESimplify(const LPESimplify &);
-  LPESimplify &operator=(const LPESimplify &);
+    ScalarParam steps;
+    ScalarParam threshold;
+    ScalarParam smooth_angles;
+    ScalarParam helper_size;
+    ToggleButtonParam simplify_individual_paths;
+    ToggleButtonParam simplify_just_coalesce;
+
+    double radius_helper_nodes;
+    Geom::PathVector hp;
+    Geom::OptRect bbox;
+
+    LPESimplify(const LPESimplify &);
+    LPESimplify &operator=(const LPESimplify &);
 
 };
 
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]);
         }