diff --git a/container/calculator.cpp b/container/calculator.cpp
index 36e7202e9..1ba0a8477 100644
--- a/container/calculator.cpp
+++ b/container/calculator.cpp
@@ -30,11 +30,8 @@
 #define FINISHED   10
 #define EOL        9
 
-Calculator::Calculator(const VContainer *data):errorMsg(0), token(QString()), tok(0), token_type(0),
-    prog(QString()), index(0), data(data), debugFormula(QString()){
-}
-
-qreal Calculator::eval(QString prog, QString *errorMsg){
+qreal Calculator::eval(QString prog, QString *errorMsg)
+{
     this->errorMsg = errorMsg;
     this->errorMsg->clear();
     debugFormula.clear();
@@ -48,10 +45,12 @@ qreal Calculator::eval(QString prog, QString *errorMsg){
     return result;
 }
 
-qreal Calculator::get_exp(){
+qreal Calculator::get_exp()
+{
     qreal result = 0;
     get_token();
-    if(token.isEmpty()) {
+    if (token.isEmpty())
+    {
         serror(2);
         return 0;
     }
@@ -62,38 +61,44 @@ qreal Calculator::get_exp(){
 }
 
 /* Сложение или вычитание двух термов */
-void Calculator::level2(qreal *result){
+void Calculator::level2(qreal *result)
+{
     QChar op;
     qreal hold;
 
     level3(result);
-    while((op=token[0]) == '+' || op == '-') {
+    while ((op=token[0]) == '+' || op == '-')
+    {
         get_token();
         level3(&hold);
-        arith(op,result,&hold);
+        arith(op, result, &hold);
     }
 }
 
 /* Вычисление произведения или частного двух фвкторов */
-void Calculator::level3(qreal *result){
+void Calculator::level3(qreal *result)
+{
     QChar op;
     qreal hold;
 
     level4(result);
 
-    while((op = token[0]) == '*' || op == '/' || op == '%') {
+    while ((op = token[0]) == '*' || op == '/' || op == '%')
+    {
         get_token();
         level4(&hold);
-        arith(op,result,&hold);
+        arith(op, result, &hold);
     }
 }
 
 /* Обработка степени числа (целочисленной) */
-void Calculator::level4(qreal *result){
+void Calculator::level4(qreal *result)
+{
     qreal hold;
 
     level5(result);
-    if(token[0] == '^') {
+    if (token[0] == '^')
+    {
         get_token();
         level4(&hold);
         arith('^', result, &hold);
@@ -101,35 +106,45 @@ void Calculator::level4(qreal *result){
 }
 
 /* Унарный + или - */
-void Calculator::level5(qreal *result){
+void Calculator::level5(qreal *result)
+{
     QChar op;
 
     op = '\0';
-    if((token_type==DELIMITER) && (token[0]=='+' || token[0]=='-')) {
+    if ((token_type==DELIMITER) && (token[0]=='+' || token[0]=='-'))
+    {
         op = token[0];
         get_token();
     }
     level6(result);
-    if(op != '\0')
+    if (op != '\0')
+    {
         unary(op, result);
+    }
 }
 
 /* Обработка выражения в круглых скобках */
-void Calculator::level6(qreal *result){
-    if((token[0] == '(') && (token_type == DELIMITER)) {
+void Calculator::level6(qreal *result)
+{
+    if ((token[0] == '(') && (token_type == DELIMITER))
+    {
         get_token();
         level2(result);
-        if(token[0] != ')')
+        if (token[0] != ')')
+        {
             serror(1);
+        }
         get_token();
     } else
         primitive(result);
 }
 
 /* Определение значения переменной по ее имени */
-void Calculator::primitive(qreal *result){
+void Calculator::primitive(qreal *result)
+{
     QString str;
-    switch(token_type) {
+    switch (token_type)
+    {
         case VARIABLE:
             *result = find_var(token);
             str = QString("%1").arg(*result, 0, 'f', 3);
@@ -148,10 +163,12 @@ void Calculator::primitive(qreal *result){
 }
 
 /* Выполнение специфицированной арифметики */
-void Calculator::arith(QChar o, qreal *r, qreal *h){
+void Calculator::arith(QChar o, qreal *r, qreal *h)
+{
     qreal  t;//, ex;
 
-    switch(o.toLatin1()) {
+    switch (o.toLatin1())
+    {
         case '-':
             *r = *r-*h;
             break;
@@ -177,21 +194,26 @@ void Calculator::arith(QChar o, qreal *r, qreal *h){
 //            }
 //            for(t=*h-1; t>0; --t)
 //                *r = (*r) * ex;
-            break;    
-      }
+            break;
+    }
 }
 
 /* Изменение знака */
-void Calculator::unary(QChar o, qreal *r){
-    if(o=='-')
+void Calculator::unary(QChar o, qreal *r)
+{
+    if (o=='-')
+    {
         *r = -(*r);
+    }
 }
 
 /* Поиск значения переменной */
-qreal Calculator::find_var(QString s){
+qreal Calculator::find_var(QString s)
+{
     bool ok = false;
     qreal value = data->FindVar(s, &ok);
-    if(!ok){
+    if (ok == false)
+    {
         qDebug()<<s;
         serror(4); /* не переменная */
         return 0;
@@ -200,23 +222,26 @@ qreal Calculator::find_var(QString s){
 }
 
 /* выдать сообщение об ошибке */
-void Calculator::serror(qint32 error){
-    QString e[]= {
+void Calculator::serror(qint32 error)
+{
+    QString e[]=
+    {
                  "Синтаксическая ошибка",
                  "Непарные круглые скобки",
                  "Это не выражение",
                  "Предполагается символ равенства",
                  "Не переменная"
-     };
+    };
     errorMsg->clear();
     *errorMsg = e[error];
-     qDebug()<<e[error];
+    qDebug()<<e[error];
 }
 
 /* Поиск соответствия внутреннего формата для
                 текущей лексемы в таблице лексем.
              */
-char Calculator::look_up(QString s){
+char Calculator::look_up(QString s)
+{
     QString p;
 
     /* преобразование к нижнему регистру */
@@ -235,37 +260,51 @@ char Calculator::look_up(QString s){
 }
 
 /* Возвращает "истину", если "c" разделитель */
-bool Calculator::isdelim(QChar c){
-    if(StrChr(" ;,+-<>/*%^=()",c) || c=='\n' || c=='\r' || c=='\0')
+bool Calculator::isdelim(QChar c)
+{
+    if (StrChr(" ;,+-<>/*%^=()", c) || c=='\n' || c=='\r' || c=='\0')
+    {
         return true;
+    }
     return false;
 }
 
 /* Возвращает 1, если "с" пробел или табуляция */
-bool Calculator::iswhite(QChar c){
-    if(c==' ' || c=='\t')
+bool Calculator::iswhite(QChar c)
+{
+    if (c==' ' || c=='\t')
+    {
         return true;
+    }
     else
+    {
         return false;
+    }
 }
 
-void Calculator::get_token(){
+void Calculator::get_token()
+{
     QString *temp;
 
     token_type=0; tok=0;
     token.clear();
     temp=&token;
 
-    if(prog[index]=='\0')  { /* Конец файла */
+    if (prog[index]=='\0')
+    { /* Конец файла */
         token="\0";
         tok=FINISHED;
         token_type=DELIMITER;
         return;
     }
 
-    while(iswhite(prog[index])) ++index;  /* пропуск пробелов */
+    while (iswhite(prog[index]))
+    {
+        ++index;  /* пропуск пробелов */
+    }
 
-    if(prog[index]=='\r') { /* crtl */
+    if (prog[index]=='\r')
+    { /* crtl */
         ++index; ++index;
         tok= EOL; token='\r';
         token.append('\n');token.append("\0");
@@ -273,7 +312,8 @@ void Calculator::get_token(){
         return;
     }
 
-    if(StrChr("+-*^/%=;(),><", prog[index])) { /* разделитель */
+    if (StrChr("+-*^/%=;(),><", prog[index]))
+    { /* разделитель */
         *temp=prog[index];
         index++; /* переход на следующую позицию */
         temp->append("\0");
@@ -281,20 +321,26 @@ void Calculator::get_token(){
         debugFormula.append(token);
         return;
     }
-    if(prog[index]=='"')  { /* строка в кавычках */
+    if (prog[index]=='"')
+    { /* строка в кавычках */
         index++;
-        while(prog[index] != '"' && prog[index] != '\r'){
+        while (prog[index] != '"' && prog[index] != '\r')
+        {
             temp->append(prog[index]);
             index++;
         }
-        if(prog[index]=='\r')
+        if (prog[index]=='\r')
+        {
             serror(1);
+        }
         index++;temp->append("\0");
         token_type=QUOTE;
         return;
     }
-    if(prog[index].isDigit()) { /* число */
-        while(!isdelim(prog[index])){
+    if (prog[index].isDigit())
+    { /* число */
+        while (isdelim(prog[index]) == false)
+        {
             temp->append(prog[index]);
             index++;
         }
@@ -303,8 +349,10 @@ void Calculator::get_token(){
         return;
     }
 
-    if(prog[index].isPrint())  { /* переменная или команда */
-        while(!isdelim(prog[index])){
+    if (prog[index].isPrint())
+    { /* переменная или команда */
+        while (isdelim(prog[index]) == false)
+        {
             temp->append(prog[index]);
             index++;
         }
@@ -313,22 +361,30 @@ void Calculator::get_token(){
     temp->append("\0");
 
     /* Просматривается, если строка есть команда или переменная */
-    if(token_type==STRING) {
+    if (token_type==STRING)
+    {
         tok=look_up(token); /* преобразование во внутренний
                                           формат */
-        if(!tok)
+        if (tok == false)
+        {
             token_type = VARIABLE;
-        else token_type = COMMAND; /* это команда */
-     }
+        }
+        else
+        {
+            token_type = COMMAND; /* это команда */
+        }
+    }
     return;
 }
 
-bool Calculator::StrChr(QString string, QChar c){
+bool Calculator::StrChr(QString string, QChar c)
+{
     return string.contains(c, Qt::CaseInsensitive);
 }
 
 /*  Возвращает лексему обратно во входной поток */
-void Calculator::putback(){
+void Calculator::putback()
+{
     QString t;
     t = token;
     index = index - t.size();
diff --git a/container/calculator.h b/container/calculator.h
index 607dd648e..6fa29c3ed 100644
--- a/container/calculator.h
+++ b/container/calculator.h
@@ -28,13 +28,15 @@
  * @brief The Calculator клас калькулятора формул лекал. Виконує розрахунок формул з підставлянням
  * значеннь зміних.
  */
-class Calculator{
+class Calculator
+{
 public:
     /**
      * @brief Calculator конструктор класу. Використовується при розрахунку лекала.
      * @param data покажчик на контейнер змінних
      */
-    explicit    Calculator(const VContainer *data);
+    explicit Calculator(const VContainer *data):errorMsg(0), token(QString()), tok(0), token_type(0), prog(QString()),
+        index(0), data(data), debugFormula(QString()){}
     /**
      * @brief eval виконує розрахунок формули.
      * @param prog рядко в якому зберігається формула.
@@ -143,7 +145,7 @@ private:
     qreal       find_var(QString s);
     void        serror(qint32 error);
     /**
-     * @brief look_up пошук відповідного внутрішнього формату для теперішньої лексеми в таблиці лексем.            текущей лексемы в таблице лексем
+     * @brief look_up пошук відповідного внутрішнього формату для теперішньої лексеми в таблиці лексем.
      * @param s ім'я лексеми.
      * @return внутрішній номер лексеми.
      */
diff --git a/container/vcontainer.cpp b/container/vcontainer.cpp
index 7b94c7ab2..2a6daca3d 100644
--- a/container/vcontainer.cpp
+++ b/container/vcontainer.cpp
@@ -24,7 +24,8 @@
 
 qint64 VContainer::_id = 0;
 
-VContainer::VContainer():base(QHash<QString, qint32>()), points(QHash<qint64, VPointF>()),
+VContainer::VContainer()
+    :base(QHash<QString, qint32>()), points(QHash<qint64, VPointF>()),
     modelingPoints(QHash<qint64, VPointF>()),
     standartTable(QHash<QString, VStandartTableCell>()), incrementTable(QHash<QString, VIncrementTableRow>()),
     lengthLines(QHash<QString, qreal>()), lineAngles(QHash<QString, qreal>()), splines(QHash<qint64, VSpline>()),
@@ -32,18 +33,21 @@ VContainer::VContainer():base(QHash<QString, qint32>()), points(QHash<qint64, VP
     lengthSplines(QHash<QString, qreal>()), arcs(QHash<qint64, VArc>()), modelingArcs(QHash<qint64, VArc>()),
     lengthArcs(QHash<QString, qreal>()),
     splinePaths(QHash<qint64, VSplinePath>()), modelingSplinePaths(QHash<qint64, VSplinePath>()),
-    details(QHash<qint64, VDetail>()){
+    details(QHash<qint64, VDetail>())
+{
     SetSize(500);
     SetGrowth(1760);
     CreateManTableIGroup ();
 }
 
-VContainer &VContainer::operator =(const VContainer &data){
+VContainer &VContainer::operator =(const VContainer &data)
+{
     setData(data);
     return *this;
 }
 
-VContainer::VContainer(const VContainer &data):base(QHash<QString, qint32>()), points(QHash<qint64, VPointF>()),
+VContainer::VContainer(const VContainer &data)
+    :base(QHash<QString, qint32>()), points(QHash<qint64, VPointF>()),
     modelingPoints(QHash<qint64, VPointF>()),
     standartTable(QHash<QString, VStandartTableCell>()), incrementTable(QHash<QString, VIncrementTableRow>()),
     lengthLines(QHash<QString, qreal>()), lineAngles(QHash<QString, qreal>()), splines(QHash<qint64, VSpline>()),
@@ -51,11 +55,13 @@ VContainer::VContainer(const VContainer &data):base(QHash<QString, qint32>()), p
     lengthSplines(QHash<QString, qreal>()), arcs(QHash<qint64, VArc>()), modelingArcs(QHash<qint64, VArc>()),
     lengthArcs(QHash<QString, qreal>()),
     splinePaths(QHash<qint64, VSplinePath>()), modelingSplinePaths(QHash<qint64, VSplinePath>()),
-    details(QHash<qint64, VDetail>()){
+    details(QHash<qint64, VDetail>())
+{
     setData(data);
 }
 
-void VContainer::setData(const VContainer &data){
+void VContainer::setData(const VContainer &data)
+{
     base = *data.DataBase();
     points = *data.DataPoints();
     modelingPoints = *data.DataModelingPoints();
@@ -75,158 +81,201 @@ void VContainer::setData(const VContainer &data){
 }
 
 template <typename key, typename val>
-val VContainer::GetObject(const QHash<key, val> &obj, key id){
-    if(obj.contains(id)){
+val VContainer::GetObject(const QHash<key, val> &obj, key id)
+{
+    if (obj.contains(id))
+    {
         return obj.value(id);
-    } else {
+    }
+    else
+    {
         throw VExceptionBadId(tr("Can't find object"), id);
     }
 }
 
-VStandartTableCell VContainer::GetStandartTableCell(const QString &name) const{
-    Q_ASSERT(!name.isEmpty());
+VStandartTableCell VContainer::GetStandartTableCell(const QString &name) const
+{
+    Q_ASSERT(name.isEmpty()==false);
     return GetObject(standartTable, name);
 }
 
-VIncrementTableRow VContainer::GetIncrementTableRow(const QString& name) const{
-    Q_ASSERT(!name.isEmpty());
+VIncrementTableRow VContainer::GetIncrementTableRow(const QString& name) const
+{
+    Q_ASSERT(name.isEmpty()==false);
     return GetObject(incrementTable, name);
 }
 
-qreal VContainer::GetLine(const QString &name) const{
-    Q_ASSERT(!name.isEmpty());
+qreal VContainer::GetLine(const QString &name) const
+{
+    Q_ASSERT(name.isEmpty()==false);
     return GetObject(lengthLines, name);
 }
 
-qreal VContainer::GetLengthArc(const QString &name) const{
-    Q_ASSERT(!name.isEmpty());
+qreal VContainer::GetLengthArc(const QString &name) const
+{
+    Q_ASSERT(name.isEmpty()==false);
     return GetObject(lengthArcs, name);
 }
 
-qreal VContainer::GetLengthSpline(const QString &name) const{
-    Q_ASSERT(!name.isEmpty());
+qreal VContainer::GetLengthSpline(const QString &name) const
+{
+    Q_ASSERT(name.isEmpty()==false);
     return GetObject(lengthSplines, name);
 }
 
-qreal VContainer::GetLineAngle(const QString &name) const{
-    Q_ASSERT(!name.isEmpty());
+qreal VContainer::GetLineAngle(const QString &name) const
+{
+    Q_ASSERT(name.isEmpty()==false);
     return GetObject(lineAngles, name);
 }
 
-qint64 VContainer::AddPoint(const VPointF &point){
+qint64 VContainer::AddPoint(const VPointF &point)
+{
     return AddObject(points, point);
 }
 
-qint64 VContainer::AddModelingPoint(const VPointF &point){
-return AddObject(modelingPoints, point);
+qint64 VContainer::AddModelingPoint(const VPointF &point)
+{
+    return AddObject(modelingPoints, point);
 }
 
-qint64 VContainer::AddDetail(const VDetail &detail){
+qint64 VContainer::AddDetail(const VDetail &detail)
+{
     return AddObject(details, detail);
 }
 
-qint64 VContainer::getNextId(){
+qint64 VContainer::getNextId()
+{
     _id++;
     return _id;
 }
 
-void VContainer::UpdateId(qint64 newId){
-    if(newId > _id){
+void VContainer::UpdateId(qint64 newId)
+{
+    if (newId > _id)
+    {
        _id = newId;
     }
 }
 
-QPainterPath VContainer::ContourPath(qint64 idDetail) const{
+QPainterPath VContainer::ContourPath(qint64 idDetail) const
+{
     VDetail detail = GetDetail(idDetail);
     QVector<QPointF> points;
     QVector<QPointF> pointsEkv;
-    for(qint32 i = 0; i< detail.CountNode(); ++i){
-        switch(detail[i].getTypeTool()){
-        case(Tool::NodePoint):{
-            VPointF point = GetModelingPoint(detail[i].getId());
-            points.append(point.toQPointF());
-            if(detail.getSupplement() == true){
-                QPointF pEkv = point.toQPointF();
-                pEkv.setX(pEkv.x()+detail[i].getMx());
-                pEkv.setY(pEkv.y()+detail[i].getMy());
-                pointsEkv.append(pEkv);
-            }
-        }
-            break;
-        case(Tool::NodeArc):{
-            VArc arc = GetModelingArc(detail[i].getId());
-            qreal len1 = GetLengthContour(points, arc.GetPoints());
-            qreal lenReverse = GetLengthContour(points, GetReversePoint(arc.GetPoints()));
-            if(len1 <= lenReverse){
-                points << arc.GetPoints();
-                if(detail.getSupplement() == true){
-                    pointsEkv << biasPoints(arc.GetPoints(), detail[i].getMx(), detail[i].getMy());
+    for (qint32 i = 0; i< detail.CountNode(); ++i)
+    {
+        switch (detail[i].getTypeTool())
+        {
+            case (Tool::NodePoint):
+            {
+                VPointF point = GetModelingPoint(detail[i].getId());
+                points.append(point.toQPointF());
+                if (detail.getSupplement() == true)
+                {
+                    QPointF pEkv = point.toQPointF();
+                    pEkv.setX(pEkv.x()+detail[i].getMx());
+                    pEkv.setY(pEkv.y()+detail[i].getMy());
+                    pointsEkv.append(pEkv);
                 }
-            } else {
-                points << GetReversePoint(arc.GetPoints());
-                if(detail.getSupplement() == true){
-                    pointsEkv << biasPoints(GetReversePoint(arc.GetPoints()), detail[i].getMx(),
+            }
+            break;
+            case (Tool::NodeArc):
+            {
+                VArc arc = GetModelingArc(detail[i].getId());
+                qreal len1 = GetLengthContour(points, arc.GetPoints());
+                qreal lenReverse = GetLengthContour(points, GetReversePoint(arc.GetPoints()));
+                if (len1 <= lenReverse)
+                {
+                    points << arc.GetPoints();
+                    if (detail.getSupplement() == true)
+                    {
+                        pointsEkv << biasPoints(arc.GetPoints(), detail[i].getMx(), detail[i].getMy());
+                    }
+                }
+                else
+                {
+                    points << GetReversePoint(arc.GetPoints());
+                    if (detail.getSupplement() == true)
+                    {
+                        pointsEkv << biasPoints(GetReversePoint(arc.GetPoints()), detail[i].getMx(), detail[i].getMy());
+                    }
+                }
+            }
+            break;
+            case (Tool::NodeSpline):
+            {
+                VSpline spline = GetModelingSpline(detail[i].getId());
+                qreal len1 = GetLengthContour(points, spline.GetPoints());
+                qreal lenReverse = GetLengthContour(points, GetReversePoint(spline.GetPoints()));
+                if (len1 <= lenReverse)
+                {
+                    points << spline.GetPoints();
+                    if (detail.getSupplement() == true)
+                    {
+                        pointsEkv << biasPoints(spline.GetPoints(), detail[i].getMx(), detail[i].getMy());
+                    }
+                }
+                else
+                {
+                    points << GetReversePoint(spline.GetPoints());
+                    if (detail.getSupplement() == true)
+                    {
+                        pointsEkv << biasPoints(GetReversePoint(spline.GetPoints()), detail[i].getMx(),
                                                 detail[i].getMy());
+                    }
                 }
             }
-        }
             break;
-        case(Tool::NodeSpline):{
-            VSpline spline = GetModelingSpline(detail[i].getId());
-            qreal len1 = GetLengthContour(points, spline.GetPoints());
-            qreal lenReverse = GetLengthContour(points, GetReversePoint(spline.GetPoints()));
-            if(len1 <= lenReverse){
-                points << spline.GetPoints();
-                if(detail.getSupplement() == true){
-                    pointsEkv << biasPoints(spline.GetPoints(), detail[i].getMx(), detail[i].getMy());
+            case (Tool::NodeSplinePath):
+            {
+                VSplinePath splinePath = GetModelingSplinePath(detail[i].getId());
+                qreal len1 = GetLengthContour(points, splinePath.GetPathPoints());
+                qreal lenReverse = GetLengthContour(points, GetReversePoint(splinePath.GetPathPoints()));
+                if (len1 <= lenReverse)
+                {
+                    points << splinePath.GetPathPoints();
+                    if (detail.getSupplement() == true)
+                    {
+                     pointsEkv << biasPoints(splinePath.GetPathPoints(), detail[i].getMx(), detail[i].getMy());
+                    }
                 }
-            } else {
-                points << GetReversePoint(spline.GetPoints());
-                if(detail.getSupplement() == true){
-                    pointsEkv << biasPoints(GetReversePoint(spline.GetPoints()), detail[i].getMx(),
-                                            detail[i].getMy());
+                else
+                {
+                    points << GetReversePoint(splinePath.GetPathPoints());
+                    if (detail.getSupplement() == true)
+                    {
+                        pointsEkv << biasPoints(GetReversePoint(splinePath.GetPathPoints()), detail[i].getMx(),
+                                                detail[i].getMy());
+                    }
                 }
             }
+            break;
+            case (Tool::SplineTool):
+                break;//Nothing to do, just ignore.
+            default:
+                qWarning()<<"Get wrong tool type. Ignore."<<detail[i].getTypeTool();
+                break;
         }
-            break;
-        case(Tool::NodeSplinePath):{
-            VSplinePath splinePath = GetModelingSplinePath(detail[i].getId());
-            qreal len1 = GetLengthContour(points, splinePath.GetPathPoints());
-            qreal lenReverse = GetLengthContour(points, GetReversePoint(splinePath.GetPathPoints()));
-            if(len1 <= lenReverse){
-                points << splinePath.GetPathPoints();
-                if(detail.getSupplement() == true){
-                    pointsEkv << biasPoints(splinePath.GetPathPoints(), detail[i].getMx(), detail[i].getMy());
-                }
-            } else {
-                points << GetReversePoint(splinePath.GetPathPoints());
-                if(detail.getSupplement() == true){
-                    pointsEkv << biasPoints(GetReversePoint(splinePath.GetPathPoints()), detail[i].getMx(),
-                                            detail[i].getMy());
-                }
-            }
-        }
-            break;
-        case(Tool::SplineTool):
-            break;//Nothing to do, just ignore.
-        default:
-            qWarning()<<"Get wrong tool type. Ignore."<<detail[i].getTypeTool();
-            break;
-        } 
     }
 
     QPainterPath path;
     path.moveTo(points[0]);
-    for (qint32 i = 1; i < points.count(); ++i){
+    for (qint32 i = 1; i < points.count(); ++i)
+    {
         path.lineTo(points[i]);
     }
     path.lineTo(points[0]);
 
-    if(detail.getSupplement() == true){
+    if (detail.getSupplement() == true)
+    {
         QPainterPath ekv;
-        if(detail.getClosed() == true){
+        if (detail.getClosed() == true)
+        {
             ekv = Equidistant(pointsEkv, Detail::CloseEquidistant, toPixel(detail.getWidth()));
-        } else {
+        }
+        else
+        {
             ekv = Equidistant(pointsEkv, Detail::OpenEquidistant, toPixel(detail.getWidth()));
         }
         path.addPath(ekv);
@@ -235,54 +284,71 @@ QPainterPath VContainer::ContourPath(qint64 idDetail) const{
     return path;
 }
 
-QVector<QPointF> VContainer::biasPoints(const QVector<QPointF> &points, const qreal &mx, const qreal &my) const{
+QVector<QPointF> VContainer::biasPoints(const QVector<QPointF> &points, const qreal &mx, const qreal &my) const
+{
     QVector<QPointF> p;
-    for(qint32 i = 0; i < points.size(); ++i){
+    for (qint32 i = 0; i < points.size(); ++i)
+    {
         QPointF point = points.at(i);
         point.setX(point.x() + mx);
-        point.setY(point.x() + my);
+        point.setY(point.y() + my);
         p.append(point);
     }
     return p;
 }
 
-QPainterPath VContainer::Equidistant(QVector<QPointF> points, const Detail::Equidistant &eqv,
-                                     const qreal &width) const{
+QPainterPath VContainer::Equidistant(QVector<QPointF> points, const Detail::Equidistant &eqv, const qreal &width) const
+{
     QPainterPath ekv;
     QVector<QPointF> ekvPoints;
-    if ( points.size() < 3 ){
+    if ( points.size() < 3 )
+    {
         qDebug()<<"Not enough points for build equidistant.\n";
         return ekv;
     }
-    for (qint32 i = 0; i < points.size(); ++i ){
-        if(i != points.size()-1){
-            if(points[i] == points[i+1]){
+    for (qint32 i = 0; i < points.size(); ++i )
+    {
+        if (i != points.size()-1)
+        {
+            if (points[i] == points[i+1])
+            {
                 points.remove(i+1);
             }
-        } else {
-            if(points[i] == points[0]){
+        }
+        else
+        {
+            if (points[i] == points[0])
+            {
                 points.remove(i);
             }
         }
     }
-    if(eqv == Detail::CloseEquidistant){
+    if (eqv == Detail::CloseEquidistant)
+    {
         points.append(points.at(0));
     }
-    for (qint32 i = 0; i < points.size(); ++i ){
-        if ( i == 0 && eqv == Detail::CloseEquidistant){//перша точка, ламана замкнена
-            ekvPoints<<EkvPoint(QLineF(points[points.size()-2], points[points.size()-1]),
-                    QLineF(points[1], points[0]), width);
+    for (qint32 i = 0; i < points.size(); ++i )
+    {
+        if ( i == 0 && eqv == Detail::CloseEquidistant)
+        {//перша точка, ламана замкнена
+            ekvPoints<<EkvPoint(QLineF(points[points.size()-2], points[points.size()-1]), QLineF(points[1], points[0]),
+                    width);
             continue;
-        } else if(i == 0 && eqv == Detail::OpenEquidistant){//перша точка, ламана не замкнена
+        }
+        else if (i == 0 && eqv == Detail::OpenEquidistant)
+        {//перша точка, ламана не замкнена
             ekvPoints.append(SingleParallelPoint(QLineF(points[0], points[1]), 90, width));
             continue;
         }
-        if(i == points.size()-1 && eqv == Detail::CloseEquidistant){//остання точка, ламана замкнена
+        if (i == points.size()-1 && eqv == Detail::CloseEquidistant)
+        {//остання точка, ламана замкнена
             ekvPoints.append(ekvPoints.at(0));
             continue;
-        } else if(i == points.size()-1 && eqv == Detail::OpenEquidistant){//остання точка, ламана не замкнена
-                ekvPoints.append(SingleParallelPoint(QLineF(points[points.size()-1],
-                                                   points[points.size()-2]), -90, width));
+        }
+        else if (i == points.size()-1 && eqv == Detail::OpenEquidistant)
+        {//остання точка, ламана не замкнена
+                ekvPoints.append(SingleParallelPoint(QLineF(points[points.size()-1], points[points.size()-2]), -90,
+                        width));
                 continue;
         }
         //точка яка не лежить ні на початку ні в кінці
@@ -290,107 +356,130 @@ QPainterPath VContainer::Equidistant(QVector<QPointF> points, const Detail::Equi
     }
     ekvPoints = CheckLoops(ekvPoints);
     ekv.moveTo(ekvPoints[0]);
-    for (qint32 i = 1; i < ekvPoints.count(); ++i){
+    for (qint32 i = 1; i < ekvPoints.count(); ++i)
+    {
         ekv.lineTo(ekvPoints[i]);
     }
     return ekv;
 }
 
-QLineF VContainer::ParallelLine(const QLineF &line, qreal width){
+QLineF VContainer::ParallelLine(const QLineF &line, qreal width)
+{
     Q_ASSERT(width > 0);
-    QLineF paralel = QLineF (SingleParallelPoint(line, 90, width),
-                             SingleParallelPoint(QLineF(line.p2(), line.p1()), -90, width));
+    QLineF paralel = QLineF (SingleParallelPoint(line, 90, width), SingleParallelPoint(QLineF(line.p2(), line.p1()),
+                                                                                       -90, width));
     return paralel;
 }
 
-QPointF VContainer::SingleParallelPoint(const QLineF &line, const qreal &angle, const qreal &width){
+QPointF VContainer::SingleParallelPoint(const QLineF &line, const qreal &angle, const qreal &width)
+{
     Q_ASSERT(width > 0);
-    QLineF l = line;
-    l.setAngle( l.angle() + angle );
-    l.setLength( width );
-    return l.p2();
+    QLineF pLine = line;
+    pLine.setAngle( pLine.angle() + angle );
+    pLine.setLength( width );
+    return pLine.p2();
 }
 
-QVector<QPointF> VContainer::EkvPoint(const QLineF &line1, const QLineF &line2, const qreal &width) const{
+QVector<QPointF> VContainer::EkvPoint(const QLineF &line1, const QLineF &line2, const qreal &width) const
+{
     Q_ASSERT(width > 0);
     QVector<QPointF> points;
-    if(line1.p2() != line2.p2()){
+    if (line1.p2() != line2.p2())
+    {
         qWarning()<<"Last point of two lines must be equal.";
     }
     QPointF CrosPoint;
     QLineF bigLine1 = ParallelLine(line1, width );
     QLineF bigLine2 = ParallelLine(QLineF(line2.p2(), line2.p1()), width );
     QLineF::IntersectType type = bigLine1.intersect( bigLine2, &CrosPoint );
-    switch(type){
-    case(QLineF::BoundedIntersection):
-        points.append(CrosPoint);
-        return points;
-        break;
-    case(QLineF::UnboundedIntersection):{
-        QLineF line( line1.p2(), CrosPoint );
-        if(line.length() > width + toPixel(8)){
-            QLineF l;
-            l = QLineF(bigLine1.p2(), CrosPoint);
-            l.setLength(width);
-            points.append(l.p2());
-
-            l = QLineF(bigLine2.p1(), CrosPoint);
-            l.setLength(width);
-            points.append(l.p2());
-        } else {
+    switch (type)
+    {
+        case (QLineF::BoundedIntersection):
             points.append(CrosPoint);
             return points;
+            break;
+        case (QLineF::UnboundedIntersection):
+        {
+            QLineF line( line1.p2(), CrosPoint );
+            if (line.length() > width + toPixel(8))
+            {
+                QLineF lineL;
+                lineL = QLineF(bigLine1.p2(), CrosPoint);
+                lineL.setLength(width);
+                points.append(lineL.p2());
+
+                lineL = QLineF(bigLine2.p1(), CrosPoint);
+                lineL.setLength(width);
+                points.append(lineL.p2());
+            }
+            else
+            {
+                points.append(CrosPoint);
+                return points;
+            }
+            break;
         }
-        break;
-    }
-    case(QLineF::NoIntersection):
-        /*If we have correct lines this means lines lie on a line.*/
-        points.append(bigLine1.p2());
-        return points;
-        break;
+        case (QLineF::NoIntersection):
+            /*If we have correct lines this means lines lie on a line.*/
+            points.append(bigLine1.p2());
+            return points;
+            break;
     }
     return points;
 }
 
-QVector<QPointF> VContainer::CheckLoops(const QVector<QPointF> &points) const{
+QVector<QPointF> VContainer::CheckLoops(const QVector<QPointF> &points) const
+{
     QVector<QPointF> ekvPoints;
     /*If we got less than 4 points no need seek loops.*/
-    if(points.size() < 4){
+    if (points.size() < 4)
+    {
        return ekvPoints;
     }
     bool closed = false;
-    if(points.at(0) == points.at(points.size()-1)){
+    if (points.at(0) == points.at(points.size()-1))
+    {
         closed = true;
     }
     qint32 i, j;
-    for(i = 0; i < points.size(); ++i){
+    for (i = 0; i < points.size(); ++i)
+    {
         /*Last three points no need check.*/
-        if(i >= points.size()-3){
+        if (i >= points.size()-3)
+        {
             ekvPoints.append(points.at(i));
             continue;
         }
         QPointF crosPoint;
         QLineF::IntersectType intersect = QLineF::NoIntersection;
-        QLineF line1(points.at(i),points.at(i+1));
-        for(j = i+2; j < points.size()-1; ++j){
-            QLineF line2(points.at(j),points.at(j+1));
+        QLineF line1(points.at(i), points.at(i+1));
+        for (j = i+2; j < points.size()-1; ++j)
+        {
+            QLineF line2(points.at(j), points.at(j+1));
             intersect = line1.intersect(line2, &crosPoint);
-            if(intersect == QLineF::BoundedIntersection){
+            if (intersect == QLineF::BoundedIntersection)
+            {
                 break;
             }
         }
-        if(intersect == QLineF::BoundedIntersection){
-            if(i == 0 && j+1 == points.size()-1 && closed){
+        if (intersect == QLineF::BoundedIntersection)
+        {
+            if (i == 0 && j+1 == points.size()-1 && closed)
+            {
                 /*We got closed contour.*/
                 ekvPoints.append(points.at(i));
-            } else {
+            }
+            else
+            {
                 /*We found loop.*/
                 ekvPoints.append(points.at(i));
                 ekvPoints.append(crosPoint);
                 ekvPoints.append(points.at(j+1));
                 i = j + 2;
             }
-        } else {
+        }
+        else
+        {
             /*We did not found loop.*/
             ekvPoints.append(points.at(i));
         }
@@ -398,57 +487,67 @@ QVector<QPointF> VContainer::CheckLoops(const QVector<QPointF> &points) const{
     return ekvPoints;
 }
 
-void VContainer::PrepareDetails(QVector<VItem *> &list) const{
+void VContainer::PrepareDetails(QVector<VItem *> &list) const
+{
     QHashIterator<qint64, VDetail> iDetail(details);
-    while (iDetail.hasNext()) {
+    while (iDetail.hasNext())
+    {
         iDetail.next();
         list.append(new VItem(ContourPath(iDetail.key()), list.size()));
     }
 }
 
 template <typename val>
-void VContainer::UpdateObject(QHash<qint64, val> &obj, const qint64 &id, const val& point){
+void VContainer::UpdateObject(QHash<qint64, val> &obj, const qint64 &id, const val& point)
+{
     Q_ASSERT_X(id > 0, Q_FUNC_INFO, "id <= 0");
     obj[id] = point;
     UpdateId(id);
 }
 
-void VContainer::AddLengthSpline(const QString &name, const qreal &value){
-    Q_ASSERT(!name.isEmpty());
+void VContainer::AddLengthSpline(const QString &name, const qreal &value)
+{
+    Q_ASSERT(name.isEmpty() == false);
     lengthSplines[name] = value;
 }
 
-void VContainer::AddLengthArc(const qint64 &center, const qint64 &id){
+void VContainer::AddLengthArc(const qint64 &center, const qint64 &id)
+{
     AddLengthArc(GetNameArc(center, id), toMM(GetArc(id).GetLength()));
 }
 
-void VContainer::AddLengthArc(const QString &name, const qreal &value){
-    Q_ASSERT(!name.isEmpty());
+void VContainer::AddLengthArc(const QString &name, const qreal &value)
+{
+    Q_ASSERT(name.isEmpty() == false);
     lengthArcs[name] = value;
 }
 
-void VContainer::AddLineAngle(const QString &name, const qreal &value){
-    Q_ASSERT(!name.isEmpty());
+void VContainer::AddLineAngle(const QString &name, const qreal &value)
+{
+    Q_ASSERT(name.isEmpty() == false);
     lineAngles[name] = value;
 }
 
-qreal VContainer::GetValueStandartTableCell(const QString& name) const{
+qreal VContainer::GetValueStandartTableCell(const QString& name) const
+{
     VStandartTableCell cell =  GetStandartTableCell(name);
-    qreal k_size 	= ( static_cast<qreal> (size()/10.0) - 50.0 ) / 2.0;
+    qreal k_size    = ( static_cast<qreal> (size()/10.0) - 50.0 ) / 2.0;
     qreal k_growth  = ( static_cast<qreal> (growth()/10.0) - 176.0 ) / 6.0;
-    qreal value = cell.GetBase() + k_size*cell.GetKsize() 	+ k_growth*cell.GetKgrowth();
+    qreal value = cell.GetBase() + k_size*cell.GetKsize() + k_growth*cell.GetKgrowth();
     return value;
 }
 
-qreal VContainer::GetValueIncrementTableRow(const QString& name) const{
+qreal VContainer::GetValueIncrementTableRow(const QString& name) const
+{
     VIncrementTableRow cell =  GetIncrementTableRow(name);
-    qreal k_size 	= ( static_cast<qreal> (size()/10.0) - 50.0 ) / 2.0;
+    qreal k_size    = ( static_cast<qreal> (size()/10.0) - 50.0 ) / 2.0;
     qreal k_growth  = ( static_cast<qreal> (growth()/10.0) - 176.0 ) / 6.0;
     qreal value = cell.getBase() + k_size*cell.getKsize() + k_growth*cell.getKgrowth();
     return value;
 }
 
-void VContainer::Clear(){
+void VContainer::Clear()
+{
     _id = 0;
     standartTable.clear();
     incrementTable.clear();
@@ -464,40 +563,49 @@ void VContainer::Clear(){
     CreateManTableIGroup ();
 }
 
-void VContainer::ClearObject(){
+void VContainer::ClearObject()
+{
     points.clear();
     splines.clear();
     arcs.clear();
     splinePaths.clear();
 }
 
-qreal VContainer::FindVar(const QString &name, bool *ok)const{
-    if(base.contains(name)){
+qreal VContainer::FindVar(const QString &name, bool *ok)const
+{
+    if (base.contains(name))
+    {
         *ok = true;
         return base.value(name);
     }
 
-    if(standartTable.contains(name)){
+    if (standartTable.contains(name))
+    {
         *ok = true;
         return GetValueStandartTableCell(name);
     }
-    if(incrementTable.contains(name)){
+    if (incrementTable.contains(name))
+    {
         *ok = true;
         return GetValueIncrementTableRow(name);
     }
-    if(lengthLines.contains(name)){
+    if (lengthLines.contains(name))
+    {
         *ok = true;
         return lengthLines.value(name);
     }
-    if(lengthArcs.contains(name)){
+    if (lengthArcs.contains(name))
+    {
         *ok = true;
         return lengthArcs.value(name);
     }
-    if(lineAngles.contains(name)){
+    if (lineAngles.contains(name))
+    {
         *ok = true;
         return lineAngles.value(name);
     }
-    if(lengthSplines.contains(name)){
+    if (lengthSplines.contains(name))
+    {
         *ok = true;
         return lengthSplines.value(name);
     }
@@ -505,14 +613,18 @@ qreal VContainer::FindVar(const QString &name, bool *ok)const{
     return 0;
 }
 
-void VContainer::AddLine(const qint64 &firstPointId, const qint64 &secondPointId, Draw::Draws mode){
+void VContainer::AddLine(const qint64 &firstPointId, const qint64 &secondPointId, Draw::Draws mode)
+{
     QString nameLine = GetNameLine(firstPointId, secondPointId, mode);
     VPointF first;
     VPointF second;
-    if(mode == Draw::Calculation){
+    if (mode == Draw::Calculation)
+    {
         first = GetPoint(firstPointId);
         second = GetPoint(secondPointId);
-    } else {
+    }
+    else
+    {
         first = GetModelingPoint(firstPointId);
         second = GetModelingPoint(secondPointId);
     }
@@ -521,91 +633,114 @@ void VContainer::AddLine(const qint64 &firstPointId, const qint64 &secondPointId
     AddLineAngle(nameLine, QLineF(first.toQPointF(), second.toQPointF()).angle());
 }
 
-qint64 VContainer::AddSpline(const VSpline &spl){
+qint64 VContainer::AddSpline(const VSpline &spl)
+{
     return AddObject(splines, spl);
 }
 
-qint64 VContainer::AddModelingSpline(const VSpline &spl){
+qint64 VContainer::AddModelingSpline(const VSpline &spl)
+{
     return AddObject(modelingSplines, spl);
 }
 
-qint64 VContainer::AddSplinePath(const VSplinePath &splPath){
+qint64 VContainer::AddSplinePath(const VSplinePath &splPath)
+{
     return AddObject(splinePaths, splPath);
 }
 
-qint64 VContainer::AddModelingSplinePath(const VSplinePath &splPath){
+qint64 VContainer::AddModelingSplinePath(const VSplinePath &splPath)
+{
     return AddObject(modelingSplinePaths, splPath);
 }
 
-qint64 VContainer::AddArc(const VArc &arc){
+qint64 VContainer::AddArc(const VArc &arc)
+{
     return AddObject(arcs, arc);
 }
 
-qint64 VContainer::AddModelingArc(const VArc &arc){
+qint64 VContainer::AddModelingArc(const VArc &arc)
+{
     return AddObject(modelingArcs, arc);
 }
 
 template <typename key, typename val>
-qint64 VContainer::AddObject(QHash<key, val> &obj, const val& value){
+qint64 VContainer::AddObject(QHash<key, val> &obj, const val& value)
+{
     qint64 id = getNextId();
     obj[id] = value;
     return id;
 }
 
-QString VContainer::GetNameLine(const qint64 &firstPoint, const qint64 &secondPoint, Draw::Draws mode) const{
+QString VContainer::GetNameLine(const qint64 &firstPoint, const qint64 &secondPoint, Draw::Draws mode) const
+{
     VPointF first;
     VPointF second;
-    if(mode == Draw::Calculation){
+    if (mode == Draw::Calculation)
+    {
         first = GetPoint(firstPoint);
         second = GetPoint(secondPoint);
-    } else {
+    }
+    else
+    {
         first = GetModelingPoint(firstPoint);
         second = GetModelingPoint(secondPoint);
     }
     return QString("Line_%1_%2").arg(first.name(), second.name());
 }
 
-QString VContainer::GetNameLineAngle(const qint64 &firstPoint, const qint64 &secondPoint,
-                                     Draw::Draws mode) const{
+QString VContainer::GetNameLineAngle(const qint64 &firstPoint, const qint64 &secondPoint, Draw::Draws mode) const
+{
     VPointF first;
     VPointF second;
-    if(mode == Draw::Calculation){
+    if (mode == Draw::Calculation)
+    {
         first = GetPoint(firstPoint);
         second = GetPoint(secondPoint);
-    } else {
+    }
+    else
+    {
         first = GetModelingPoint(firstPoint);
         second = GetModelingPoint(secondPoint);
     }
     return QString("AngleLine_%1_%2").arg(first.name(), second.name());
 }
 
-QString VContainer::GetNameSpline(const qint64 &firstPoint, const qint64 &secondPoint,
-                                  Draw::Draws mode) const{
+QString VContainer::GetNameSpline(const qint64 &firstPoint, const qint64 &secondPoint, Draw::Draws mode) const
+{
     VPointF first;
     VPointF second;
-    if(mode == Draw::Calculation){
+    if (mode == Draw::Calculation)
+    {
         first = GetPoint(firstPoint);
         second = GetPoint(secondPoint);
-    } else {
+    }
+    else
+    {
         first = GetModelingPoint(firstPoint);
         second = GetModelingPoint(secondPoint);
     }
     return QString("Spl_%1_%2").arg(first.name(), second.name());
 }
 
-QString VContainer::GetNameSplinePath(const VSplinePath &path, Draw::Draws mode) const{
-    if(path.Count() == 0){
+QString VContainer::GetNameSplinePath(const VSplinePath &path, Draw::Draws mode) const
+{
+    if (path.Count() == 0)
+    {
         return QString();
     }
     QString name("SplPath");
-    for(qint32 i = 1; i <= path.Count(); ++i){
+    for (qint32 i = 1; i <= path.Count(); ++i)
+    {
         VSpline spl = path.GetSpline(i);
         VPointF first;
         VPointF second;
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             first = GetPoint(spl.GetP1());
             second = GetPoint(spl.GetP4());
-        } else {
+        }
+        else
+        {
             first = GetModelingPoint(spl.GetP1());
             second = GetModelingPoint(spl.GetP4());
         }
@@ -615,58 +750,73 @@ QString VContainer::GetNameSplinePath(const VSplinePath &path, Draw::Draws mode)
     return name;
 }
 
-QString VContainer::GetNameArc(const qint64 &center, const qint64 &id, Draw::Draws mode) const{
+QString VContainer::GetNameArc(const qint64 &center, const qint64 &id, Draw::Draws mode) const
+{
     VPointF centerPoint;
-    if(mode == Draw::Calculation){
+    if (mode == Draw::Calculation)
+    {
         centerPoint = GetPoint(center);
-    } else {
+    }
+    else
+    {
         centerPoint = GetModelingPoint(center);
     }
     return QString ("Arc_%1_%2").arg(centerPoint.name()).arg(id);
 }
 
-void VContainer::UpdatePoint(qint64 id, const VPointF &point){
+void VContainer::UpdatePoint(qint64 id, const VPointF &point)
+{
     UpdateObject(points, id, point);
 }
 
-void VContainer::UpdateModelingPoint(qint64 id, const VPointF &point){
+void VContainer::UpdateModelingPoint(qint64 id, const VPointF &point)
+{
     UpdateObject(modelingPoints, id, point);
 }
 
-void VContainer::UpdateDetail(qint64 id, const VDetail &detail){
+void VContainer::UpdateDetail(qint64 id, const VDetail &detail)
+{
     UpdateObject(details, id, detail);
 }
 
-void VContainer::UpdateSpline(qint64 id, const VSpline &spl){
+void VContainer::UpdateSpline(qint64 id, const VSpline &spl)
+{
     UpdateObject(splines, id, spl);
 }
 
-void VContainer::UpdateModelingSpline(qint64 id, const VSpline &spl){
+void VContainer::UpdateModelingSpline(qint64 id, const VSpline &spl)
+{
     UpdateObject(modelingSplines, id, spl);
 }
 
-void VContainer::UpdateSplinePath(qint64 id, const VSplinePath &splPath){
+void VContainer::UpdateSplinePath(qint64 id, const VSplinePath &splPath)
+{
     UpdateObject(splinePaths, id, splPath);
 }
 
-void VContainer::UpdateModelingSplinePath(qint64 id, const VSplinePath &splPath){
+void VContainer::UpdateModelingSplinePath(qint64 id, const VSplinePath &splPath)
+{
     UpdateObject(modelingSplinePaths, id, splPath);
 }
 
-void VContainer::UpdateArc(qint64 id, const VArc &arc){
+void VContainer::UpdateArc(qint64 id, const VArc &arc)
+{
     UpdateObject(arcs, id, arc);
 }
 
-void VContainer::UpdateModelingArc(qint64 id, const VArc &arc){
+void VContainer::UpdateModelingArc(qint64 id, const VArc &arc)
+{
     UpdateObject(modelingArcs, id, arc);
 }
 
-void VContainer::AddLengthLine(const QString &name, const qreal &value){
-    Q_ASSERT(!name.isEmpty());
+void VContainer::AddLengthLine(const QString &name, const qreal &value)
+{
+    Q_ASSERT(name.isEmpty() == false);
     lengthLines[name] = value;
 }
 
-void VContainer::CreateManTableIGroup (){
+void VContainer::CreateManTableIGroup ()
+{
     AddStandartTableCell("Pkor", VStandartTableCell(84, 0, 3));
     AddStandartTableCell("Pkor", VStandartTableCell(84, 0, 3));
     AddStandartTableCell("Vtos", VStandartTableCell(1450, 2, 51));
@@ -679,7 +829,7 @@ void VContainer::CreateManTableIGroup (){
     AddStandartTableCell("Vzy", VStandartTableCell(1328, 0, 49));
     AddStandartTableCell("Vlop", VStandartTableCell(1320, 0, 49));
     AddStandartTableCell("Vps", VStandartTableCell(811, -1, 36));
-    AddStandartTableCell("Ssh", VStandartTableCell(202,4, 1));
+    AddStandartTableCell("Ssh", VStandartTableCell(202, 4, 1));
     AddStandartTableCell("SgI", VStandartTableCell(517, 18, 2));
     AddStandartTableCell("SgII", VStandartTableCell(522, 19, 1));
     AddStandartTableCell("SgIII", VStandartTableCell(500, 20, 0));
@@ -723,20 +873,24 @@ void VContainer::CreateManTableIGroup (){
     AddStandartTableCell("Sb", VStandartTableCell(504, 15, 4));
 }
 
-QVector<QPointF> VContainer::GetReversePoint(const QVector<QPointF> &points) const{
+QVector<QPointF> VContainer::GetReversePoint(const QVector<QPointF> &points) const
+{
     Q_ASSERT(points.size() > 0);
     QVector<QPointF> reversePoints;
-    for (qint32 i = points.size() - 1; i >= 0; --i) {
+    for (qint32 i = points.size() - 1; i >= 0; --i)
+    {
         reversePoints.append(points.at(i));
     }
     return reversePoints;
 }
 
-qreal VContainer::GetLengthContour(const QVector<QPointF> &contour, const QVector<QPointF> &newPoints) const{
+qreal VContainer::GetLengthContour(const QVector<QPointF> &contour, const QVector<QPointF> &newPoints) const
+{
     qreal length = 0;
     QVector<QPointF> points;
     points << contour << newPoints;
-    for (qint32 i = 0; i < points.size()-1; ++i) {
+    for (qint32 i = 0; i < points.size()-1; ++i)
+    {
         QLineF line(points.at(i), points.at(i+1));
         length += line.length();
     }
diff --git a/container/vcontainer.h b/container/vcontainer.h
index 94c02498e..5937bb03e 100644
--- a/container/vcontainer.h
+++ b/container/vcontainer.h
@@ -32,7 +32,8 @@
 /**
  * @brief The VContainer class
  */
-class VContainer{
+class VContainer
+{
     Q_DECLARE_TR_FUNCTIONS(VContainer)
 public:
     /**
@@ -168,7 +169,7 @@ private:
     void               CreateManTableIGroup ();
     QVector<QPointF>   GetReversePoint(const QVector<QPointF> &points)const;
     qreal              GetLengthContour(const QVector<QPointF> &contour, const QVector<QPointF> &newPoints)const;
-    template <typename key, typename val> static val GetObject(const QHash<key,val> &obj, key id);
+    template <typename key, typename val> static val GetObject(const QHash<key, val> &obj, key id);
     template <typename val> static void UpdateObject(QHash<qint64, val> &obj, const qint64 &id, const val& point);
     template <typename key, typename val> static qint64 AddObject(QHash<key, val> &obj, const val& value);
 };
diff --git a/container/vincrementtablerow.cpp b/container/vincrementtablerow.cpp
index e6e3670a4..e7adbca73 100644
--- a/container/vincrementtablerow.cpp
+++ b/container/vincrementtablerow.cpp
@@ -21,12 +21,8 @@
 
 #include "vincrementtablerow.h"
 
-VIncrementTableRow::VIncrementTableRow():id(0), base(0), ksize(0), kgrowth(0), description(QString()){
-}
-
-VIncrementTableRow::VIncrementTableRow(qint64 id, qreal base, qreal ksize, qreal kgrowth,
-                                         QString description):id(id), base(base), ksize(ksize),
-    kgrowth(kgrowth), description(description){
-}
-
+VIncrementTableRow::VIncrementTableRow()
+    :id(0), base(0), ksize(0), kgrowth(0), description(QString()){}
 
+VIncrementTableRow::VIncrementTableRow(qint64 id, qreal base, qreal ksize, qreal kgrowth, QString description)
+    :id(id), base(base), ksize(ksize), kgrowth(kgrowth), description(description){}
diff --git a/container/vincrementtablerow.h b/container/vincrementtablerow.h
index f04abd8bf..c3d82b6d4 100644
--- a/container/vincrementtablerow.h
+++ b/container/vincrementtablerow.h
@@ -22,7 +22,8 @@
 #ifndef VINCREMENTTABLEROW_H
 #define VINCREMENTTABLEROW_H
 
-class VIncrementTableRow{
+class VIncrementTableRow
+{
 public:
                    VIncrementTableRow();
                    VIncrementTableRow(qint64 id, qreal base, qreal ksize, qreal kgrowth,
diff --git a/container/vpointf.cpp b/container/vpointf.cpp
index 14f5aa2d6..bb5a2a8ad 100644
--- a/container/vpointf.cpp
+++ b/container/vpointf.cpp
@@ -21,7 +21,8 @@
 
 #include "vpointf.h"
 
-VPointF &VPointF::operator =(const VPointF &point){
+VPointF &VPointF::operator =(const VPointF &point)
+{
     _name = point.name();
     _mx = point.mx();
     _my = point.my();
diff --git a/container/vpointf.h b/container/vpointf.h
index d51c13789..2a71599d0 100644
--- a/container/vpointf.h
+++ b/container/vpointf.h
@@ -22,7 +22,8 @@
 #ifndef VPOINTF_H
 #define VPOINTF_H
 
-class VPointF{
+class VPointF
+{
 public:
     inline             VPointF ()
                        :_name(QString()), _mx(0), _my(0), _x(0), _y(0), mode(Draw::Calculation), idObject(0){}
diff --git a/container/vstandarttablecell.cpp b/container/vstandarttablecell.cpp
index 1eb2ff2f9..4f08ae346 100644
--- a/container/vstandarttablecell.cpp
+++ b/container/vstandarttablecell.cpp
@@ -21,9 +21,8 @@
 
 #include "vstandarttablecell.h"
 
-VStandartTableCell::VStandartTableCell():base(0), ksize(0), kgrowth(0), description(QString()){
-}
+VStandartTableCell::VStandartTableCell()
+    :base(0), ksize(0), kgrowth(0), description(QString()){}
 
-VStandartTableCell::VStandartTableCell(qint32 base, qreal ksize, qreal kgrowth, QString description):base(base),
-    ksize(ksize), kgrowth(kgrowth), description(description){
-}
+VStandartTableCell::VStandartTableCell(qint32 base, qreal ksize, qreal kgrowth, QString description)
+    :base(base), ksize(ksize), kgrowth(kgrowth), description(description){}
diff --git a/container/vstandarttablecell.h b/container/vstandarttablecell.h
index d74f683ad..e5247f7a2 100644
--- a/container/vstandarttablecell.h
+++ b/container/vstandarttablecell.h
@@ -22,7 +22,8 @@
 #ifndef VSTANDARTTABLECELL_H
 #define VSTANDARTTABLECELL_H
 
-class VStandartTableCell{
+class VStandartTableCell
+{
 public:
                    VStandartTableCell();
                    VStandartTableCell(qint32 base, qreal ksize, qreal kgrowth, QString description = QString());
diff --git a/dialogs/dialogalongline.cpp b/dialogs/dialogalongline.cpp
index 969107db7..00846dfa9 100644
--- a/dialogs/dialogalongline.cpp
+++ b/dialogs/dialogalongline.cpp
@@ -22,9 +22,10 @@
 #include "dialogalongline.h"
 #include "ui_dialogalongline.h"
 
-DialogAlongLine::DialogAlongLine(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(new Ui::DialogAlongLine), number(0), pointName(QString()),
-    typeLine(QString()), formula(QString()), firstPointId(0), secondPointId(0){
+DialogAlongLine::DialogAlongLine(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(new Ui::DialogAlongLine), number(0), pointName(QString()),
+    typeLine(QString()), formula(QString()), firstPointId(0), secondPointId(0)
+{
     ui->setupUi(this);
     listWidget = ui->listWidget;
     labelResultCalculation = ui->labelResultCalculation;
@@ -66,53 +67,69 @@ DialogAlongLine::DialogAlongLine(const VContainer *data, Draw::Draws mode, QWidg
     connect(ui->lineEditFormula, &QLineEdit::textChanged, this, &DialogAlongLine::FormulaChanged);
 }
 
-DialogAlongLine::~DialogAlongLine(){
+DialogAlongLine::~DialogAlongLine()
+{
     delete ui;
 }
 
-void DialogAlongLine::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogAlongLine::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id) == false)
+        {
             return;
         }
     }
-    if(type == Scene::Point){
+    if (type == Scene::Point)
+    {
         VPointF point;
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             point = data->GetPoint(id);
-        } else {
+        }
+        else
+        {
             point = data->GetModelingPoint(id);
         }
-        if(number == 0){
+        if (number == 0)
+        {
             qint32 index = ui->comboBoxFirstPoint->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxFirstPoint->setCurrentIndex(index);
                 number++;
                 emit ToolTip(tr("Select second point of line"));
                 return;
             }
         }
-        if(number == 1){
+        if (number == 1)
+        {
             qint32 index = ui->comboBoxSecondPoint->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxSecondPoint->setCurrentIndex(index);
                 number = 0;
                 emit ToolTip("");
             }
-            if(!isInitialized){
+            if (isInitialized == false)
+            {
                 this->show();
             }
         }
     }
 }
 
-void DialogAlongLine::DialogAccepted(){
+void DialogAlongLine::DialogAccepted()
+{
     pointName = ui->lineEditNamePoint->text();
     typeLine = GetTypeLine(ui->comboBoxLineType);
     formula = ui->lineEditFormula->text();
@@ -121,25 +138,30 @@ void DialogAlongLine::DialogAccepted(){
     emit DialogClosed(QDialog::Accepted);
 }
 
-void DialogAlongLine::setSecondPointId(const qint64 &value, const qint64 &id){
+void DialogAlongLine::setSecondPointId(const qint64 &value, const qint64 &id)
+{
     setCurrentPointId(ui->comboBoxSecondPoint, secondPointId, value, id);
 }
 
-void DialogAlongLine::setFirstPointId(const qint64 &value, const qint64 &id){
+void DialogAlongLine::setFirstPointId(const qint64 &value, const qint64 &id)
+{
     setCurrentPointId(ui->comboBoxFirstPoint, firstPointId, value, id);
 }
 
-void DialogAlongLine::setFormula(const QString &value){
+void DialogAlongLine::setFormula(const QString &value)
+{
     formula = value;
     ui->lineEditFormula->setText(formula);
 }
 
-void DialogAlongLine::setTypeLine(const QString &value){
+void DialogAlongLine::setTypeLine(const QString &value)
+{
     typeLine = value;
     SetupTypeLine(ui->comboBoxLineType, value);
 }
 
-void DialogAlongLine::setPointName(const QString &value){
+void DialogAlongLine::setPointName(const QString &value)
+{
     pointName = value;
     ui->lineEditNamePoint->setText(pointName);
 }
diff --git a/dialogs/dialogalongline.h b/dialogs/dialogalongline.h
index 4b13fb25d..bda9b31f3 100644
--- a/dialogs/dialogalongline.h
+++ b/dialogs/dialogalongline.h
@@ -24,12 +24,14 @@
 
 #include "dialogtool.h"
 
-namespace Ui {
-class DialogAlongLine;
+namespace Ui
+{
+    class DialogAlongLine;
 }
 
-class DialogAlongLine : public DialogTool{
-    Q_OBJECT    
+class DialogAlongLine : public DialogTool
+{
+    Q_OBJECT
 public:
                         DialogAlongLine(const VContainer *data, Draw::Draws mode = Draw::Calculation,
                                         QWidget *parent = 0);
@@ -46,7 +48,7 @@ public:
     void                setSecondPointId(const qint64 &value, const qint64 &id);
 public slots:
     virtual void        ChoosedObject(qint64 id, Scene::Scenes type);
-    virtual void        DialogAccepted();   
+    virtual void        DialogAccepted();
 private:
     Q_DISABLE_COPY(DialogAlongLine)
     Ui::DialogAlongLine *ui;
diff --git a/dialogs/dialogarc.cpp b/dialogs/dialogarc.cpp
index dbd6eff99..16989d44e 100644
--- a/dialogs/dialogarc.cpp
+++ b/dialogs/dialogarc.cpp
@@ -22,9 +22,10 @@
 #include "dialogarc.h"
 #include "ui_dialogarc.h"
 
-DialogArc::DialogArc(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(new Ui::DialogArc), flagRadius(false), flagF1(false), flagF2(false),
-    timerRadius(0), timerF1(0), timerF2(0), center(0), radius(QString()), f1(QString()), f2(QString()){
+DialogArc::DialogArc(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(new Ui::DialogArc), flagRadius(false), flagF1(false), flagF2(false),
+    timerRadius(0), timerF1(0), timerF2(0), center(0), radius(QString()), f1(QString()), f2(QString())
+{
     ui->setupUi(this);
 
     timerRadius = new QTimer(this);
@@ -77,47 +78,61 @@ DialogArc::DialogArc(const VContainer *data, Draw::Draws mode, QWidget *parent)
     connect(ui->lineEditF2, &QLineEdit::textChanged, this, &DialogArc::F2Changed);
 }
 
-DialogArc::~DialogArc(){
+DialogArc::~DialogArc()
+{
     delete ui;
 }
 
-void DialogArc::SetCenter(const qint64 &value){
+void DialogArc::SetCenter(const qint64 &value)
+{
     center = value;
     ChangeCurrentData(ui->comboBoxBasePoint, center);
 }
 
-void DialogArc::SetF2(const QString &value){
+void DialogArc::SetF2(const QString &value)
+{
     f2 = value;
     ui->lineEditF2->setText(f2);
 }
 
-void DialogArc::SetF1(const QString &value){
+void DialogArc::SetF1(const QString &value)
+{
     f1 = value;
     ui->lineEditF1->setText(f1);
 }
 
-void DialogArc::SetRadius(const QString &value){
+void DialogArc::SetRadius(const QString &value)
+{
     radius = value;
     ui->lineEditRadius->setText(radius);
 }
 
-void DialogArc::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogArc::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id)==false)
+        {
             return;
         }
     }
-    if(type == Scene::Point){
+    if (type == Scene::Point)
+    {
         VPointF point;
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             point = data->GetPoint(id);
-        } else {
+        }
+        else
+        {
             point = data->GetModelingPoint(id);
         }
         ChangeCurrentText(ui->comboBoxBasePoint, point.name());
@@ -126,7 +141,8 @@ void DialogArc::ChoosedObject(qint64 id, Scene::Scenes type){
     }
 }
 
-void DialogArc::DialogAccepted(){
+void DialogArc::DialogAccepted()
+{
     radius = ui->lineEditRadius->text();
     f1 = ui->lineEditF1->text();
     f2 = ui->lineEditF2->text();
@@ -134,12 +150,15 @@ void DialogArc::DialogAccepted(){
     emit DialogClosed(QDialog::Accepted);
 }
 
-void DialogArc::ValChenged(int row){
-    if(ui->listWidget->count() == 0){
+void DialogArc::ValChenged(int row)
+{
+    if (ui->listWidget->count() == 0)
+    {
         return;
     }
     QListWidgetItem *item = ui->listWidget->item( row );
-    if(ui->radioButtonLineAngles->isChecked()){
+    if (ui->radioButtonLineAngles->isChecked())
+    {
         QString desc = QString("%1(%2) - %3").arg(item->text()).arg(data->GetLineAngle(item->text()))
                 .arg(tr("Value angle of line."));
         ui->labelDescription->setText(desc);
@@ -148,65 +167,78 @@ void DialogArc::ValChenged(int row){
     DialogTool::ValChenged(row);
 }
 
-void DialogArc::PutRadius(){
+void DialogArc::PutRadius()
+{
     PutValHere(ui->lineEditRadius, ui->listWidget);
 }
 
-void DialogArc::PutF1(){
+void DialogArc::PutF1()
+{
     PutValHere(ui->lineEditF1, ui->listWidget);
 }
 
-void DialogArc::PutF2(){
+void DialogArc::PutF2()
+{
     PutValHere(ui->lineEditF2, ui->listWidget);
 }
 
-void DialogArc::LineAngles(){
+void DialogArc::LineAngles()
+{
     ShowLineAngles();
 }
 
-void DialogArc::RadiusChanged(){
+void DialogArc::RadiusChanged()
+{
     labelEditFormula = ui->labelEditRadius;
     ValFormulaChanged(flagRadius, ui->lineEditRadius, timerRadius);
 }
 
-void DialogArc::F1Changed(){
+void DialogArc::F1Changed()
+{
     labelEditFormula = ui->labelEditF1;
     ValFormulaChanged(flagF1, ui->lineEditF1, timerF1);
 }
 
-void DialogArc::F2Changed(){
+void DialogArc::F2Changed()
+{
     labelEditFormula = ui->labelEditF2;
     ValFormulaChanged(flagF2, ui->lineEditF2, timerF2);
 }
 
-void DialogArc::CheckState(){
+void DialogArc::CheckState()
+{
     Q_ASSERT(bOk != 0);
     bOk->setEnabled(flagRadius && flagF1 && flagF2);
 }
 
-void DialogArc::EvalRadius(){
+void DialogArc::EvalRadius()
+{
     labelEditFormula = ui->labelEditRadius;
     Eval(ui->lineEditRadius, flagRadius, timerRadius, ui->labelResultRadius);
 }
 
-void DialogArc::EvalF1(){
+void DialogArc::EvalF1()
+{
     labelEditFormula = ui->labelEditF1;
     Eval(ui->lineEditF1, flagF1, timerF1, ui->labelResultF1);
 }
 
-void DialogArc::EvalF2(){
+void DialogArc::EvalF2()
+{
     labelEditFormula = ui->labelEditF2;
     Eval(ui->lineEditF2, flagF2, timerF2, ui->labelResultF2);
 }
 
-void DialogArc::ShowLineAngles(){
+void DialogArc::ShowLineAngles()
+{
     disconnect(ui->listWidget, &QListWidget::currentRowChanged, this, &DialogArc::ValChenged);
     ui->listWidget->clear();
     connect(ui->listWidget, &QListWidget::currentRowChanged, this, &DialogArc::ValChenged);
     const QHash<QString, qreal> *lineAnglesTable = data->DataLineAngles();
     Q_ASSERT(lineAnglesTable != 0);
     QHashIterator<QString, qreal> i(*lineAnglesTable);
-    while (i.hasNext()) {
+    while (i.hasNext())
+    {
         i.next();
         QListWidgetItem *item = new QListWidgetItem(i.key());
 
diff --git a/dialogs/dialogarc.h b/dialogs/dialogarc.h
index 302737d50..c701ba582 100644
--- a/dialogs/dialogarc.h
+++ b/dialogs/dialogarc.h
@@ -24,11 +24,13 @@
 
 #include "dialogtool.h"
 
-namespace Ui {
-class DialogArc;
+namespace Ui
+{
+    class DialogArc;
 }
 
-class DialogArc : public DialogTool{
+class DialogArc : public DialogTool
+{
     Q_OBJECT
 public:
                      DialogArc(const VContainer *data, Draw::Draws mode = Draw::Calculation, QWidget *parent = 0);
diff --git a/dialogs/dialogbisector.cpp b/dialogs/dialogbisector.cpp
index e975b8559..afd97c41c 100644
--- a/dialogs/dialogbisector.cpp
+++ b/dialogs/dialogbisector.cpp
@@ -22,9 +22,10 @@
 #include "dialogbisector.h"
 #include "ui_dialogbisector.h"
 
-DialogBisector::DialogBisector(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(new Ui::DialogBisector), number(0), pointName(QString()),
-    typeLine(QString()), formula(QString()), firstPointId(0), secondPointId(0), thirdPointId(0){
+DialogBisector::DialogBisector(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(new Ui::DialogBisector), number(0), pointName(QString()),
+    typeLine(QString()), formula(QString()), firstPointId(0), secondPointId(0), thirdPointId(0)
+{
     ui->setupUi(this);
     listWidget = ui->listWidget;
     labelResultCalculation = ui->labelResultCalculation;
@@ -66,89 +67,113 @@ DialogBisector::DialogBisector(const VContainer *data, Draw::Draws mode, QWidget
     connect(ui->lineEditFormula, &QLineEdit::textChanged, this, &DialogBisector::FormulaChanged);
 }
 
-DialogBisector::~DialogBisector(){
+DialogBisector::~DialogBisector()
+{
     delete ui;
 }
 
-void DialogBisector::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogBisector::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id) == false)
+        {
             return;
         }
     }
-    if(type == Scene::Point){
+    if (type == Scene::Point)
+    {
         VPointF point;
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             point = data->GetPoint(id);
-        } else {
+        }
+        else
+        {
             point = data->GetModelingPoint(id);
         }
-        if(number == 0){
+        if (number == 0)
+        {
             qint32 index = ui->comboBoxFirstPoint->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxFirstPoint->setCurrentIndex(index);
                 number++;
                 emit ToolTip(tr("Select second point of angle"));
                 return;
             }
         }
-        if(number == 1){
+        if (number == 1)
+        {
             qint32 index = ui->comboBoxSecondPoint->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxSecondPoint->setCurrentIndex(index);
                 number++;
                 emit ToolTip(tr("Select third point of angle"));
                 return;
             }
         }
-        if(number == 2){
+        if (number == 2)
+        {
             qint32 index = ui->comboBoxThirdPoint->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxThirdPoint->setCurrentIndex(index);
                 number = 0;
                 emit ToolTip("");
             }
-            if(!isInitialized){
+            if (isInitialized == false)
+            {
                 this->show();
             }
         }
     }
 }
 
-void DialogBisector::setPointName(const QString &value){
+void DialogBisector::setPointName(const QString &value)
+{
     pointName = value;
     ui->lineEditNamePoint->setText(pointName);
 }
 
-void DialogBisector::setTypeLine(const QString &value){
+void DialogBisector::setTypeLine(const QString &value)
+{
     typeLine = value;
     SetupTypeLine(ui->comboBoxLineType, value);
 }
 
-void DialogBisector::setFormula(const QString &value){
+void DialogBisector::setFormula(const QString &value)
+{
     formula = value;
     ui->lineEditFormula->setText(formula);
 }
 
-void DialogBisector::setFirstPointId(const qint64 &value, const qint64 &id){
+void DialogBisector::setFirstPointId(const qint64 &value, const qint64 &id)
+{
     setCurrentPointId(ui->comboBoxFirstPoint, firstPointId, value, id);
 }
 
-void DialogBisector::setSecondPointId(const qint64 &value, const qint64 &id){
+void DialogBisector::setSecondPointId(const qint64 &value, const qint64 &id)
+{
     setCurrentPointId(ui->comboBoxSecondPoint, secondPointId, value, id);
 }
 
-void DialogBisector::setThirdPointId(const qint64 &value, const qint64 &id){
+void DialogBisector::setThirdPointId(const qint64 &value, const qint64 &id)
+{
     setCurrentPointId(ui->comboBoxThirdPoint, thirdPointId, value, id);
 }
 
-void DialogBisector::DialogAccepted(){
+void DialogBisector::DialogAccepted()
+{
     pointName = ui->lineEditNamePoint->text();
     typeLine = GetTypeLine(ui->comboBoxLineType);
     formula = ui->lineEditFormula->text();
diff --git a/dialogs/dialogbisector.h b/dialogs/dialogbisector.h
index 87b409421..c9b0260dc 100644
--- a/dialogs/dialogbisector.h
+++ b/dialogs/dialogbisector.h
@@ -24,13 +24,14 @@
 
 #include "dialogtool.h"
 
-namespace Ui {
-class DialogBisector;
+namespace Ui
+{
+    class DialogBisector;
 }
 
-class DialogBisector : public DialogTool{
+class DialogBisector : public DialogTool
+{
     Q_OBJECT
-    
 public:
     explicit DialogBisector(const VContainer *data, Draw::Draws mode = Draw::Calculation,
                             QWidget *parent = 0);
diff --git a/dialogs/dialogdetail.cpp b/dialogs/dialogdetail.cpp
index fb66961c5..add670998 100644
--- a/dialogs/dialogdetail.cpp
+++ b/dialogs/dialogdetail.cpp
@@ -21,8 +21,9 @@
 
 #include "dialogdetail.h"
 
-DialogDetail::DialogDetail(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(), details(VDetail()), supplement(true), closed(true){
+DialogDetail::DialogDetail(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(), details(VDetail()), supplement(true), closed(true)
+{
     ui.setupUi(this);
     labelEditNamePoint = ui.labelEditNameDetail;
     bOk = ui.buttonBox->button(QDialogButtonBox::Ok);
@@ -42,43 +43,52 @@ DialogDetail::DialogDetail(const VContainer *data, Draw::Draws mode, QWidget *pa
     connect(ui.lineEditNameDetail, &QLineEdit::textChanged, this, &DialogDetail::NamePointChanged);
 }
 
-void DialogDetail::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogDetail::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id) == false)
+        {
             return;
         }
     }
-    if(type != Scene::Line && type != Scene::Detail){
-        switch(type){
-        case(Scene::Arc):
-            NewItem(id, Tool::NodeArc, mode, NodeDetail::Contour);
-            break;
-        case(Scene::Point):
-            NewItem(id, Tool::NodePoint, mode, NodeDetail::Contour);
-            break;
-        case(Scene::Spline):
-            NewItem(id, Tool::NodeSpline, mode, NodeDetail::Contour);
-            break;
-        case(Scene::SplinePath):
-            NewItem(id, Tool::NodeSplinePath, mode, NodeDetail::Contour);
-            break;
-        default:
-            qWarning()<<tr("Get wrong scene object. Ignore.");
-            break;
+    if (type != Scene::Line && type != Scene::Detail)
+    {
+        switch (type)
+        {
+            case (Scene::Arc):
+                NewItem(id, Tool::NodeArc, mode, NodeDetail::Contour);
+                break;
+            case (Scene::Point):
+                NewItem(id, Tool::NodePoint, mode, NodeDetail::Contour);
+                break;
+            case (Scene::Spline):
+                NewItem(id, Tool::NodeSpline, mode, NodeDetail::Contour);
+                break;
+            case (Scene::SplinePath):
+                NewItem(id, Tool::NodeSplinePath, mode, NodeDetail::Contour);
+                break;
+            default:
+                qWarning()<<tr("Get wrong scene object. Ignore.");
+                break;
         }
         this->show();
     }
 }
 
-void DialogDetail::DialogAccepted(){
+void DialogDetail::DialogAccepted()
+{
     details.Clear();
-    for(qint32 i = 0; i < ui.listWidget->count(); ++i){
+    for (qint32 i = 0; i < ui.listWidget->count(); ++i)
+    {
         QListWidgetItem *item = ui.listWidget->item(i);
         details.append( qvariant_cast<VNodeDetail>(item->data(Qt::UserRole)));
     }
@@ -90,53 +100,71 @@ void DialogDetail::DialogAccepted(){
     emit DialogClosed(QDialog::Accepted);
 }
 
-void DialogDetail::NewItem(qint64 id, Tool::Tools typeTool, Draw::Draws mode, NodeDetail::NodeDetails typeNode, qreal mx,
-                           qreal my){
+void DialogDetail::NewItem(qint64 id, Tool::Tools typeTool, Draw::Draws mode, NodeDetail::NodeDetails typeNode,
+                           qreal mx, qreal my)
+{
     QString name;
-    switch(typeTool){
-    case(Tool::NodePoint):{
-        VPointF point;
-        if(mode == Draw::Calculation){
-            point = data->GetPoint(id);
-        } else {
-            point = data->GetModelingPoint(id);
+    switch (typeTool)
+    {
+        case (Tool::NodePoint):
+        {
+            VPointF point;
+            if (mode == Draw::Calculation)
+            {
+                point = data->GetPoint(id);
+            }
+            else
+            {
+                point = data->GetModelingPoint(id);
+            }
+            name = point.name();
+            break;
         }
-        name = point.name();
-        break;
-    }
-    case(Tool::NodeArc):{
-        VArc arc;
-        if(mode == Draw::Calculation){
-            arc = data->GetArc(id);
-        } else {
-            arc = data->GetModelingArc(id);
+        case (Tool::NodeArc):
+        {
+            VArc arc;
+            if (mode == Draw::Calculation)
+            {
+                arc = data->GetArc(id);
+            }
+            else
+            {
+                arc = data->GetModelingArc(id);
+            }
+            name = data->GetNameArc(arc.GetCenter(), id, mode);
+            break;
         }
-        name = data->GetNameArc(arc.GetCenter(), id, mode);
-        break;
-    }
-    case(Tool::NodeSpline):{
-        VSpline spl;
-        if(mode == Draw::Calculation){
-            spl = data->GetSpline(id);
-        } else {
-            spl = data->GetModelingSpline(id);
+        case (Tool::NodeSpline):
+        {
+            VSpline spl;
+            if (mode == Draw::Calculation)
+            {
+                spl = data->GetSpline(id);
+            }
+            else
+            {
+                spl = data->GetModelingSpline(id);
+            }
+            name = spl.GetName();
+            break;
         }
-        name = spl.GetName();
-        break;
-    }
-    case(Tool::NodeSplinePath):{
-        VSplinePath splPath;
-        if(mode == Draw::Calculation){
-            splPath = data->GetSplinePath(id);
-        } else {
-            splPath = data->GetModelingSplinePath(id);
+        case (Tool::NodeSplinePath):
+        {
+            VSplinePath splPath;
+            if (mode == Draw::Calculation)
+            {
+                splPath = data->GetSplinePath(id);
+            }
+            else
+            {
+                splPath = data->GetModelingSplinePath(id);
+            }
+            name = data->GetNameSplinePath(splPath, mode);
+            break;
         }
-        name = data->GetNameSplinePath(splPath, mode);
-        break;
-    }
-    default:
-        qWarning()<<tr("Get wrong tools. Ignore.");
-        break;
+        default:
+            qWarning()<<tr("Get wrong tools. Ignore.");
+            break;
     }
 
     QListWidgetItem *item = new QListWidgetItem(name);
@@ -156,12 +184,14 @@ void DialogDetail::NewItem(qint64 id, Tool::Tools typeTool, Draw::Draws mode, No
             this, &DialogDetail::BiasYChanged);
 }
 
-void DialogDetail::setDetails(const VDetail &value){
+void DialogDetail::setDetails(const VDetail &value)
+{
     details = value;
     ui.listWidget->clear();
-    for(qint32 i = 0; i < details.CountNode(); ++i){
-        NewItem(details[i].getId(), details[i].getTypeTool(), details[i].getMode(), details[i].getTypeNode(), details[i].getMx(),
-                details[i].getMy());
+    for (qint32 i = 0; i < details.CountNode(); ++i)
+    {
+        NewItem(details[i].getId(), details[i].getTypeTool(), details[i].getMode(), details[i].getTypeNode(),
+                details[i].getMx(), details[i].getMy());
     }
     ui.lineEditNameDetail->setText(details.getName());
     ui.checkBoxSeams->setChecked(details.getSupplement());
@@ -171,7 +201,8 @@ void DialogDetail::setDetails(const VDetail &value){
     ui.listWidget->setFocus(Qt::OtherFocusReason);
 }
 
-void DialogDetail::BiasXChanged(qreal d){
+void DialogDetail::BiasXChanged(qreal d)
+{
     qint32 row = ui.listWidget->currentRow();
     QListWidgetItem *item = ui.listWidget->item( row );
     VNodeDetail node = qvariant_cast<VNodeDetail>(item->data(Qt::UserRole));
@@ -179,7 +210,8 @@ void DialogDetail::BiasXChanged(qreal d){
     item->setData(Qt::UserRole, QVariant::fromValue(node));
 }
 
-void DialogDetail::BiasYChanged(qreal d){
+void DialogDetail::BiasYChanged(qreal d)
+{
     qint32 row = ui.listWidget->currentRow();
     QListWidgetItem *item = ui.listWidget->item( row );
     VNodeDetail node = qvariant_cast<VNodeDetail>(item->data(Qt::UserRole));
@@ -187,18 +219,22 @@ void DialogDetail::BiasYChanged(qreal d){
     item->setData(Qt::UserRole, QVariant::fromValue(node));
 }
 
-void DialogDetail::ClickedSeams(bool checked){
+void DialogDetail::ClickedSeams(bool checked)
+{
     supplement = checked;
     ui.checkBoxClosed->setEnabled(checked);
     ui.doubleSpinBoxSeams->setEnabled(checked);
 }
 
-void DialogDetail::ClickedClosed(bool checked){
+void DialogDetail::ClickedClosed(bool checked)
+{
     closed = checked;
 }
 
-void DialogDetail::ObjectChanged(int row){
-    if(ui.listWidget->count() == 0){
+void DialogDetail::ObjectChanged(int row)
+{
+    if (ui.listWidget->count() == 0)
+    {
         return;
     }
     QListWidgetItem *item = ui.listWidget->item( row );
diff --git a/dialogs/dialogdetail.h b/dialogs/dialogdetail.h
index 43a518e90..8a6a12cdf 100644
--- a/dialogs/dialogdetail.h
+++ b/dialogs/dialogdetail.h
@@ -25,8 +25,9 @@
 #include "ui_dialogdetail.h"
 #include "dialogtool.h"
 
-class DialogDetail : public DialogTool{
-    Q_OBJECT  
+class DialogDetail : public DialogTool
+{
+    Q_OBJECT
 public:
                      DialogDetail(const VContainer *data, Draw::Draws mode, QWidget *parent = 0);
     inline VDetail   getDetails() const {return details;}
@@ -44,8 +45,8 @@ private:
     VDetail          details;
     bool             supplement;
     bool             closed;
-    void             NewItem(qint64 id, Tool::Tools typeTool, Draw::Draws mode, NodeDetail::NodeDetails typeNode, qreal mx = 0,
-                             qreal my = 0);
+    void             NewItem(qint64 id, Tool::Tools typeTool, Draw::Draws mode, NodeDetail::NodeDetails typeNode,
+                             qreal mx = 0, qreal my = 0);
 };
 
 #endif // DIALOGDETAIL_H
diff --git a/dialogs/dialogendline.cpp b/dialogs/dialogendline.cpp
index 011784d5c..9770166b0 100644
--- a/dialogs/dialogendline.cpp
+++ b/dialogs/dialogendline.cpp
@@ -22,9 +22,10 @@
 #include "dialogendline.h"
 #include "ui_dialogendline.h"
 
-DialogEndLine::DialogEndLine(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(new Ui::DialogEndLine), pointName(QString()), typeLine(QString()),
-    formula(QString()), angle(0), basePointId(0){
+DialogEndLine::DialogEndLine(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(new Ui::DialogEndLine), pointName(QString()), typeLine(QString()),
+    formula(QString()), angle(0), basePointId(0)
+{
     ui->setupUi(this);
     spinBoxAngle = ui->doubleSpinBoxAngle;
     listWidget = ui->listWidget;
@@ -81,23 +82,32 @@ DialogEndLine::DialogEndLine(const VContainer *data, Draw::Draws mode, QWidget *
     connect(ui->lineEditFormula, &QLineEdit::textChanged, this, &DialogEndLine::FormulaChanged);
 }
 
-void DialogEndLine::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogEndLine::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id) == false)
+        {
             return;
         }
     }
-    if(type == Scene::Point){
+    if (type == Scene::Point)
+    {
         VPointF point;
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             point = data->GetPoint(id);
-        } else {
+        }
+        else
+        {
             point = data->GetModelingPoint(id);
         }
         ChangeCurrentText(ui->comboBoxBasePoint, point.name());
@@ -106,31 +116,37 @@ void DialogEndLine::ChoosedObject(qint64 id, Scene::Scenes type){
     }
 }
 
-void DialogEndLine::setPointName(const QString &value){
+void DialogEndLine::setPointName(const QString &value)
+{
     pointName = value;
     ui->lineEditNamePoint->setText(pointName);
 }
 
-void DialogEndLine::setTypeLine(const QString &value){
+void DialogEndLine::setTypeLine(const QString &value)
+{
     typeLine = value;
     SetupTypeLine(ui->comboBoxLineType, value);
 }
 
-void DialogEndLine::setFormula(const QString &value){
+void DialogEndLine::setFormula(const QString &value)
+{
     formula = value;
     ui->lineEditFormula->setText(formula);
 }
 
-void DialogEndLine::setAngle(const qreal &value){
+void DialogEndLine::setAngle(const qreal &value)
+{
     angle = value;
     ui->doubleSpinBoxAngle->setValue(angle);
 }
 
-void DialogEndLine::setBasePointId(const qint64 &value, const qint64 &id){
+void DialogEndLine::setBasePointId(const qint64 &value, const qint64 &id)
+{
     setCurrentPointId(ui->comboBoxBasePoint, basePointId, value, id);
 }
 
-void DialogEndLine::DialogAccepted(){
+void DialogEndLine::DialogAccepted()
+{
     pointName = ui->lineEditNamePoint->text();
     typeLine = GetTypeLine(ui->comboBoxLineType);
     formula = ui->lineEditFormula->text();
@@ -139,6 +155,7 @@ void DialogEndLine::DialogAccepted(){
     emit DialogClosed(QDialog::Accepted);
 }
 
-DialogEndLine::~DialogEndLine(){
+DialogEndLine::~DialogEndLine()
+{
     delete ui;
 }
diff --git a/dialogs/dialogendline.h b/dialogs/dialogendline.h
index 4996f8fb8..489d264c4 100644
--- a/dialogs/dialogendline.h
+++ b/dialogs/dialogendline.h
@@ -24,15 +24,16 @@
 
 #include "dialogtool.h"
 
-namespace Ui {
-class DialogEndLine;
+namespace Ui
+{
+    class DialogEndLine;
 }
 
-class DialogEndLine : public DialogTool{
-    Q_OBJECT 
+class DialogEndLine : public DialogTool
+{
+    Q_OBJECT
 public:
-    explicit          DialogEndLine(const VContainer *data, Draw::Draws mode = Draw::Calculation,
-                                    QWidget *parent = 0);
+                      DialogEndLine(const VContainer *data, Draw::Draws mode = Draw::Calculation, QWidget *parent = 0);
                       ~DialogEndLine();
     inline QString    getPointName() const {return pointName;}
     void              setPointName(const QString &value);
diff --git a/dialogs/dialogheight.cpp b/dialogs/dialogheight.cpp
index 7024d94c1..4fdaa9761 100644
--- a/dialogs/dialogheight.cpp
+++ b/dialogs/dialogheight.cpp
@@ -1,9 +1,10 @@
 #include "dialogheight.h"
 #include "ui_dialogheight.h"
 
-DialogHeight::DialogHeight(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(new Ui::DialogHeight), number(0), pointName(QString()),
-    typeLine(QString()), basePointId(0), p1LineId(0), p2LineId(0){
+DialogHeight::DialogHeight(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(new Ui::DialogHeight), number(0), pointName(QString()),
+    typeLine(QString()), basePointId(0), p1LineId(0), p2LineId(0)
+{
     ui->setupUi(this);
     labelEditNamePoint = ui->labelEditNamePoint;
     bOk = ui->buttonBox->button(QDialogButtonBox::Ok);
@@ -19,78 +20,96 @@ DialogHeight::DialogHeight(const VContainer *data, Draw::Draws mode, QWidget *pa
     connect(ui->lineEditNamePoint, &QLineEdit::textChanged, this, &DialogHeight::NamePointChanged);
 }
 
-DialogHeight::~DialogHeight(){
+DialogHeight::~DialogHeight()
+{
     delete ui;
 }
 
-void DialogHeight::setPointName(const QString &value){
+void DialogHeight::setPointName(const QString &value)
+{
     pointName = value;
     ui->lineEditNamePoint->setText(pointName);
 }
 
-void DialogHeight::setTypeLine(const QString &value){
+void DialogHeight::setTypeLine(const QString &value)
+{
     typeLine = value;
     SetupTypeLine(ui->comboBoxLineType, value);
 }
 
-void DialogHeight::setBasePointId(const qint64 &value, const qint64 &id){
+void DialogHeight::setBasePointId(const qint64 &value, const qint64 &id)
+{
     basePointId = value;
     setCurrentPointId(ui->comboBoxBasePoint, basePointId, value, id);
 }
 
-void DialogHeight::setP1LineId(const qint64 &value, const qint64 &id){
+void DialogHeight::setP1LineId(const qint64 &value, const qint64 &id)
+{
     p1LineId = value;
     setCurrentPointId(ui->comboBoxP1Line, p1LineId, value, id);
 }
 
-void DialogHeight::setP2LineId(const qint64 &value, const qint64 &id){
+void DialogHeight::setP2LineId(const qint64 &value, const qint64 &id)
+{
     p2LineId = value;
     setCurrentPointId(ui->comboBoxP2Line, p2LineId, value, id);
 }
 
-void DialogHeight::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogHeight::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id) == false)
+        {
             return;
         }
     }
-    if(type == Scene::Point){
+    if (type == Scene::Point)
+    {
         VPointF point;
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             point = data->GetPoint(id);
-        } else {
+        }
+        else
+        {
             point = data->GetModelingPoint(id);
         }
-        switch(number){
-        case(0):
-            ChangeCurrentText(ui->comboBoxBasePoint, point.name());
-            number++;
-            emit ToolTip(tr("Select first point of line"));
-            break;
-        case(1):
-            ChangeCurrentText(ui->comboBoxP1Line, point.name());
-            number++;
-            emit ToolTip(tr("Select second point of line"));
-            break;
-        case(2):
-            ChangeCurrentText(ui->comboBoxP2Line, point.name());
-            number = 0;
-            emit ToolTip(tr(""));
-            if(!isInitialized){
-                this->show();
-            }
-            break;
+        switch (number)
+        {
+            case (0):
+                ChangeCurrentText(ui->comboBoxBasePoint, point.name());
+                number++;
+                emit ToolTip(tr("Select first point of line"));
+                break;
+            case (1):
+                ChangeCurrentText(ui->comboBoxP1Line, point.name());
+                number++;
+                emit ToolTip(tr("Select second point of line"));
+                break;
+            case (2):
+                ChangeCurrentText(ui->comboBoxP2Line, point.name());
+                number = 0;
+                emit ToolTip(tr(""));
+                if (isInitialized == false)
+                {
+                    this->show();
+                }
+                break;
         }
     }
 }
 
-void DialogHeight::DialogAccepted(){
+void DialogHeight::DialogAccepted()
+{
     pointName = ui->lineEditNamePoint->text();
     typeLine = GetTypeLine(ui->comboBoxLineType);
     basePointId = getCurrentPointId(ui->comboBoxBasePoint);
@@ -98,4 +117,3 @@ void DialogHeight::DialogAccepted(){
     p2LineId = getCurrentPointId(ui->comboBoxP2Line);
     emit DialogClosed(QDialog::Accepted);
 }
-
diff --git a/dialogs/dialogheight.h b/dialogs/dialogheight.h
index 933b2d786..e737ad5a3 100644
--- a/dialogs/dialogheight.h
+++ b/dialogs/dialogheight.h
@@ -24,14 +24,16 @@
 
 #include "dialogtool.h"
 
-namespace Ui {
-class DialogHeight;
+namespace Ui
+{
+    class DialogHeight;
 }
 
-class DialogHeight : public DialogTool{
+class DialogHeight : public DialogTool
+{
     Q_OBJECT
 public:
-    explicit         DialogHeight(const VContainer *data, Draw::Draws mode = Draw::Calculation,
+                     DialogHeight(const VContainer *data, Draw::Draws mode = Draw::Calculation,
                                   QWidget *parent = 0);
                      ~DialogHeight();
     inline QString   getPointName() const {return pointName;}
diff --git a/dialogs/dialoghistory.cpp b/dialogs/dialoghistory.cpp
index 80b71d293..8b175b3f5 100644
--- a/dialogs/dialoghistory.cpp
+++ b/dialogs/dialoghistory.cpp
@@ -26,9 +26,10 @@
 #include "geometry/vsplinepath.h"
 #include <QDebug>
 
-DialogHistory::DialogHistory(VContainer *data, VDomDocument *doc, QWidget *parent) :
-    DialogTool(data, Draw::Calculation, parent), ui(new Ui::DialogHistory), doc(doc), cursorRow(0),
-    cursorToolRecordRow(0){
+DialogHistory::DialogHistory(VContainer *data, VDomDocument *doc, QWidget *parent)
+    :DialogTool(data, Draw::Calculation, parent), ui(new Ui::DialogHistory), doc(doc), cursorRow(0),
+    cursorToolRecordRow(0)
+{
     ui->setupUi(this);
     bOk = ui->buttonBox->button(QDialogButtonBox::Ok);
     connect(bOk, &QPushButton::clicked, this, &DialogHistory::DialogAccepted);
@@ -42,19 +43,23 @@ DialogHistory::DialogHistory(VContainer *data, VDomDocument *doc, QWidget *paren
     ShowPoint();
 }
 
-DialogHistory::~DialogHistory(){
+DialogHistory::~DialogHistory()
+{
     delete ui;
 }
 
-void DialogHistory::DialogAccepted(){
+void DialogHistory::DialogAccepted()
+{
     QTableWidgetItem *item = ui->tableWidget->item(cursorToolRecordRow, 0);
     qint64 id = qvariant_cast<qint64>(item->data(Qt::UserRole));
     emit ShowHistoryTool(id, Qt::green, false);
     emit DialogClosed(QDialog::Accepted);
 }
 
-void DialogHistory::cellClicked(int row, int column){
-    if(column == 0){
+void DialogHistory::cellClicked(int row, int column)
+{
+    if (column == 0)
+    {
         QTableWidgetItem *item = ui->tableWidget->item(cursorRow, 0);
         item->setIcon(QIcon());
 
@@ -65,7 +70,9 @@ void DialogHistory::cellClicked(int row, int column){
         disconnect(doc, &VDomDocument::ChangedCursor, this, &DialogHistory::ChangedCursor);
         doc->setCursor(id);
         connect(doc, &VDomDocument::ChangedCursor, this, &DialogHistory::ChangedCursor);
-    } else {
+    }
+    else
+    {
         QTableWidgetItem *item = ui->tableWidget->item(cursorToolRecordRow, 0);
         qint64 id = qvariant_cast<qint64>(item->data(Qt::UserRole));
         emit ShowHistoryTool(id, Qt::green, false);
@@ -77,11 +84,14 @@ void DialogHistory::cellClicked(int row, int column){
     }
 }
 
-void DialogHistory::ChangedCursor(qint64 id){
-    for(qint32 i = 0; i< ui->tableWidget->rowCount(); ++i){
+void DialogHistory::ChangedCursor(qint64 id)
+{
+    for (qint32 i = 0; i< ui->tableWidget->rowCount(); ++i)
+    {
         QTableWidgetItem *item = ui->tableWidget->item(i, 0);
         qint64 rId = qvariant_cast<qint64>(item->data(Qt::UserRole));
-        if(rId == id){
+        if (rId == id)
+        {
             QTableWidgetItem *oldCursorItem = ui->tableWidget->item(cursorRow, 0);
             oldCursorItem->setIcon(QIcon());
             cursorRow = i;
@@ -90,20 +100,24 @@ void DialogHistory::ChangedCursor(qint64 id){
     }
 }
 
-void DialogHistory::UpdateHistory(){
+void DialogHistory::UpdateHistory()
+{
     FillTable();
     InitialTable();
 }
 
-void DialogHistory::FillTable(){
+void DialogHistory::FillTable()
+{
     ui->tableWidget->clear();
     QVector<VToolRecord> *history = doc->getHistory();
     qint32 currentRow = -1;
     qint32 count = 0;
     ui->tableWidget->setRowCount(history->size());
-    for(qint32 i = 0; i< history->size(); ++i){
+    for (qint32 i = 0; i< history->size(); ++i)
+    {
         VToolRecord tool = history->at(i);
-        if(tool.getNameDraw() != doc->GetNameActivDraw()){
+        if (tool.getNameDraw() != doc->GetNameActivDraw())
+        {
             continue;
         }
         currentRow++;
@@ -121,7 +135,8 @@ void DialogHistory::FillTable(){
         ++count;
     }
     ui->tableWidget->setRowCount(count);
-    if(history->size()>0){
+    if (history->size()>0)
+    {
         cursorRow = currentRow;
         QTableWidgetItem *item = ui->tableWidget->item(cursorRow, 0);
         item->setIcon(QIcon("://icon/32x32/put_after.png"));
@@ -131,7 +146,8 @@ void DialogHistory::FillTable(){
     ui->tableWidget->verticalHeader()->setDefaultSectionSize(20);
 }
 
-QString DialogHistory::Record(const VToolRecord &tool){
+QString DialogHistory::Record(const VToolRecord &tool)
+{
     QString record = QString();
     qint64 basePointId = 0;
     qint64 secondPointId = 0;
@@ -143,7 +159,8 @@ QString DialogHistory::Record(const VToolRecord &tool){
     qint64 p2Line2 = 0;
     qint64 center = 0;
     QDomElement domElement;
-    switch( tool.getTypeTool() ){
+    switch ( tool.getTypeTool() )
+    {
         case Tool::ArrowTool:
             break;
         case Tool::SinglePointTool:
@@ -151,7 +168,8 @@ QString DialogHistory::Record(const VToolRecord &tool){
             break;
         case Tool::EndLineTool:
             domElement = doc->elementById(QString().setNum(tool.getId()));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 basePointId = domElement.attribute("basePoint", "").toLongLong();
             }
             record = QString(tr("%1_%2 - Line from point %1 to point %2")).arg(data->GetPoint(basePointId).name(),
@@ -159,7 +177,8 @@ QString DialogHistory::Record(const VToolRecord &tool){
             break;
         case Tool::LineTool:
             domElement = doc->elementById(QString().setNum(tool.getId()));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 firstPointId = domElement.attribute("firstPoint", "").toLongLong();
                 secondPointId = domElement.attribute("secondPoint", "").toLongLong();
             }
@@ -168,7 +187,8 @@ QString DialogHistory::Record(const VToolRecord &tool){
             break;
         case Tool::AlongLineTool:
             domElement = doc->elementById(QString().setNum(tool.getId()));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 basePointId = domElement.attribute("firstPoint", "").toLongLong();
                 secondPointId = domElement.attribute("secondPoint", "").toLongLong();
             }
@@ -181,7 +201,8 @@ QString DialogHistory::Record(const VToolRecord &tool){
             break;
         case Tool::NormalTool:
             domElement = doc->elementById(QString().setNum(tool.getId()));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 basePointId = domElement.attribute("firstPoint", "").toLongLong();
                 secondPointId = domElement.attribute("secondPoint", "").toLongLong();
             }
@@ -191,7 +212,8 @@ QString DialogHistory::Record(const VToolRecord &tool){
             break;
         case Tool::BisectorTool:
             domElement = doc->elementById(QString().setNum(tool.getId()));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 firstPointId = domElement.attribute("firstPoint", "").toLongLong();
                 basePointId = domElement.attribute("secondPoint", "").toLongLong();
                 thirdPointId = domElement.attribute("thirdPoint", "").toLongLong();
@@ -203,7 +225,8 @@ QString DialogHistory::Record(const VToolRecord &tool){
             break;
         case Tool::LineIntersectTool:
             domElement = doc->elementById(QString().setNum(tool.getId()));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 p1Line1 = domElement.attribute("p1Line1", "").toLongLong();
                 p2Line1 = domElement.attribute("p2Line1", "").toLongLong();
                 p1Line2 = domElement.attribute("p1Line2", "").toLongLong();
@@ -213,69 +236,78 @@ QString DialogHistory::Record(const VToolRecord &tool){
                                                                                          data->GetPoint(p2Line1).name(),
                                                                                          data->GetPoint(p1Line2).name(),
                                                                                          data->GetPoint(p2Line2).name(),
-                                                                                         data->GetPoint(tool.getId()).name());
+                                                                                   data->GetPoint(tool.getId()).name());
             break;
-        case Tool::SplineTool:{
+        case Tool::SplineTool:
+        {
             VSpline spl = data->GetSpline(tool.getId());
             record = QString(tr("Curve %1_%2")).arg(data->GetPoint(spl.GetP1()).name(),
                                                  data->GetPoint(spl.GetP4()).name());
         }
         break;
-        case Tool::ArcTool:{
+        case Tool::ArcTool:
+        {
             VArc arc = data->GetArc(tool.getId());
             record = QString(tr("Arc with center in point %1")).arg(data->GetPoint(arc.GetCenter()).name());
         }
         break;
-        case Tool::SplinePathTool:{
+        case Tool::SplinePathTool:
+        {
             VSplinePath splPath = data->GetSplinePath(tool.getId());
             QVector<VSplinePoint> points = splPath.GetSplinePath();
-            if(points.size() != 0 ){
+            if (points.size() != 0 )
+            {
                 record = QString(tr("Curve point %1")).arg(data->GetPoint(points[0].P()).name());
-                for(qint32 i = 1; i< points.size(); ++i){
+                for (qint32 i = 1; i< points.size(); ++i)
+                {
                     QString name = QString("_%1").arg(data->GetPoint(points[i].P()).name());
                     record.append(name);
                 }
             }
         }
-         break;
+        break;
         case Tool::PointOfContact:
             domElement = doc->elementById(QString().setNum(tool.getId()));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 center = domElement.attribute("center", "").toLongLong();
                 firstPointId = domElement.attribute("firstPoint", "").toLongLong();
                 secondPointId = domElement.attribute("secondPoint", "").toLongLong();
             }
-            record = QString(tr("%4 - Point of contact arc with center in point %1 and line %2_%3")).arg(data->GetPoint(center).name(),
-                                                                                                         data->GetPoint(firstPointId).name(),
-                                                                                                         data->GetPoint(secondPointId).name(),
-                                                                                                         data->GetPoint(tool.getId()).name());
+            record = QString(tr("%4 - Point of contact arc with center in point %1 and line %2_%3")).arg(
+                        data->GetPoint(center).name(), data->GetPoint(firstPointId).name(),
+                        data->GetPoint(secondPointId).name(), data->GetPoint(tool.getId()).name());
             break;
-        case Tool::Height:{
+        case Tool::Height:
+        {
             qint64 p1LineId = 0;
             qint64 p2LineId = 0;
             domElement = doc->elementById(QString().setNum(tool.getId()));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 basePointId = domElement.attribute("basePoint", "").toLongLong();
                 p1LineId = domElement.attribute("p1Line", "").toLongLong();
                 p2LineId = domElement.attribute("p2Line", "").toLongLong();
             }
-            record = QString(tr("Point of perpendical from point %1 to line %2_%3")).arg(data->GetPoint(basePointId).name(),
-                                                                                         data->GetPoint(p1LineId).name(),
-                                                                                         data->GetPoint(p2LineId).name());
+            record = QString(tr("Point of perpendical from point %1 to line %2_%3")).arg(
+                        data->GetPoint(basePointId).name(), data->GetPoint(p1LineId).name(),
+                        data->GetPoint(p2LineId).name());
             break;
         }
-        case Tool::Triangle:{
+        case Tool::Triangle:
+        {
             qint64 axisP1Id = 0;
             qint64 axisP2Id = 0;
             domElement = doc->elementById(QString().setNum(tool.getId()));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 axisP1Id = domElement.attribute("axisP1", "").toLongLong();
                 axisP2Id = domElement.attribute("axisP2", "").toLongLong();
                 firstPointId = domElement.attribute("firstPoint", "").toLongLong();
                 secondPointId = domElement.attribute("secondPoint", "").toLongLong();
             }
             record = QString(tr("Triangle: axis %1_%2, points %3 and %4")).arg(
-                        data->GetPoint(axisP1Id).name(),data->GetPoint(axisP2Id).name(),
+                        data->GetPoint(axisP1Id).name(), data->GetPoint(axisP2Id).name(),
                         data->GetPoint(firstPointId).name(), data->GetPoint(secondPointId).name());
             break;
         }
@@ -286,15 +318,18 @@ QString DialogHistory::Record(const VToolRecord &tool){
     return record;
 }
 
-void DialogHistory::InitialTable(){
+void DialogHistory::InitialTable()
+{
     ui->tableWidget->setSortingEnabled(false);
     ui->tableWidget->setHorizontalHeaderItem(0, new QTableWidgetItem(" "));
     ui->tableWidget->setHorizontalHeaderItem(1, new QTableWidgetItem(tr("Tool")));
 }
 
-void DialogHistory::ShowPoint(){
+void DialogHistory::ShowPoint()
+{
     QVector<VToolRecord> *history = doc->getHistory();
-    if(history->size()>0){
+    if (history->size()>0)
+    {
         QTableWidgetItem *item = ui->tableWidget->item(0, 1);
         item->setSelected(true);
         cursorToolRecordRow = 0;
@@ -304,7 +339,8 @@ void DialogHistory::ShowPoint(){
     }
 }
 
-void DialogHistory::closeEvent(QCloseEvent *event){
+void DialogHistory::closeEvent(QCloseEvent *event)
+{
     QTableWidgetItem *item = ui->tableWidget->item(cursorToolRecordRow, 0);
     qint64 id = qvariant_cast<qint64>(item->data(Qt::UserRole));
     emit ShowHistoryTool(id, Qt::green, false);
diff --git a/dialogs/dialoghistory.h b/dialogs/dialoghistory.h
index bd650452e..c3b51156c 100644
--- a/dialogs/dialoghistory.h
+++ b/dialogs/dialoghistory.h
@@ -25,11 +25,13 @@
 #include "dialogtool.h"
 #include "xml/vdomdocument.h"
 
-namespace Ui {
-class DialogHistory;
+namespace Ui
+{
+    class DialogHistory;
 }
 
-class DialogHistory : public DialogTool{
+class DialogHistory : public DialogTool
+{
     Q_OBJECT
 public:
                       DialogHistory(VContainer *data, VDomDocument *doc, QWidget *parent = 0);
diff --git a/dialogs/dialogincrements.cpp b/dialogs/dialogincrements.cpp
index 86f2348c6..0dd5e7298 100644
--- a/dialogs/dialogincrements.cpp
+++ b/dialogs/dialogincrements.cpp
@@ -24,9 +24,9 @@
 #include <widgets/doubledelegate.h>
 #include <exception/vexception.h>
 
-DialogIncrements::DialogIncrements(VContainer *data, VDomDocument *doc, QWidget *parent) :
-    DialogTool(data, Draw::Calculation, parent), ui(new Ui::DialogIncrements), data(data), doc(doc),
-    row(0), column(0){
+DialogIncrements::DialogIncrements(VContainer *data, VDomDocument *doc, QWidget *parent)
+    :DialogTool(data, Draw::Calculation, parent), ui(new Ui::DialogIncrements), data(data), doc(doc), row(0), column(0)
+{
     ui->setupUi(this);
     InitialStandartTable();
     InitialIncrementTable();
@@ -58,12 +58,14 @@ DialogIncrements::DialogIncrements(VContainer *data, VDomDocument *doc, QWidget
     ui->tabWidget->setCurrentIndex(0);
 }
 
-void DialogIncrements::FillStandartTable(){
+void DialogIncrements::FillStandartTable()
+{
     const QHash<QString, VStandartTableCell> *standartTable = data->DataStandartTable();
     qint32 currentRow = -1;
     QHashIterator<QString, VStandartTableCell> i(*standartTable);
     ui->tableWidgetStandart->setRowCount ( standartTable->size() );
-    while (i.hasNext()) {
+    while (i.hasNext())
+    {
         i.next();
         VStandartTableCell cell = i.value();
         currentRow++;
@@ -98,12 +100,14 @@ void DialogIncrements::FillStandartTable(){
     ui->tableWidgetStandart->verticalHeader()->setDefaultSectionSize(20);
 }
 
-void DialogIncrements::FillIncrementTable(){
+void DialogIncrements::FillIncrementTable()
+{
     const QHash<QString, VIncrementTableRow> *incrementTable = data->DataIncrementTable();
     QHashIterator<QString, VIncrementTableRow> i(*incrementTable);
     QMap<qint64, QString> map;
     //Sorting QHash by id
-    while (i.hasNext()) {
+    while (i.hasNext())
+    {
         i.next();
         VIncrementTableRow cell = i.value();
         map.insert(cell.getId(), i.key());
@@ -111,7 +115,8 @@ void DialogIncrements::FillIncrementTable(){
 
     qint32 currentRow = -1;
     QMapIterator<qint64, QString> iMap(map);
-    while (iMap.hasNext()) {
+    while (iMap.hasNext())
+    {
         iMap.next();
         VIncrementTableRow cell = incrementTable->value(iMap.value());
         currentRow++;
@@ -147,7 +152,8 @@ void DialogIncrements::FillIncrementTable(){
         item->setTextAlignment(Qt::AlignLeft);
         ui->tableWidgetIncrement->setItem(currentRow, 5, item);
     }
-    if(ui->tableWidgetIncrement->rowCount()>0){
+    if (ui->tableWidgetIncrement->rowCount()>0)
+    {
         ui->toolButtonRemove->setEnabled(true);
     }
     ui->tableWidgetIncrement->resizeColumnsToContents();
@@ -155,19 +161,22 @@ void DialogIncrements::FillIncrementTable(){
     ui->tableWidgetIncrement->setCurrentCell( row, column );
 }
 
-void DialogIncrements::FillLengthLines(){
+void DialogIncrements::FillLengthLines()
+{
     const QHash<QString, qreal> *linesTable = data->DataLengthLines();
     QHashIterator<QString, qreal> iHash(*linesTable);
     QMap<QString, qreal> map;
     //Sorting QHash by name
-    while (iHash.hasNext()) {
+    while (iHash.hasNext())
+    {
         iHash.next();
         map.insert(iHash.key(), iHash.value());
     }
 
     qint32 currentRow = -1;
     QMapIterator<QString, qreal> i(map);
-    while (i.hasNext()) {
+    while (i.hasNext())
+    {
         i.next();
         qreal length = i.value();
         currentRow++;
@@ -187,19 +196,22 @@ void DialogIncrements::FillLengthLines(){
     ui->tableWidgetLines->verticalHeader()->setDefaultSectionSize(20);
 }
 
-void DialogIncrements::FillLengthSplines(){
+void DialogIncrements::FillLengthSplines()
+{
     const QHash<QString, qreal> *splinesTable = data->DataLengthSplines();
     QHashIterator<QString, qreal> iHash(*splinesTable);
     QMap<QString, qreal> map;
     //Sorting QHash by name
-    while (iHash.hasNext()) {
+    while (iHash.hasNext())
+    {
         iHash.next();
         map.insert(iHash.key(), iHash.value());
     }
 
     qint32 currentRow = -1;
     QMapIterator<QString, qreal> i(map);
-    while (i.hasNext()) {
+    while (i.hasNext())
+    {
         i.next();
         qreal length = i.value();
         currentRow++;
@@ -219,19 +231,22 @@ void DialogIncrements::FillLengthSplines(){
     ui->tableWidgetSplines->verticalHeader()->setDefaultSectionSize(20);
 }
 
-void DialogIncrements::FillLengthArcs(){
+void DialogIncrements::FillLengthArcs()
+{
     const QHash<QString, qreal> *arcsTable = data->DataLengthArcs();
     QHashIterator<QString, qreal> iHash(*arcsTable);
     QMap<QString, qreal> map;
     //Sorting QHash by name
-    while (iHash.hasNext()) {
+    while (iHash.hasNext())
+    {
         iHash.next();
         map.insert(iHash.key(), iHash.value());
     }
 
     qint32 currentRow = -1;
     QMapIterator<QString, qreal> i(map);
-    while (i.hasNext()) {
+    while (i.hasNext())
+    {
         i.next();
         qreal length = i.value();
         currentRow++;
@@ -251,7 +266,8 @@ void DialogIncrements::FillLengthArcs(){
     ui->tableWidgetArcs->verticalHeader()->setDefaultSectionSize(20);
 }
 
-void DialogIncrements::FullUpdateFromFile(){
+void DialogIncrements::FullUpdateFromFile()
+{
     disconnect(ui->tableWidgetIncrement, &QTableWidget::cellChanged, this,
                &DialogIncrements::cellChanged);
 
@@ -279,7 +295,8 @@ void DialogIncrements::FullUpdateFromFile(){
             &DialogIncrements::cellChanged);
 }
 
-void DialogIncrements::clickedToolButtonAdd(){
+void DialogIncrements::clickedToolButtonAdd()
+{
     disconnect(ui->tableWidgetIncrement, &QTableWidget::cellChanged, this,
                &DialogIncrements::cellChanged);
     ui->tableWidgetIncrement->setFocus(Qt::OtherFocusReason);
@@ -288,10 +305,11 @@ void DialogIncrements::clickedToolButtonAdd(){
 
     qint32 num = 1;
     QString name;
-    do{
+    do
+    {
         name = QString(tr("Denotation %1")).arg(num);
         num++;
-    }while(data->IncrementTableContains(name));
+    } while (data->IncrementTableContains(name));
 
     qint64 id = data->getNextId();
     qreal base = 0;
@@ -340,7 +358,8 @@ void DialogIncrements::clickedToolButtonAdd(){
     emit haveLiteChange();
 }
 
-void DialogIncrements::clickedToolButtonRemove(){
+void DialogIncrements::clickedToolButtonRemove()
+{
     disconnect(ui->tableWidgetIncrement, &QTableWidget::cellChanged, this,
                &DialogIncrements::cellChanged);
     QTableWidgetItem *item = ui->tableWidgetIncrement->currentItem();
@@ -349,12 +368,14 @@ void DialogIncrements::clickedToolButtonRemove(){
     data->RemoveIncrementTableRow(itemName->text());
     qint64 id = qvariant_cast<qint64>(item->data(Qt::UserRole));
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         QDomNodeList list = doc->elementsByTagName("increments");
         list.at(0).removeChild(domElement);
     }
     ui->tableWidgetIncrement->removeRow(row);
-    if(ui->tableWidgetIncrement->rowCount() == 0){
+    if (ui->tableWidgetIncrement->rowCount() == 0)
+    {
         ui->toolButtonRemove->setEnabled(false);
     }
     connect(ui->tableWidgetIncrement, &QTableWidget::cellChanged, this,
@@ -362,8 +383,9 @@ void DialogIncrements::clickedToolButtonRemove(){
     emit haveLiteChange();
 }
 
-void DialogIncrements::AddIncrementToFile(qint64 id, QString name, qreal base, qreal ksize,
-                                          qreal kgrowth, QString description){
+void DialogIncrements::AddIncrementToFile(qint64 id, QString name, qreal base, qreal ksize, qreal kgrowth,
+                                          QString description)
+{
     QDomNodeList list = doc->elementsByTagName("increments");
     QDomElement element = doc->createElement("increment");
 
@@ -394,18 +416,21 @@ void DialogIncrements::AddIncrementToFile(qint64 id, QString name, qreal base, q
     list.at(0).appendChild(element);
 }
 
-void DialogIncrements::cellChanged ( qint32 row, qint32 column ){
+void DialogIncrements::cellChanged ( qint32 row, qint32 column )
+{
     QTableWidgetItem *item = 0;
     QTableWidgetItem *itemName = 0;
     qint64 id;
     QDomElement domElement;
     this->row = row;
-    switch(column) {
+    switch (column)
+    {
         case 0:
             item = ui->tableWidgetIncrement->item(row, 0);
             id = qvariant_cast<qint64>(item->data(Qt::UserRole));
             domElement = doc->elementById(QString().setNum(id));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 domElement.setAttribute("name", item->text());
                 data->ClearIncrementTable();
                 this->column = 2;
@@ -417,14 +442,18 @@ void DialogIncrements::cellChanged ( qint32 row, qint32 column ){
             item = ui->tableWidgetIncrement->item(row, column);
             id = qvariant_cast<qint64>(itemName->data(Qt::UserRole));
             domElement = doc->elementById(QString().setNum(id));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 bool ok = false;
                 qreal value = item->text().toDouble(&ok);
-                if(ok){
+                if (ok)
+                {
                     domElement.setAttribute("base", value);
                     this->column = 3;
                     emit FullUpdateTree();
-                } else {
+                }
+                else
+                {
                     throw VException(tr("Can't convert toDouble value."));
                 }
             }
@@ -434,7 +463,8 @@ void DialogIncrements::cellChanged ( qint32 row, qint32 column ){
             item = ui->tableWidgetIncrement->item(row, column);
             id = qvariant_cast<qint64>(itemName->data(Qt::UserRole));
             domElement = doc->elementById(QString().setNum(id));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 domElement.setAttribute("ksize", item->text().toDouble());
                 this->column = 4;
                 emit FullUpdateTree();
@@ -445,7 +475,8 @@ void DialogIncrements::cellChanged ( qint32 row, qint32 column ){
             item = ui->tableWidgetIncrement->item(row, column);
             id = qvariant_cast<qint64>(itemName->data(Qt::UserRole));
             domElement = doc->elementById(QString().setNum(id));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 domElement.setAttribute("kgrowth", item->text().toDouble());
                 this->column = 5;
                 emit FullUpdateTree();
@@ -456,7 +487,8 @@ void DialogIncrements::cellChanged ( qint32 row, qint32 column ){
             item = ui->tableWidgetIncrement->item(row, column);
             id = qvariant_cast<qint64>(itemName->data(Qt::UserRole));
             domElement = doc->elementById(QString().setNum(id));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 domElement.setAttribute("description", item->text());
                 VIncrementTableRow incr = data->GetIncrementTableRow(itemName->text());
                 incr.setDescription(item->text());
@@ -470,7 +502,8 @@ void DialogIncrements::cellChanged ( qint32 row, qint32 column ){
     }
 }
 
-void DialogIncrements::InitialStandartTable(){
+void DialogIncrements::InitialStandartTable()
+{
     ui->tableWidgetStandart->setSortingEnabled(false);
     ui->tableWidgetStandart->setHorizontalHeaderItem(0, new QTableWidgetItem(tr("Denotation")));
     ui->tableWidgetStandart->setHorizontalHeaderItem(1, new QTableWidgetItem(tr("Calculated value")));
@@ -480,7 +513,8 @@ void DialogIncrements::InitialStandartTable(){
     ui->tableWidgetStandart->setHorizontalHeaderItem(5, new QTableWidgetItem(tr("Description")));
 }
 
-void DialogIncrements::InitialIncrementTable(){
+void DialogIncrements::InitialIncrementTable()
+{
     ui->tableWidgetIncrement->setSortingEnabled(false);
     ui->tableWidgetIncrement->setHorizontalHeaderItem(0, new QTableWidgetItem(tr("Denotation")));
     ui->tableWidgetIncrement->setHorizontalHeaderItem(1, new QTableWidgetItem(tr("Calculated value")));
@@ -491,25 +525,30 @@ void DialogIncrements::InitialIncrementTable(){
     ui->tableWidgetIncrement->verticalHeader()->setDefaultSectionSize(20);
 }
 
-void DialogIncrements::InitialLinesTable(){
+void DialogIncrements::InitialLinesTable()
+{
     ui->tableWidgetLines->setHorizontalHeaderItem(0, new QTableWidgetItem(tr("Line")));
     ui->tableWidgetLines->setHorizontalHeaderItem(1, new QTableWidgetItem(tr("Length")));
 }
 
-void DialogIncrements::InitialSplinesTable(){
+void DialogIncrements::InitialSplinesTable()
+{
     ui->tableWidgetSplines->setHorizontalHeaderItem(0, new QTableWidgetItem(tr("Curve")));
     ui->tableWidgetSplines->setHorizontalHeaderItem(1, new QTableWidgetItem(tr("Length")));
 }
 
-void DialogIncrements::InitialArcsTable(){
+void DialogIncrements::InitialArcsTable()
+{
     ui->tableWidgetArcs->setHorizontalHeaderItem(0, new QTableWidgetItem(tr("Arc")));
     ui->tableWidgetArcs->setHorizontalHeaderItem(1, new QTableWidgetItem(tr("Length")));
 }
 
-void DialogIncrements::DialogAccepted(){
+void DialogIncrements::DialogAccepted()
+{
     emit DialogClosed(QDialog::Accepted);
 }
 
-DialogIncrements::~DialogIncrements(){
+DialogIncrements::~DialogIncrements()
+{
     delete ui;
 }
diff --git a/dialogs/dialogincrements.h b/dialogs/dialogincrements.h
index a9f5d9e8a..bc4260052 100644
--- a/dialogs/dialogincrements.h
+++ b/dialogs/dialogincrements.h
@@ -25,12 +25,14 @@
 #include "dialogtool.h"
 #include "xml/vdomdocument.h"
 
-namespace Ui {
-class DialogIncrements;
+namespace Ui
+{
+    class DialogIncrements;
 }
 
-class DialogIncrements : public DialogTool{
-    Q_OBJECT   
+class DialogIncrements : public DialogTool
+{
+    Q_OBJECT
 public:
                          DialogIncrements(VContainer *data, VDomDocument *doc, QWidget *parent = 0);
                          ~DialogIncrements();
diff --git a/dialogs/dialogline.cpp b/dialogs/dialogline.cpp
index a94b65fd5..ecdf6cb9d 100644
--- a/dialogs/dialogline.cpp
+++ b/dialogs/dialogline.cpp
@@ -22,8 +22,9 @@
 #include "dialogline.h"
 #include "ui_dialogline.h"
 
-DialogLine::DialogLine(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(new Ui::DialogLine), number(0), firstPoint(0), secondPoint(0){
+DialogLine::DialogLine(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(new Ui::DialogLine), number(0), firstPoint(0), secondPoint(0)
+{
     ui->setupUi(this);
     bOk = ui->buttonBox->button(QDialogButtonBox::Ok);
     connect(bOk, &QPushButton::clicked, this, &DialogLine::DialogAccepted);
@@ -34,30 +35,36 @@ DialogLine::DialogLine(const VContainer *data, Draw::Draws mode, QWidget *parent
     number = 0;
 }
 
-DialogLine::~DialogLine(){
+DialogLine::~DialogLine()
+{
     delete ui;
 }
 
-void DialogLine::setSecondPoint(const qint64 &value){
+void DialogLine::setSecondPoint(const qint64 &value)
+{
     secondPoint = value;
     VPointF point = data->GetPoint(value);
     qint32 index = ui->comboBoxSecondPoint->findText(point.name());
-    if(index != -1){
+    if (index != -1)
+    {
         ui->comboBoxSecondPoint->setCurrentIndex(index);
     }
 }
 
-void DialogLine::setFirstPoint(const qint64 &value){
+void DialogLine::setFirstPoint(const qint64 &value)
+{
     firstPoint = value;
     VPointF point = data->GetPoint(value);
     qint32 index = ui->comboBoxFirstPoint->findText(point.name());
-    if(index != -1){
+    if (index != -1)
+    {
         ui->comboBoxFirstPoint->setCurrentIndex(index);
     }
 }
 
 
-void DialogLine::DialogAccepted(){
+void DialogLine::DialogAccepted()
+{
     qint32 index = ui->comboBoxFirstPoint->currentIndex();
     firstPoint = qvariant_cast<qint64>(ui->comboBoxFirstPoint->itemData(index));
     index = ui->comboBoxSecondPoint->currentIndex();
@@ -65,42 +72,56 @@ void DialogLine::DialogAccepted(){
     DialogClosed(QDialog::Accepted);
 }
 
-void DialogLine::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogLine::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id) == false)
+        {
             return;
         }
     }
-    if(type == Scene::Point){
+    if (type == Scene::Point)
+    {
         VPointF point;
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             point = data->GetPoint(id);
-        } else {
+        }
+        else
+        {
             point = data->GetModelingPoint(id);
         }
-        if(number == 0){
+        if (number == 0)
+        {
             qint32 index = ui->comboBoxFirstPoint->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxFirstPoint->setCurrentIndex(index);
                 number++;
                 emit ToolTip(tr("Select second point"));
                 return;
             }
         }
-        if(number == 1){
+        if (number == 1)
+        {
             qint32 index = ui->comboBoxSecondPoint->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxSecondPoint->setCurrentIndex(index);
                 number = 0;
                 emit ToolTip("");
             }
-            if(!isInitialized){
+            if (isInitialized == false)
+            {
                 this->show();
             }
         }
diff --git a/dialogs/dialogline.h b/dialogs/dialogline.h
index 99bc99d1a..9957eca16 100644
--- a/dialogs/dialogline.h
+++ b/dialogs/dialogline.h
@@ -24,16 +24,17 @@
 
 #include "dialogtool.h"
 
-namespace Ui {
-class DialogLine;
+namespace Ui
+{
+    class DialogLine;
 }
 
-class DialogLine : public DialogTool{
+class DialogLine : public DialogTool
+{
     Q_OBJECT
 public:
-    explicit         DialogLine(const VContainer *data, Draw::Draws mode = Draw::Calculation,
-                                QWidget *parent = 0);
-                     ~DialogLine();   
+                     DialogLine(const VContainer *data, Draw::Draws mode = Draw::Calculation, QWidget *parent = 0);
+                     ~DialogLine();
     inline qint64    getFirstPoint() const {return firstPoint;}
     void             setFirstPoint(const qint64 &value);
     inline qint64    getSecondPoint() const {return secondPoint;}
diff --git a/dialogs/dialoglineintersect.cpp b/dialogs/dialoglineintersect.cpp
index 347c45815..4961e0db3 100644
--- a/dialogs/dialoglineintersect.cpp
+++ b/dialogs/dialoglineintersect.cpp
@@ -22,9 +22,10 @@
 #include "dialoglineintersect.h"
 #include "ui_dialoglineintersect.h"
 
-DialogLineIntersect::DialogLineIntersect(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(new Ui::DialogLineIntersect), number(0), pointName(QString()),
-    p1Line1(0), p2Line1(0), p1Line2(0), p2Line2(0), flagPoint(true){
+DialogLineIntersect::DialogLineIntersect(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(new Ui::DialogLineIntersect), number(0), pointName(QString()),
+    p1Line1(0), p2Line1(0), p1Line2(0), p2Line2(0), flagPoint(true)
+{
     ui->setupUi(this);
     number = 0;
     bOk = ui->buttonBox->button(QDialogButtonBox::Ok);
@@ -41,32 +42,44 @@ DialogLineIntersect::DialogLineIntersect(const VContainer *data, Draw::Draws mod
     connect(ui->lineEditNamePoint, &QLineEdit::textChanged, this, &DialogLineIntersect::NamePointChanged);
 }
 
-DialogLineIntersect::~DialogLineIntersect(){
+DialogLineIntersect::~DialogLineIntersect()
+{
     delete ui;
 }
 
-void DialogLineIntersect::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogLineIntersect::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id) == false)
+        {
             return;
         }
     }
-    if(type == Scene::Point){
+    if (type == Scene::Point)
+    {
         VPointF point;
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             point = data->GetPoint(id);
-        } else {
+        }
+        else
+        {
             point = data->GetModelingPoint(id);
         }
-        if(number == 0){
+        if (number == 0)
+        {
             qint32 index = ui->comboBoxP1Line1->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxP1Line1->setCurrentIndex(index);
                 p1Line1 = id;
                 number++;
@@ -74,9 +87,11 @@ void DialogLineIntersect::ChoosedObject(qint64 id, Scene::Scenes type){
                 return;
             }
         }
-        if(number == 1){
+        if (number == 1)
+        {
             qint32 index = ui->comboBoxP2Line1->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxP2Line1->setCurrentIndex(index);
                 p2Line1 = id;
                 number++;
@@ -84,9 +99,11 @@ void DialogLineIntersect::ChoosedObject(qint64 id, Scene::Scenes type){
                 return;
             }
         }
-        if(number == 2){
+        if (number == 2)
+        {
             qint32 index = ui->comboBoxP1Line2->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxP1Line2->setCurrentIndex(index);
                 p1Line2 = id;
                 number++;
@@ -94,15 +111,18 @@ void DialogLineIntersect::ChoosedObject(qint64 id, Scene::Scenes type){
                 return;
             }
         }
-        if(number == 3){
+        if (number == 3)
+        {
             qint32 index = ui->comboBoxP2Line2->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxP2Line2->setCurrentIndex(index);
                 p2Line2 = id;
                 number = 0;
                 emit ToolTip("");
             }
-            if(!isInitialized){
+            if (isInitialized == false)
+            {
                 flagPoint = CheckIntersecion();
                 CheckState();
                 this->show();
@@ -123,7 +143,8 @@ void DialogLineIntersect::ChoosedObject(qint64 id, Scene::Scenes type){
     }
 }
 
-void DialogLineIntersect::DialogAccepted(){
+void DialogLineIntersect::DialogAccepted()
+{
     pointName = ui->lineEditNamePoint->text();
     p1Line1 = getCurrentPointId(ui->comboBoxP1Line1);
     p2Line1 = getCurrentPointId(ui->comboBoxP2Line1);
@@ -132,36 +153,42 @@ void DialogLineIntersect::DialogAccepted(){
     emit DialogClosed(QDialog::Accepted);
 }
 
-void DialogLineIntersect::P1Line1Changed( int index){
+void DialogLineIntersect::P1Line1Changed( int index)
+{
     p1Line1 = qvariant_cast<qint64>(ui->comboBoxP1Line1->itemData(index));
     flagPoint = CheckIntersecion();
     CheckState();
 }
 
-void DialogLineIntersect::P2Line1Changed(int index){
+void DialogLineIntersect::P2Line1Changed(int index)
+{
     p2Line1 = qvariant_cast<qint64>(ui->comboBoxP2Line1->itemData(index));
     flagPoint = CheckIntersecion();
     CheckState();
 }
 
-void DialogLineIntersect::P1Line2Changed(int index){
+void DialogLineIntersect::P1Line2Changed(int index)
+{
     p1Line2 = qvariant_cast<qint64>(ui->comboBoxP1Line2->itemData(index));
     flagPoint = CheckIntersecion();
     CheckState();
 }
 
-void DialogLineIntersect::P2Line2Changed(int index){
+void DialogLineIntersect::P2Line2Changed(int index)
+{
     p2Line2 = qvariant_cast<qint64>(ui->comboBoxP2Line2->itemData(index));
     flagPoint = CheckIntersecion();
     CheckState();
 }
 
-void DialogLineIntersect::CheckState(){
+void DialogLineIntersect::CheckState()
+{
     Q_ASSERT(bOk != 0);
     bOk->setEnabled(flagName && flagPoint);
 }
 
-bool DialogLineIntersect::CheckIntersecion(){
+bool DialogLineIntersect::CheckIntersecion()
+{
     VPointF p1L1 = data->GetPoint(p1Line1);
     VPointF p2L1 = data->GetPoint(p2Line1);
     VPointF p1L2 = data->GetPoint(p1Line2);
@@ -171,34 +198,42 @@ bool DialogLineIntersect::CheckIntersecion(){
     QLineF line2(p1L2.toQPointF(), p2L2.toQPointF());
     QPointF fPoint;
     QLineF::IntersectType intersect = line1.intersect(line2, &fPoint);
-    if(intersect == QLineF::UnboundedIntersection || intersect == QLineF::BoundedIntersection){
+    if (intersect == QLineF::UnboundedIntersection || intersect == QLineF::BoundedIntersection)
+    {
         return true;
-    } else {
+    }
+    else
+    {
         return false;
     }
 }
 
-void DialogLineIntersect::setP2Line2(const qint64 &value){
+void DialogLineIntersect::setP2Line2(const qint64 &value)
+{
     p2Line2 = value;
     ChangeCurrentData(ui->comboBoxP2Line2, value);
 }
 
-void DialogLineIntersect::setP1Line2(const qint64 &value){
+void DialogLineIntersect::setP1Line2(const qint64 &value)
+{
     p1Line2 = value;
     ChangeCurrentData(ui->comboBoxP1Line2, value);
 }
 
-void DialogLineIntersect::setP2Line1(const qint64 &value){
+void DialogLineIntersect::setP2Line1(const qint64 &value)
+{
     p2Line1 = value;
     ChangeCurrentData(ui->comboBoxP2Line1, value);
 }
 
-void DialogLineIntersect::setP1Line1(const qint64 &value){
+void DialogLineIntersect::setP1Line1(const qint64 &value)
+{
     p1Line1 = value;
     ChangeCurrentData(ui->comboBoxP1Line1, value);
 }
 
-void DialogLineIntersect::setPointName(const QString &value){
+void DialogLineIntersect::setPointName(const QString &value)
+{
     pointName = value;
     ui->lineEditNamePoint->setText(pointName);
 }
diff --git a/dialogs/dialoglineintersect.h b/dialogs/dialoglineintersect.h
index 34cb19aeb..9c5195df5 100644
--- a/dialogs/dialoglineintersect.h
+++ b/dialogs/dialoglineintersect.h
@@ -24,14 +24,16 @@
 
 #include "dialogtool.h"
 
-namespace Ui {
-class DialogLineIntersect;
+namespace Ui
+{
+    class DialogLineIntersect;
 }
 
-class DialogLineIntersect : public DialogTool{
+class DialogLineIntersect : public DialogTool
+{
     Q_OBJECT
 public:
-    explicit                DialogLineIntersect(const VContainer *data, Draw::Draws mode = Draw::Calculation,
+                            DialogLineIntersect(const VContainer *data, Draw::Draws mode = Draw::Calculation,
                                                 QWidget *parent = 0);
                             ~DialogLineIntersect();
     inline qint64           getP1Line1() const {return p1Line1;}
diff --git a/dialogs/dialognormal.cpp b/dialogs/dialognormal.cpp
index 0b467145e..d13aeab95 100644
--- a/dialogs/dialognormal.cpp
+++ b/dialogs/dialognormal.cpp
@@ -22,9 +22,10 @@
 #include "dialognormal.h"
 #include "ui_dialognormal.h"
 
-DialogNormal::DialogNormal(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(new Ui::DialogNormal), number(0), pointName(QString()),
-    typeLine(QString()), formula(QString()), angle(0), firstPointId(0), secondPointId(0){
+DialogNormal::DialogNormal(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(new Ui::DialogNormal), number(0), pointName(QString()),
+    typeLine(QString()), formula(QString()), angle(0), firstPointId(0), secondPointId(0)
+{
     ui->setupUi(this);
     spinBoxAngle = ui->doubleSpinBoxAngle;
     listWidget = ui->listWidget;
@@ -82,53 +83,69 @@ DialogNormal::DialogNormal(const VContainer *data, Draw::Draws mode, QWidget *pa
     connect(ui->lineEditFormula, &QLineEdit::textChanged, this, &DialogNormal::FormulaChanged);
 }
 
-DialogNormal::~DialogNormal(){
+DialogNormal::~DialogNormal()
+{
     delete ui;
 }
 
-void DialogNormal::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogNormal::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id) == false)
+        {
             return;
         }
     }
-    if(type == Scene::Point){
+    if (type == Scene::Point)
+    {
         VPointF point;
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             point = data->GetPoint(id);
-        } else {
+        }
+        else
+        {
             point = data->GetModelingPoint(id);
         }
-        if(number == 0){
+        if (number == 0)
+        {
             qint32 index = ui->comboBoxFirstPoint->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxFirstPoint->setCurrentIndex(index);
                 number++;
                 emit ToolTip(tr("Select second point of line"));
                 return;
             }
         }
-        if(number == 1){
+        if (number == 1)
+        {
             qint32 index = ui->comboBoxSecondPoint->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxSecondPoint->setCurrentIndex(index);
                 number = 0;
                 emit ToolTip("");
             }
-            if(!isInitialized){
+            if (isInitialized == false)
+            {
                 this->show();
             }
         }
     }
 }
 
-void DialogNormal::DialogAccepted(){
+void DialogNormal::DialogAccepted()
+{
     pointName = ui->lineEditNamePoint->text();
     typeLine = GetTypeLine(ui->comboBoxLineType);
     formula = ui->lineEditFormula->text();
@@ -138,30 +155,36 @@ void DialogNormal::DialogAccepted(){
     emit DialogClosed(QDialog::Accepted);
 }
 
-void DialogNormal::setSecondPointId(const qint64 &value, const qint64 &id){
+void DialogNormal::setSecondPointId(const qint64 &value, const qint64 &id)
+{
     setCurrentPointId(ui->comboBoxSecondPoint, secondPointId, value, id);
 }
 
-void DialogNormal::setFirstPointId(const qint64 &value, const qint64 &id){
+void DialogNormal::setFirstPointId(const qint64 &value, const qint64 &id)
+{
     setCurrentPointId(ui->comboBoxFirstPoint, firstPointId, value, id);
 }
 
-void DialogNormal::setAngle(const qreal &value){
+void DialogNormal::setAngle(const qreal &value)
+{
     angle = value;
     ui->doubleSpinBoxAngle->setValue(angle);
 }
 
-void DialogNormal::setFormula(const QString &value){
+void DialogNormal::setFormula(const QString &value)
+{
     formula = value;
     ui->lineEditFormula->setText(formula);
 }
 
-void DialogNormal::setTypeLine(const QString &value){
+void DialogNormal::setTypeLine(const QString &value)
+{
     typeLine = value;
     SetupTypeLine(ui->comboBoxLineType, value);
 }
 
-void DialogNormal::setPointName(const QString &value){
+void DialogNormal::setPointName(const QString &value)
+{
     pointName = value;
     ui->lineEditNamePoint->setText(pointName);
 }
diff --git a/dialogs/dialognormal.h b/dialogs/dialognormal.h
index e1f685e7f..84a661522 100644
--- a/dialogs/dialognormal.h
+++ b/dialogs/dialognormal.h
@@ -24,15 +24,16 @@
 
 #include "dialogtool.h"
 
-namespace Ui {
-class DialogNormal;
+namespace Ui
+{
+    class DialogNormal;
 }
 
-class DialogNormal : public DialogTool{
+class DialogNormal : public DialogTool
+{
     Q_OBJECT
 public:
-    explicit         DialogNormal(const VContainer *data, Draw::Draws mode = Draw::Calculation,
-                                  QWidget *parent = 0);
+                     DialogNormal(const VContainer *data, Draw::Draws mode = Draw::Calculation, QWidget *parent = 0);
                      ~DialogNormal();
     inline QString   getPointName() const{return pointName;}
     void             setPointName(const QString &value);
diff --git a/dialogs/dialogpointofcontact.cpp b/dialogs/dialogpointofcontact.cpp
index d09b7b021..6b551df7e 100644
--- a/dialogs/dialogpointofcontact.cpp
+++ b/dialogs/dialogpointofcontact.cpp
@@ -21,9 +21,10 @@
 
 #include "dialogpointofcontact.h"
 
-DialogPointOfContact::DialogPointOfContact(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(), number(0), pointName(QString()), radius(QString()), center(0),
-    firstPoint(0), secondPoint(0){
+DialogPointOfContact::DialogPointOfContact(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(), number(0), pointName(QString()), radius(QString()), center(0),
+    firstPoint(0), secondPoint(0)
+{
     ui.setupUi(this);
     listWidget = ui.listWidget;
     labelResultCalculation = ui.labelResultCalculation;
@@ -64,58 +65,75 @@ DialogPointOfContact::DialogPointOfContact(const VContainer *data, Draw::Draws m
     connect(ui.lineEditFormula, &QLineEdit::textChanged, this, &DialogPointOfContact::FormulaChanged);
 }
 
-void DialogPointOfContact::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogPointOfContact::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id) == false)
+        {
             return;
         }
     }
-    if(type == Scene::Point){
+    if (type == Scene::Point)
+    {
         VPointF point;
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             point = data->GetPoint(id);
-        } else {
+        }
+        else
+        {
             point = data->GetModelingPoint(id);
         }
-        if(number == 0){
+        if (number == 0)
+        {
             qint32 index = ui.comboBoxFirstPoint->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui.comboBoxFirstPoint->setCurrentIndex(index);
                 number++;
                 emit ToolTip(tr("Select second point of line"));
                 return;
             }
         }
-        if(number == 1){
+        if (number == 1)
+        {
             qint32 index = ui.comboBoxSecondPoint->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui.comboBoxSecondPoint->setCurrentIndex(index);
                 number++;
                 emit ToolTip(tr("Select point of center of arc"));
                 return;
             }
         }
-        if(number == 2){
+        if (number == 2)
+        {
             qint32 index = ui.comboBoxCenter->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui.comboBoxCenter->setCurrentIndex(index);
                 number = 0;
                 emit ToolTip("");
             }
-            if(!isInitialized){
+            if (isInitialized == false)
+            {
                 this->show();
             }
         }
     }
 }
 
-void DialogPointOfContact::DialogAccepted(){
+void DialogPointOfContact::DialogAccepted()
+{
     pointName = ui.lineEditNamePoint->text();
     radius = ui.lineEditFormula->text();
     center = getCurrentPointId(ui.comboBoxCenter);
@@ -124,25 +142,30 @@ void DialogPointOfContact::DialogAccepted(){
     emit DialogClosed(QDialog::Accepted);
 }
 
-void DialogPointOfContact::setSecondPoint(const qint64 &value, const qint64 &id){
+void DialogPointOfContact::setSecondPoint(const qint64 &value, const qint64 &id)
+{
     setCurrentPointId(ui.comboBoxSecondPoint, secondPoint, value, id);
 }
 
-void DialogPointOfContact::setFirstPoint(const qint64 &value, const qint64 &id){
+void DialogPointOfContact::setFirstPoint(const qint64 &value, const qint64 &id)
+{
     setCurrentPointId(ui.comboBoxFirstPoint, firstPoint, value, id);
 }
 
-void DialogPointOfContact::setCenter(const qint64 &value, const qint64 &id){
+void DialogPointOfContact::setCenter(const qint64 &value, const qint64 &id)
+{
     setCurrentPointId(ui.comboBoxCenter, center, value, id);
     center = value;
 }
 
-void DialogPointOfContact::setRadius(const QString &value){
+void DialogPointOfContact::setRadius(const QString &value)
+{
     radius = value;
     ui.lineEditFormula->setText(radius);
 }
 
-void DialogPointOfContact::setPointName(const QString &value){
+void DialogPointOfContact::setPointName(const QString &value)
+{
     pointName = value;
     ui.lineEditNamePoint->setText(pointName);
 }
diff --git a/dialogs/dialogpointofcontact.h b/dialogs/dialogpointofcontact.h
index 003c16001..35af0835a 100644
--- a/dialogs/dialogpointofcontact.h
+++ b/dialogs/dialogpointofcontact.h
@@ -25,9 +25,9 @@
 #include "ui_dialogpointofcontact.h"
 #include "dialogtool.h"
 
-class DialogPointOfContact : public DialogTool{
+class DialogPointOfContact : public DialogTool
+{
     Q_OBJECT
-    
 public:
                  DialogPointOfContact(const VContainer *data, Draw::Draws mode = Draw::Calculation,
                                       QWidget *parent = 0);
diff --git a/dialogs/dialogpointofintersection.cpp b/dialogs/dialogpointofintersection.cpp
index 1172284fe..bf6fff658 100644
--- a/dialogs/dialogpointofintersection.cpp
+++ b/dialogs/dialogpointofintersection.cpp
@@ -1,9 +1,10 @@
 #include "dialogpointofintersection.h"
 #include "ui_dialogpointofintersection.h"
 
-DialogPointOfIntersection::DialogPointOfIntersection(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(new Ui::DialogPointOfIntersection), number(0), pointName(QString()),
-    firstPointId(0), secondPointId(0){
+DialogPointOfIntersection::DialogPointOfIntersection(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(new Ui::DialogPointOfIntersection), number(0), pointName(QString()),
+    firstPointId(0), secondPointId(0)
+{
     ui->setupUi(this);
     labelEditNamePoint = ui->labelEditNamePoint;
     bOk = ui->buttonBox->button(QDialogButtonBox::Ok);
@@ -17,70 +18,89 @@ DialogPointOfIntersection::DialogPointOfIntersection(const VContainer *data, Dra
     connect(ui->lineEditNamePoint, &QLineEdit::textChanged, this, &DialogPointOfIntersection::NamePointChanged);
 }
 
-DialogPointOfIntersection::~DialogPointOfIntersection(){
+DialogPointOfIntersection::~DialogPointOfIntersection()
+{
     delete ui;
 }
 
-void DialogPointOfIntersection::setSecondPointId(const qint64 &value, const qint64 &id){
+void DialogPointOfIntersection::setSecondPointId(const qint64 &value, const qint64 &id)
+{
     secondPointId = value;
     setCurrentPointId(ui->comboBoxSecondPoint, secondPointId, value, id);
 }
 
-void DialogPointOfIntersection::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogPointOfIntersection::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id) == false)
+        {
             return;
         }
     }
-    if(type == Scene::Point){
+    if (type == Scene::Point)
+    {
         VPointF point;
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             point = data->GetPoint(id);
-        } else {
+        }
+        else
+        {
             point = data->GetModelingPoint(id);
         }
-        if(number == 0){
+        if (number == 0)
+        {
             qint32 index = ui->comboBoxFirstPoint->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxFirstPoint->setCurrentIndex(index);
                 number++;
                 emit ToolTip(tr("Select point horizontally"));
                 return;
             }
         }
-        if(number == 1){
+        if (number == 1)
+        {
             qint32 index = ui->comboBoxSecondPoint->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxSecondPoint->setCurrentIndex(index);
                 number = 0;
                 emit ToolTip("");
             }
-            if(!isInitialized){
+            if (isInitialized == false)
+            {
                 this->show();
             }
         }
     }
 }
 
-void DialogPointOfIntersection::DialogAccepted(){
+void DialogPointOfIntersection::DialogAccepted()
+{
     pointName = ui->lineEditNamePoint->text();
     firstPointId = getCurrentPointId(ui->comboBoxFirstPoint);
     secondPointId = getCurrentPointId(ui->comboBoxSecondPoint);
     emit DialogClosed(QDialog::Accepted);
 }
 
-void DialogPointOfIntersection::setFirstPointId(const qint64 &value, const qint64 &id){
+void DialogPointOfIntersection::setFirstPointId(const qint64 &value, const qint64 &id)
+{
     firstPointId = value;
     setCurrentPointId(ui->comboBoxFirstPoint, firstPointId, value, id);
 }
 
-void DialogPointOfIntersection::setPointName(const QString &value){
+void DialogPointOfIntersection::setPointName(const QString &value)
+{
     pointName = value;
     ui->lineEditNamePoint->setText(pointName);
 }
diff --git a/dialogs/dialogpointofintersection.h b/dialogs/dialogpointofintersection.h
index 432105400..52a3ff7a2 100644
--- a/dialogs/dialogpointofintersection.h
+++ b/dialogs/dialogpointofintersection.h
@@ -3,12 +3,14 @@
 
 #include "dialogtool.h"
 
-namespace Ui {
-class DialogPointOfIntersection;
+namespace Ui
+{
+    class DialogPointOfIntersection;
 }
 
-class DialogPointOfIntersection : public DialogTool{
-    Q_OBJECT   
+class DialogPointOfIntersection : public DialogTool
+{
+    Q_OBJECT
 public:
                    DialogPointOfIntersection(const VContainer *data, Draw::Draws mode = Draw::Calculation,
                                              QWidget *parent = 0);
diff --git a/dialogs/dialogshoulderpoint.cpp b/dialogs/dialogshoulderpoint.cpp
index 9c65ec76a..0224eb90b 100644
--- a/dialogs/dialogshoulderpoint.cpp
+++ b/dialogs/dialogshoulderpoint.cpp
@@ -22,9 +22,10 @@
 #include "dialogshoulderpoint.h"
 #include "ui_dialogshoulderpoint.h"
 
-DialogShoulderPoint::DialogShoulderPoint(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(new Ui::DialogShoulderPoint), number(0), pointName(QString()),
-    typeLine(QString()), formula(QString()), p1Line(0), p2Line(0), pShoulder(0){
+DialogShoulderPoint::DialogShoulderPoint(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(new Ui::DialogShoulderPoint), number(0), pointName(QString()),
+    typeLine(QString()), formula(QString()), p1Line(0), p2Line(0), pShoulder(0)
+{
     ui->setupUi(this);
     number = 0;
     listWidget = ui->listWidget;
@@ -67,62 +68,80 @@ DialogShoulderPoint::DialogShoulderPoint(const VContainer *data, Draw::Draws mod
     connect(ui->lineEditFormula, &QLineEdit::textChanged, this, &DialogShoulderPoint::FormulaChanged);
 }
 
-DialogShoulderPoint::~DialogShoulderPoint(){
+DialogShoulderPoint::~DialogShoulderPoint()
+{
     delete ui;
 }
 
-void DialogShoulderPoint::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogShoulderPoint::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id) == false)
+        {
             return;
         }
     }
-    if(type == Scene::Point){
+    if (type == Scene::Point)
+    {
         VPointF point;
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             point = data->GetPoint(id);
-        } else {
+        }
+        else
+        {
             point = data->GetModelingPoint(id);
         }
-        if(number == 0){
+        if (number == 0)
+        {
             qint32 index = ui->comboBoxP1Line->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxP1Line->setCurrentIndex(index);
                 number++;
                 emit ToolTip(tr("Select second point of line"));
                 return;
             }
         }
-        if(number == 1){
+        if (number == 1)
+        {
             qint32 index = ui->comboBoxP2Line->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxP2Line->setCurrentIndex(index);
                 number++;
                 emit ToolTip(tr("Select point of shoulder"));
                 return;
             }
         }
-        if(number == 2){
+        if (number == 2)
+        {
             qint32 index = ui->comboBoxPShoulder->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxPShoulder->setCurrentIndex(index);
                 number = 0;
                 emit ToolTip("");
             }
-            if(!isInitialized){
+            if (isInitialized == false)
+            {
                 this->show();
             }
         }
     }
 }
 
-void DialogShoulderPoint::DialogAccepted(){
+void DialogShoulderPoint::DialogAccepted()
+{
     pointName = ui->lineEditNamePoint->text();
     typeLine = GetTypeLine(ui->comboBoxLineType);
     formula = ui->lineEditFormula->text();
@@ -132,29 +151,35 @@ void DialogShoulderPoint::DialogAccepted(){
     emit DialogClosed(QDialog::Accepted);
 }
 
-void DialogShoulderPoint::setPShoulder(const qint64 &value, const qint64 &id){
+void DialogShoulderPoint::setPShoulder(const qint64 &value, const qint64 &id)
+{
     setCurrentPointId(ui->comboBoxPShoulder, pShoulder, value, id);
 }
 
-void DialogShoulderPoint::setP2Line(const qint64 &value, const qint64 &id){
+void DialogShoulderPoint::setP2Line(const qint64 &value, const qint64 &id)
+{
     setCurrentPointId(ui->comboBoxP2Line, p2Line, value, id);
 }
 
-void DialogShoulderPoint::setP1Line(const qint64 &value, const qint64 &id){
+void DialogShoulderPoint::setP1Line(const qint64 &value, const qint64 &id)
+{
     setCurrentPointId(ui->comboBoxP1Line, p1Line, value, id);
 }
 
-void DialogShoulderPoint::setFormula(const QString &value){
+void DialogShoulderPoint::setFormula(const QString &value)
+{
     formula = value;
     ui->lineEditFormula->setText(formula);
 }
 
-void DialogShoulderPoint::setTypeLine(const QString &value){
+void DialogShoulderPoint::setTypeLine(const QString &value)
+{
     typeLine = value;
     SetupTypeLine(ui->comboBoxLineType, value);
 }
 
-void DialogShoulderPoint::setPointName(const QString &value){
+void DialogShoulderPoint::setPointName(const QString &value)
+{
     pointName = value;
     ui->lineEditNamePoint->setText(pointName);
 }
diff --git a/dialogs/dialogshoulderpoint.h b/dialogs/dialogshoulderpoint.h
index 44b315738..8d06393e6 100644
--- a/dialogs/dialogshoulderpoint.h
+++ b/dialogs/dialogshoulderpoint.h
@@ -24,11 +24,13 @@
 
 #include "dialogtool.h"
 
-namespace Ui {
-class DialogShoulderPoint;
+namespace Ui
+{
+    class DialogShoulderPoint;
 }
 
-class DialogShoulderPoint : public DialogTool{
+class DialogShoulderPoint : public DialogTool
+{
     Q_OBJECT
 public:
                    DialogShoulderPoint(const VContainer *data, Draw::Draws mode = Draw::Calculation,
diff --git a/dialogs/dialogsinglepoint.cpp b/dialogs/dialogsinglepoint.cpp
index 9bb6914d1..ddf12c14e 100644
--- a/dialogs/dialogsinglepoint.cpp
+++ b/dialogs/dialogsinglepoint.cpp
@@ -22,12 +22,13 @@
 #include "dialogsinglepoint.h"
 #include "ui_dialogsinglepoint.h"
 
-DialogSinglePoint::DialogSinglePoint(const VContainer *data, QWidget *parent) :
-    DialogTool(data, Draw::Calculation, parent), ui(new Ui::DialogSinglePoint), name(QString()),
-    point(QPointF()){
+DialogSinglePoint::DialogSinglePoint(const VContainer *data, QWidget *parent)
+    :DialogTool(data, Draw::Calculation, parent), ui(new Ui::DialogSinglePoint), name(QString()),
+    point(QPointF())
+{
     ui->setupUi(this);
-    ui->doubleSpinBoxX->setRange(0,toMM(PaperSize));
-    ui->doubleSpinBoxY->setRange(0,toMM(PaperSize));
+    ui->doubleSpinBoxX->setRange(0, toMM(PaperSize));
+    ui->doubleSpinBoxY->setRange(0, toMM(PaperSize));
     bOk = ui->buttonBox->button(QDialogButtonBox::Ok);
     labelEditNamePoint = ui->labelEditName;
     flagName = false;
@@ -35,27 +36,33 @@ DialogSinglePoint::DialogSinglePoint(const VContainer *data, QWidget *parent) :
     connect(bOk, &QPushButton::clicked, this, &DialogSinglePoint::DialogAccepted);
     QPushButton *bCansel = ui->buttonBox->button(QDialogButtonBox::Cancel);
     connect(bCansel, &QPushButton::clicked, this, &DialogSinglePoint::DialogRejected);
-    connect(ui->lineEditName,&QLineEdit::textChanged, this, &DialogSinglePoint::NamePointChanged);
+    connect(ui->lineEditName, &QLineEdit::textChanged, this, &DialogSinglePoint::NamePointChanged);
 }
 
-void DialogSinglePoint::mousePress(QPointF scenePos){
-    if(isInitialized == false){
+void DialogSinglePoint::mousePress(QPointF scenePos)
+{
+    if (isInitialized == false)
+    {
         ui->doubleSpinBoxX->setValue(toMM(scenePos.x()));
         ui->doubleSpinBoxY->setValue(toMM(scenePos.y()));
         this->show();
-    } else {
+    }
+    else
+    {
         ui->doubleSpinBoxX->setValue(toMM(scenePos.x()));
         ui->doubleSpinBoxY->setValue(toMM(scenePos.y()));
     }
 }
 
-void DialogSinglePoint::DialogAccepted(){
+void DialogSinglePoint::DialogAccepted()
+{
     point = QPointF(toPixel(ui->doubleSpinBoxX->value()), toPixel(ui->doubleSpinBoxY->value()));
     name = ui->lineEditName->text();
     emit DialogClosed(QDialog::Accepted);
 }
 
-void DialogSinglePoint::setData(const QString name, const QPointF point){
+void DialogSinglePoint::setData(const QString name, const QPointF point)
+{
     this->name = name;
     this->point = point;
     isInitialized = true;
@@ -64,7 +71,7 @@ void DialogSinglePoint::setData(const QString name, const QPointF point){
     ui->doubleSpinBoxY->setValue(toMM(point.y()));
 }
 
-DialogSinglePoint::~DialogSinglePoint(){
+DialogSinglePoint::~DialogSinglePoint()
+{
     delete ui;
 }
-
diff --git a/dialogs/dialogsinglepoint.h b/dialogs/dialogsinglepoint.h
index 3a4d1b860..48adcf8a9 100644
--- a/dialogs/dialogsinglepoint.h
+++ b/dialogs/dialogsinglepoint.h
@@ -24,12 +24,14 @@
 
 #include "dialogtool.h"
 
-namespace Ui {
-class DialogSinglePoint;
+namespace Ui
+{
+    class DialogSinglePoint;
 }
 
-class DialogSinglePoint : public DialogTool{
-    Q_OBJECT 
+class DialogSinglePoint : public DialogTool
+{
+    Q_OBJECT
 public:
                    DialogSinglePoint(const VContainer *data, QWidget *parent = 0);
     void           setData(const QString name, const QPointF point);
diff --git a/dialogs/dialogspline.cpp b/dialogs/dialogspline.cpp
index 08f8f331b..16baab710 100644
--- a/dialogs/dialogspline.cpp
+++ b/dialogs/dialogspline.cpp
@@ -22,58 +22,74 @@
 #include "dialogspline.h"
 #include "ui_dialogspline.h"
 
-DialogSpline::DialogSpline(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(new Ui::DialogSpline), number(0), p1(0), p4(0), angle1(0), angle2(0),
-    kAsm1(1), kAsm2(1), kCurve(1){
+DialogSpline::DialogSpline(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(new Ui::DialogSpline), number(0), p1(0), p4(0), angle1(0), angle2(0),
+    kAsm1(1), kAsm2(1), kCurve(1)
+{
     ui->setupUi(this);
     bOk = ui->buttonBox->button(QDialogButtonBox::Ok);
     connect(bOk, &QPushButton::clicked, this, &DialogSpline::DialogAccepted);
 
     QPushButton *bCansel = ui->buttonBox->button(QDialogButtonBox::Cancel);
     connect(bCansel, &QPushButton::clicked, this, &DialogSpline::DialogRejected);
-    if(mode == Draw::Calculation){
+    if (mode == Draw::Calculation)
+    {
         FillComboBoxPoints(ui->comboBoxP1);
         FillComboBoxPoints(ui->comboBoxP4);
     }
 }
 
-DialogSpline::~DialogSpline(){
+DialogSpline::~DialogSpline()
+{
     delete ui;
 }
 
-void DialogSpline::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogSpline::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             FillComboBoxPoints(ui->comboBoxP1);
             FillComboBoxPoints(ui->comboBoxP4);
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id) == false)
+        {
             return;
         }
     }
-    if(type == Scene::Point){
+    if (type == Scene::Point)
+    {
         VPointF point;
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             point = data->GetPoint(id);
-        } else {
+        }
+        else
+        {
             point = data->GetModelingPoint(id);
         }
-        if(number == 0){
+        if (number == 0)
+        {
             qint32 index = ui->comboBoxP1->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxP1->setCurrentIndex(index);
                 number++;
                 emit ToolTip(tr("Select last point of curve"));
                 return;
             }
         }
-        if(number == 1){
+        if (number == 1)
+        {
             qint32 index = ui->comboBoxP4->findText(point.name());
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 ui->comboBoxP4->setCurrentIndex(index);
                 number = 0;
                 emit ToolTip("");
@@ -81,24 +97,29 @@ void DialogSpline::ChoosedObject(qint64 id, Scene::Scenes type){
                 qint64 p1Id = qvariant_cast<qint64>(ui->comboBoxP1->itemData(index));
                 QPointF p1;
                 QPointF p4;
-                if(mode == Draw::Calculation){
+                if (mode == Draw::Calculation)
+                {
                     p1 = data->GetPoint(p1Id).toQPointF();
                     p4 = data->GetPoint(id).toQPointF();
-                } else {
+                }
+                else
+                {
                     p1 = data->GetModelingPoint(p1Id).toQPointF();
                     p4 = data->GetModelingPoint(id).toQPointF();
                 }
                 ui->spinBoxAngle1->setValue(static_cast<qint32>(QLineF(p1, p4).angle()));
                 ui->spinBoxAngle2->setValue(static_cast<qint32>(QLineF(p4, p1).angle()));
             }
-            if(!isInitialized){
+            if (isInitialized == false)
+            {
                 this->show();
             }
         }
     }
 }
 
-void DialogSpline::DialogAccepted(){
+void DialogSpline::DialogAccepted()
+{
     p1 = getCurrentPointId(ui->comboBoxP1);
     p4 = getCurrentPointId(ui->comboBoxP4);
     angle1 = ui->spinBoxAngle1->value();
@@ -109,37 +130,44 @@ void DialogSpline::DialogAccepted(){
     emit DialogClosed(QDialog::Accepted);
 }
 
-void DialogSpline::setKCurve(const qreal &value){
+void DialogSpline::setKCurve(const qreal &value)
+{
     kCurve = value;
     ui->doubleSpinBoxKcurve->setValue(value);
 }
 
-void DialogSpline::setKAsm2(const qreal &value){
+void DialogSpline::setKAsm2(const qreal &value)
+{
     kAsm2 = value;
     ui->doubleSpinBoxKasm2->setValue(value);
 }
 
-void DialogSpline::setKAsm1(const qreal &value){
+void DialogSpline::setKAsm1(const qreal &value)
+{
     kAsm1 = value;
     ui->doubleSpinBoxKasm1->setValue(value);
 }
 
-void DialogSpline::setAngle2(const qreal &value){
+void DialogSpline::setAngle2(const qreal &value)
+{
     angle2 = value;
     ui->spinBoxAngle2->setValue(static_cast<qint32>(value));
 }
 
-void DialogSpline::setAngle1(const qreal &value){
+void DialogSpline::setAngle1(const qreal &value)
+{
     angle1 = value;
     ui->spinBoxAngle1->setValue(static_cast<qint32>(value));
 }
 
-void DialogSpline::setP4(const qint64 &value){
+void DialogSpline::setP4(const qint64 &value)
+{
     p4 = value;
     ChangeCurrentData(ui->comboBoxP4, value);
 }
 
-void DialogSpline::setP1(const qint64 &value){
+void DialogSpline::setP1(const qint64 &value)
+{
     p1 = value;
     ChangeCurrentData(ui->comboBoxP1, value);
 }
diff --git a/dialogs/dialogspline.h b/dialogs/dialogspline.h
index 310a679dc..bcb69ce87 100644
--- a/dialogs/dialogspline.h
+++ b/dialogs/dialogspline.h
@@ -24,15 +24,16 @@
 
 #include "dialogtool.h"
 
-namespace Ui {
-class DialogSpline;
+namespace Ui
+{
+    class DialogSpline;
 }
 
-class DialogSpline : public DialogTool{
-    Q_OBJECT  
+class DialogSpline : public DialogTool
+{
+    Q_OBJECT
 public:
-    explicit      DialogSpline(const VContainer *data, Draw::Draws mode = Draw::Calculation,
-                               QWidget *parent = 0);
+                  DialogSpline(const VContainer *data, Draw::Draws mode = Draw::Calculation, QWidget *parent = 0);
                   ~DialogSpline();
     inline qint64 getP1() const {return p1;}
     void          setP1(const qint64 &value);
@@ -55,10 +56,10 @@ private:
     Q_DISABLE_COPY(DialogSpline)
     Ui::DialogSpline *ui;
     qint32        number;
-    qint64        p1;			// перша точка
-    qint64        p4;			// четверта точка
-    qreal         angle1;		// кут нахилу дотичної в першій точці
-    qreal         angle2;		// кут нахилу дотичної в другій точці
+    qint64        p1;           // перша точка
+    qint64        p4;           // четверта точка
+    qreal         angle1;       // кут нахилу дотичної в першій точці
+    qreal         angle2;       // кут нахилу дотичної в другій точці
     qreal         kAsm1;
     qreal         kAsm2;
     qreal         kCurve;
diff --git a/dialogs/dialogsplinepath.cpp b/dialogs/dialogsplinepath.cpp
index e3d45bdd0..d671ef182 100644
--- a/dialogs/dialogsplinepath.cpp
+++ b/dialogs/dialogsplinepath.cpp
@@ -23,8 +23,9 @@
 #include "ui_dialogsplinepath.h"
 #include "geometry/vsplinepoint.h"
 
-DialogSplinePath::DialogSplinePath(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(new Ui::DialogSplinePath), path(VSplinePath()){
+DialogSplinePath::DialogSplinePath(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(new Ui::DialogSplinePath), path(VSplinePath())
+{
     ui->setupUi(this);
     bOk = ui->buttonBox->button(QDialogButtonBox::Ok);
     connect(bOk, &QPushButton::clicked, this, &DialogSplinePath::DialogAccepted);
@@ -48,14 +49,17 @@ DialogSplinePath::DialogSplinePath(const VContainer *data, Draw::Draws mode, QWi
             this, &DialogSplinePath::KAsm2Changed);
 }
 
-DialogSplinePath::~DialogSplinePath(){
+DialogSplinePath::~DialogSplinePath()
+{
     delete ui;
 }
 
-void DialogSplinePath::SetPath(const VSplinePath &value){
+void DialogSplinePath::SetPath(const VSplinePath &value)
+{
     this->path = value;
-    ui->listWidget->clear();   
-    for(qint32 i = 0; i < path.CountPoint(); ++i){
+    ui->listWidget->clear();
+    for (qint32 i = 0; i < path.CountPoint(); ++i)
+    {
         NewItem(path[i].P(), path[i].KAsm1(), path[i].Angle2(), path[i].KAsm2());
     }
     ui->listWidget->setFocus(Qt::OtherFocusReason);
@@ -63,28 +67,36 @@ void DialogSplinePath::SetPath(const VSplinePath &value){
 }
 
 
-void DialogSplinePath::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogSplinePath::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id) == false)
+        {
             return;
         }
     }
-    if(type == Scene::Point){
+    if (type == Scene::Point)
+    {
         NewItem(id, 1, 0, 1);
         emit ToolTip(tr("Select point of curve path"));
         this->show();
     }
 }
 
-void DialogSplinePath::DialogAccepted(){
+void DialogSplinePath::DialogAccepted()
+{
     path.Clear();
-    for(qint32 i = 0; i < ui->listWidget->count(); ++i){
+    for (qint32 i = 0; i < ui->listWidget->count(); ++i)
+    {
         QListWidgetItem *item = ui->listWidget->item(i);
         path.append( qvariant_cast<VSplinePoint>(item->data(Qt::UserRole)));
     }
@@ -93,8 +105,10 @@ void DialogSplinePath::DialogAccepted(){
     emit DialogClosed(QDialog::Accepted);
 }
 
-void DialogSplinePath::PointChenged(int row){
-    if(ui->listWidget->count() == 0){
+void DialogSplinePath::PointChenged(int row)
+{
+    if (ui->listWidget->count() == 0)
+    {
         return;
     }
     QListWidgetItem *item = ui->listWidget->item( row );
@@ -103,7 +117,8 @@ void DialogSplinePath::PointChenged(int row){
     EnableFields();
 }
 
-void DialogSplinePath::currentPointChanged(int index){
+void DialogSplinePath::currentPointChanged(int index)
+{
     qint64 id = qvariant_cast<qint64>(ui->comboBoxPoint->itemData(index));
     qint32 row = ui->listWidget->currentRow();
     QListWidgetItem *item = ui->listWidget->item( row );
@@ -114,15 +129,18 @@ void DialogSplinePath::currentPointChanged(int index){
     item->setData(Qt::UserRole, QVariant::fromValue(p));
 }
 
-void DialogSplinePath::Angle1Changed(int index){
+void DialogSplinePath::Angle1Changed(int index)
+{
     SetAngle(index+180);
 }
 
-void DialogSplinePath::Angle2Changed(int index){
+void DialogSplinePath::Angle2Changed(int index)
+{
     SetAngle(index);
 }
 
-void DialogSplinePath::KAsm1Changed(qreal d){
+void DialogSplinePath::KAsm1Changed(qreal d)
+{
     qint32 row = ui->listWidget->currentRow();
     QListWidgetItem *item = ui->listWidget->item( row );
     VSplinePoint p = qvariant_cast<VSplinePoint>(item->data(Qt::UserRole));
@@ -130,7 +148,8 @@ void DialogSplinePath::KAsm1Changed(qreal d){
     item->setData(Qt::UserRole, QVariant::fromValue(p));
 }
 
-void DialogSplinePath::KAsm2Changed(qreal d){
+void DialogSplinePath::KAsm2Changed(qreal d)
+{
     qint32 row = ui->listWidget->currentRow();
     QListWidgetItem *item = ui->listWidget->item( row );
     VSplinePoint p = qvariant_cast<VSplinePoint>(item->data(Qt::UserRole));
@@ -138,11 +157,15 @@ void DialogSplinePath::KAsm2Changed(qreal d){
     item->setData(Qt::UserRole, QVariant::fromValue(p));
 }
 
-void DialogSplinePath::NewItem(qint64 id, qreal kAsm1, qreal angle, qreal kAsm2){
+void DialogSplinePath::NewItem(qint64 id, qreal kAsm1, qreal angle, qreal kAsm2)
+{
     VPointF point;
-    if(mode == Draw::Calculation){
+    if (mode == Draw::Calculation)
+    {
         point = data->GetPoint(id);
-    } else {
+    }
+    else
+    {
         point = data->GetModelingPoint(id);
     }
     QListWidgetItem *item = new QListWidgetItem(point.name());
@@ -154,7 +177,8 @@ void DialogSplinePath::NewItem(qint64 id, qreal kAsm1, qreal angle, qreal kAsm2)
     EnableFields();
 }
 
-void DialogSplinePath::DataPoint(qint64 id, qreal kAsm1, qreal angle1, qreal kAsm2, qreal angle2){
+void DialogSplinePath::DataPoint(qint64 id, qreal kAsm1, qreal angle1, qreal kAsm2, qreal angle2)
+{
     disconnect(ui->comboBoxPoint,  static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
                this, &DialogSplinePath::currentPointChanged);
     disconnect(ui->spinBoxAngle1,  static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged),
@@ -184,25 +208,29 @@ void DialogSplinePath::DataPoint(qint64 id, qreal kAsm1, qreal angle1, qreal kAs
             this, &DialogSplinePath::KAsm2Changed);
 }
 
-void DialogSplinePath::EnableFields(){
+void DialogSplinePath::EnableFields()
+{
     ui->doubleSpinBoxKasm1->setEnabled(true);
     ui->spinBoxAngle1->setEnabled(true);
     ui->doubleSpinBoxKasm2->setEnabled(true);
     ui->spinBoxAngle2->setEnabled(true);
     qint32 row = ui->listWidget->currentRow();
-    if(row == 0){
+    if (row == 0)
+    {
         ui->doubleSpinBoxKasm1->setEnabled(false);
         ui->spinBoxAngle1->setEnabled(false);
         return;
     }
-    if(row == ui->listWidget->count()-1){
+    if (row == ui->listWidget->count()-1)
+    {
         ui->doubleSpinBoxKasm2->setEnabled(false);
         ui->spinBoxAngle2->setEnabled(false);
         return;
     }
 }
 
-void DialogSplinePath::SetAngle(qint32 angle){
+void DialogSplinePath::SetAngle(qint32 angle)
+{
     qint32 row = ui->listWidget->currentRow();
     QListWidgetItem *item = ui->listWidget->item( row );
     VSplinePoint p = qvariant_cast<VSplinePoint>(item->data(Qt::UserRole));
diff --git a/dialogs/dialogsplinepath.h b/dialogs/dialogsplinepath.h
index 922351a31..394e79356 100644
--- a/dialogs/dialogsplinepath.h
+++ b/dialogs/dialogsplinepath.h
@@ -25,11 +25,13 @@
 #include "dialogtool.h"
 #include "geometry/vsplinepath.h"
 
-namespace Ui {
-class DialogSplinePath;
+namespace Ui
+{
+    class DialogSplinePath;
 }
 
-class DialogSplinePath : public DialogTool{
+class DialogSplinePath : public DialogTool
+{
     Q_OBJECT
 public:
                        DialogSplinePath(const VContainer *data, Draw::Draws mode = Draw::Calculation,
diff --git a/dialogs/dialogtool.cpp b/dialogs/dialogtool.cpp
index c527cb383..3f3e0133a 100644
--- a/dialogs/dialogtool.cpp
+++ b/dialogs/dialogtool.cpp
@@ -22,60 +22,76 @@
 #include "dialogtool.h"
 #include <container/calculator.h>
 
-DialogTool::DialogTool(const VContainer *data, Draw::Draws mode, QWidget *parent):QDialog(parent), data(data),
-    isInitialized(false), flagName(true), flagFormula(true), timerFormula(0), bOk(0), spinBoxAngle(0),
-    lineEditFormula(0), listWidget(0), labelResultCalculation(0), labelDescription(0), labelEditNamePoint(0),
-    labelEditFormula(0), radioButtonSizeGrowth(0), radioButtonStandartTable(0), radioButtonIncrements(0),
-    radioButtonLengthLine(0), radioButtonLengthArc(0), radioButtonLengthCurve(0), idDetail(0), mode(mode){
+DialogTool::DialogTool(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :QDialog(parent), data(data), isInitialized(false), flagName(true), flagFormula(true), timerFormula(0), bOk(0),
+      spinBoxAngle(0), lineEditFormula(0), listWidget(0), labelResultCalculation(0), labelDescription(0),
+      labelEditNamePoint(0), labelEditFormula(0), radioButtonSizeGrowth(0), radioButtonStandartTable(0),
+      radioButtonIncrements(0), radioButtonLengthLine(0), radioButtonLengthArc(0), radioButtonLengthCurve(0),
+      idDetail(0), mode(mode)
+{
     Q_ASSERT(data != 0);
     timerFormula = new QTimer(this);
     connect(timerFormula, &QTimer::timeout, this, &DialogTool::EvalFormula);
 }
 
-void DialogTool::closeEvent(QCloseEvent *event){
+void DialogTool::closeEvent(QCloseEvent *event)
+{
     DialogClosed(QDialog::Rejected);
     event->accept();
 }
 
-void DialogTool::showEvent(QShowEvent *event){
+void DialogTool::showEvent(QShowEvent *event)
+{
     QDialog::showEvent( event );
-    if( event->spontaneous() ){
+    if ( event->spontaneous() )
+    {
         return;
     }
-    if(isInitialized){
+    if (isInitialized)
+    {
         return;
     }
     isInitialized = true;//first show windows are held
 }
 
-void DialogTool::FillComboBoxPoints(QComboBox *box, const qint64 &id) const{
+void DialogTool::FillComboBoxPoints(QComboBox *box, const qint64 &id) const
+{
     box->clear();
-    if(mode == Draw::Calculation){
+    if (mode == Draw::Calculation)
+    {
         const QHash<qint64, VPointF> *points = data->DataPoints();
         QHashIterator<qint64, VPointF> i(*points);
-        while (i.hasNext()) {
+        while (i.hasNext())
+        {
             i.next();
-            if(i.key() != id){
+            if (i.key() != id)
+            {
                 VPointF point = i.value();
                 box->addItem(point.name(), i.key());
             }
         }
-    } else {
-        if(idDetail <= 0){
+    }
+    else
+    {
+        if (idDetail <= 0)
+        {
             qWarning()<<tr("Wrong details id.")<<Q_FUNC_INFO;
             return;
         }
         VDetail det = data->GetDetail(idDetail);
-        for(qint32 i = 0; i< det.CountNode(); ++i){
-            if(det[i].getTypeTool() == Tool::NodePoint ||
-               det[i].getTypeTool() == Tool::AlongLineTool ||
-               det[i].getTypeTool() == Tool::BisectorTool ||
-               det[i].getTypeTool() == Tool::EndLineTool ||
-               det[i].getTypeTool() == Tool::LineIntersectTool ||
-               det[i].getTypeTool() == Tool::NormalTool ||
-               det[i].getTypeTool() == Tool::PointOfContact ||
-               det[i].getTypeTool() == Tool::ShoulderPointTool){
-                if(det[i].getId() != id){
+        for (qint32 i = 0; i< det.CountNode(); ++i)
+        {
+            if (det[i].getTypeTool() == Tool::NodePoint ||
+                det[i].getTypeTool() == Tool::AlongLineTool ||
+                det[i].getTypeTool() == Tool::BisectorTool ||
+                det[i].getTypeTool() == Tool::EndLineTool ||
+                det[i].getTypeTool() == Tool::LineIntersectTool ||
+                det[i].getTypeTool() == Tool::NormalTool ||
+                det[i].getTypeTool() == Tool::PointOfContact ||
+                det[i].getTypeTool() == Tool::ShoulderPointTool)
+            {
+                if (det[i].getId() != id)
+                {
                     VPointF point = data->GetModelingPoint(det[i].getId());
                     box->addItem(point.name(), det[i].getId());
                 }
@@ -84,53 +100,70 @@ void DialogTool::FillComboBoxPoints(QComboBox *box, const qint64 &id) const{
     }
 }
 
-void DialogTool::FillComboBoxTypeLine(QComboBox *box) const{
+void DialogTool::FillComboBoxTypeLine(QComboBox *box) const
+{
     Q_ASSERT(box != 0);
     QStringList list;
     list<<tr("Line")<<tr("No line");
     box->addItems(list);
 }
 
-QString DialogTool::GetTypeLine(const QComboBox *box) const{
-    if(box->currentText()==tr("Line")){
+QString DialogTool::GetTypeLine(const QComboBox *box) const
+{
+    if (box->currentText()==tr("Line"))
+    {
         return QString("hair");
-    } else {
+    }
+    else
+    {
         return QString("none");
     }
 }
 
-void DialogTool::SetupTypeLine(QComboBox *box, const QString &value){
-    if(value == "hair"){
+void DialogTool::SetupTypeLine(QComboBox *box, const QString &value)
+{
+    if (value == "hair")
+    {
         qint32 index = box->findText(tr("Line"));
-        if(index != -1){
+        if (index != -1)
+        {
             box->setCurrentIndex(index);
         }
     }
-    if(value == "none"){
+    if (value == "none")
+    {
         qint32 index = box->findText(tr("No line"));
-        if(index != -1){
+        if (index != -1)
+        {
             box->setCurrentIndex(index);
         }
     }
 }
 
-void DialogTool::ChangeCurrentText(QComboBox *box, const QString &value){
+void DialogTool::ChangeCurrentText(QComboBox *box, const QString &value)
+{
     qint32 index = box->findText(value);
-    if(index != -1){
+    if (index != -1)
+    {
         box->setCurrentIndex(index);
-    } else {
+    }
+    else
+    {
         qWarning()<<tr("Can't find point by name")<<value;
     }
 }
 
-void DialogTool::ChangeCurrentData(QComboBox *box, const qint64 &value) const{
+void DialogTool::ChangeCurrentData(QComboBox *box, const qint64 &value) const
+{
     qint32 index = box->findData(value);
-    if(index != -1){
+    if (index != -1)
+    {
         box->setCurrentIndex(index);
     }
 }
 
-void DialogTool::PutValHere(QLineEdit *lineEdit, QListWidget *listWidget){
+void DialogTool::PutValHere(QLineEdit *lineEdit, QListWidget *listWidget)
+{
     Q_ASSERT(lineEdit != 0);
     Q_ASSERT(listWidget != 0);
     QListWidgetItem *item = listWidget->currentItem();
@@ -140,11 +173,13 @@ void DialogTool::PutValHere(QLineEdit *lineEdit, QListWidget *listWidget){
     lineEdit->setCursorPosition(pos + item->text().size());
 }
 
-void DialogTool::ValFormulaChanged(bool &flag, QLineEdit *edit, QTimer *timer){
+void DialogTool::ValFormulaChanged(bool &flag, QLineEdit *edit, QTimer *timer)
+{
     Q_ASSERT(edit != 0);
     Q_ASSERT(timer != 0);
     Q_ASSERT(labelEditFormula != 0);
-    if(edit->text().isEmpty()){
+    if (edit->text().isEmpty())
+    {
         flag = false;
         CheckState();
         QPalette palette = labelEditFormula->palette();
@@ -155,27 +190,34 @@ void DialogTool::ValFormulaChanged(bool &flag, QLineEdit *edit, QTimer *timer){
     timer->start(1000);
 }
 
-void DialogTool::Eval(QLineEdit *edit, bool &flag, QTimer *timer, QLabel *label){
+void DialogTool::Eval(QLineEdit *edit, bool &flag, QTimer *timer, QLabel *label)
+{
     Q_ASSERT(edit != 0);
     Q_ASSERT(timer != 0);
     Q_ASSERT(label != 0);
     Q_ASSERT(labelEditFormula != 0);
     QPalette palette = labelEditFormula->palette();
-    if(edit->text().isEmpty()){
+    if (edit->text().isEmpty())
+    {
         flag = false;
         palette.setColor(labelEditFormula->foregroundRole(), Qt::red);
-    } else {
+    }
+    else
+    {
         Calculator cal(data);
         QString errorMsg;
-        qreal result = cal.eval(edit->text(),&errorMsg);
-        if(!errorMsg.isEmpty()){
+        qreal result = cal.eval(edit->text(), &errorMsg);
+        if (errorMsg.isEmpty() == false)
+        {
             label->setText(tr("Error"));
             flag = false;
             palette.setColor(labelEditFormula->foregroundRole(), Qt::red);
-        } else {
+        }
+        else
+        {
             label->setText(QString().setNum(result));
             flag = true;
-            palette.setColor(labelEditFormula->foregroundRole(), QColor(76,76,76));
+            palette.setColor(labelEditFormula->foregroundRole(), QColor(76, 76, 76));
         }
     }
     CheckState();
@@ -183,145 +225,177 @@ void DialogTool::Eval(QLineEdit *edit, bool &flag, QTimer *timer, QLabel *label)
     labelEditFormula->setPalette(palette);
 }
 
-void DialogTool::setCurrentPointId(QComboBox *box, qint64 &pointId, const qint64 &value,
-                                   const qint64 &id) const{
+void DialogTool::setCurrentPointId(QComboBox *box, qint64 &pointId, const qint64 &value, const qint64 &id) const
+{
     Q_ASSERT(box != 0);
     FillComboBoxPoints(box, id);
     pointId = value;
     ChangeCurrentData(box, value);
 }
 
-qint64 DialogTool::getCurrentPointId(QComboBox *box) const{
+qint64 DialogTool::getCurrentPointId(QComboBox *box) const
+{
     Q_ASSERT(box != 0);
     qint32 index = box->currentIndex();
     Q_ASSERT(index != -1);
-    if(index != -1){
+    if (index != -1)
+    {
         return qvariant_cast<qint64>(box->itemData(index));
-    } else {
+    }
+    else
+    {
         return -1;
     }
 }
 
-void DialogTool::CheckState(){
+void DialogTool::CheckState()
+{
     Q_ASSERT(bOk != 0);
     bOk->setEnabled(flagFormula && flagName);
 }
 
-void DialogTool::ChoosedObject(qint64 id, Scene::Scenes type){
+void DialogTool::ChoosedObject(qint64 id, Scene::Scenes type)
+{
     Q_UNUSED(id);
     Q_UNUSED(type);
 }
 
-void DialogTool::NamePointChanged(){
+void DialogTool::NamePointChanged()
+{
     Q_ASSERT(labelEditNamePoint != 0);
     QLineEdit* edit = qobject_cast<QLineEdit*>(sender());
-    if (edit){
+    if (edit)
+    {
         QString name = edit->text();
-        if(name.isEmpty() || name.contains(" ")){
+        if (name.isEmpty() || name.contains(" "))
+        {
             flagName = false;
             QPalette palette = labelEditNamePoint->palette();
             palette.setColor(labelEditNamePoint->foregroundRole(), Qt::red);
             labelEditNamePoint->setPalette(palette);
-        } else {
+        }
+        else
+        {
             flagName = true;
             QPalette palette = labelEditNamePoint->palette();
-            palette.setColor(labelEditNamePoint->foregroundRole(), QColor(76,76,76));
+            palette.setColor(labelEditNamePoint->foregroundRole(), QColor(76, 76, 76));
             labelEditNamePoint->setPalette(palette);
         }
     }
     CheckState();
 }
 
-void DialogTool::DialogAccepted(){
+void DialogTool::DialogAccepted()
+{
     emit DialogClosed(QDialog::Accepted);
 }
 
-void DialogTool::DialogRejected(){
+void DialogTool::DialogRejected()
+{
     emit DialogClosed(QDialog::Rejected);
 }
 
-void DialogTool::FormulaChanged(){
+void DialogTool::FormulaChanged()
+{
     QLineEdit* edit = qobject_cast<QLineEdit*>(sender());
-    if(edit){
+    if (edit)
+    {
         ValFormulaChanged(flagFormula, edit, timerFormula);
     }
 }
 
-void DialogTool::ArrowUp(){
+void DialogTool::ArrowUp()
+{
     Q_ASSERT(spinBoxAngle != 0);
     spinBoxAngle->setValue(90);
 }
 
-void DialogTool::ArrowDown(){
+void DialogTool::ArrowDown()
+{
     Q_ASSERT(spinBoxAngle != 0);
     spinBoxAngle->setValue(270);
 }
 
-void DialogTool::ArrowLeft(){
+void DialogTool::ArrowLeft()
+{
     Q_ASSERT(spinBoxAngle != 0);
     spinBoxAngle->setValue(180);
 }
 
-void DialogTool::ArrowRight(){
+void DialogTool::ArrowRight()
+{
     Q_ASSERT(spinBoxAngle != 0);
     spinBoxAngle->setValue(0);
 }
 
-void DialogTool::ArrowLeftUp(){
+void DialogTool::ArrowLeftUp()
+{
     Q_ASSERT(spinBoxAngle != 0);
     spinBoxAngle->setValue(135);
 }
 
-void DialogTool::ArrowLeftDown(){
+void DialogTool::ArrowLeftDown()
+{
     Q_ASSERT(spinBoxAngle != 0);
     spinBoxAngle->setValue(225);
 }
 
-void DialogTool::ArrowRightUp(){
+void DialogTool::ArrowRightUp()
+{
     Q_ASSERT(spinBoxAngle != 0);
     spinBoxAngle->setValue(45);
 }
 
-void DialogTool::ArrowRightDown(){
+void DialogTool::ArrowRightDown()
+{
     Q_ASSERT(spinBoxAngle != 0);
     spinBoxAngle->setValue(315);
 }
 
-void DialogTool::EvalFormula(){
+void DialogTool::EvalFormula()
+{
     Q_ASSERT(lineEditFormula != 0);
     Q_ASSERT(labelResultCalculation != 0);
     Eval(lineEditFormula, flagFormula, timerFormula, labelResultCalculation);
 }
 
-void DialogTool::SizeGrowth(){
+void DialogTool::SizeGrowth()
+{
     ShowVariable(data->DataBase());
 }
 
-void DialogTool::StandartTable(){
+void DialogTool::StandartTable()
+{
     ShowVariable(data->DataStandartTable());
 }
 
-void DialogTool::LengthLines(){
+void DialogTool::LengthLines()
+{
     ShowVariable(data->DataLengthLines());
 }
 
-void DialogTool::LengthArcs(){
+void DialogTool::LengthArcs()
+{
     ShowVariable(data->DataLengthArcs());
 }
 
-void DialogTool::LengthCurves(){
+void DialogTool::LengthCurves()
+{
     ShowVariable(data->DataLengthSplines());
 }
 
-void DialogTool::Increments(){
+void DialogTool::Increments()
+{
     ShowVariable(data->DataIncrementTable());
 }
 
-void DialogTool::PutHere(){
+void DialogTool::PutHere()
+{
     PutValHere(lineEditFormula, listWidget);
 }
 
-void DialogTool::PutVal(QListWidgetItem *item){
+void DialogTool::PutVal(QListWidgetItem *item)
+{
     Q_ASSERT(lineEditFormula != 0);
     Q_ASSERT(item != 0);
     int pos = lineEditFormula->cursorPosition();
@@ -331,7 +405,8 @@ void DialogTool::PutVal(QListWidgetItem *item){
     lineEditFormula->setCursorPosition(pos + item->text().size());
 }
 
-void DialogTool::ValChenged(int row){
+void DialogTool::ValChenged(int row)
+{
     Q_ASSERT(listWidget != 0);
     Q_ASSERT(labelDescription != 0);
     Q_ASSERT(radioButtonSizeGrowth != 0);
@@ -340,48 +415,57 @@ void DialogTool::ValChenged(int row){
     Q_ASSERT(radioButtonLengthLine != 0);
     Q_ASSERT(radioButtonLengthArc != 0);
     Q_ASSERT(radioButtonLengthCurve != 0);
-    if(listWidget->count() == 0){
+    if (listWidget->count() == 0)
+    {
         return;
     }
     QListWidgetItem *item = listWidget->item( row );
-    if(radioButtonSizeGrowth->isChecked()){
-        if(item->text()=="Р"){
+    if (radioButtonSizeGrowth->isChecked())
+    {
+        if (item->text()=="Р")
+        {
             QString desc = QString("%1(%2) - %3").arg(item->text()).arg(data->growth()).arg(tr("Growth"));
             labelDescription->setText(desc);
         }
-        if(item->text()=="Сг"){
+        if (item->text()=="Сг")
+        {
             QString desc = QString("%1(%2) - %3").arg(item->text()).arg(data->size()).arg(tr("Size"));
             labelDescription->setText(desc);
         }
         return;
     }
-    if(radioButtonStandartTable->isChecked()){
+    if (radioButtonStandartTable->isChecked())
+    {
         VStandartTableCell stable = data->GetStandartTableCell(item->text());
         QString desc = QString("%1(%2) - %3").arg(item->text()).arg(data->GetValueStandartTableCell(item->text()))
                 .arg(stable.GetDescription());
         labelDescription->setText(desc);
         return;
     }
-    if(radioButtonIncrements->isChecked()){
+    if (radioButtonIncrements->isChecked())
+    {
         VIncrementTableRow itable = data->GetIncrementTableRow(item->text());
         QString desc = QString("%1(%2) - %3").arg(item->text()).arg(data->GetValueIncrementTableRow(item->text()))
                 .arg(itable.getDescription());
         labelDescription->setText(desc);
         return;
     }
-    if(radioButtonLengthLine->isChecked()){
+    if (radioButtonLengthLine->isChecked())
+    {
         QString desc = QString("%1(%2) - %3").arg(item->text()).arg(data->GetLine(item->text()))
                 .arg(tr("Line length"));
         labelDescription->setText(desc);
         return;
     }
-    if(radioButtonLengthArc->isChecked()){
+    if (radioButtonLengthArc->isChecked())
+    {
         QString desc = QString("%1(%2) - %3").arg(item->text()).arg(data->GetLengthArc(item->text()))
                 .arg(tr("Arc length"));
         labelDescription->setText(desc);
         return;
     }
-    if(radioButtonLengthCurve->isChecked()){
+    if (radioButtonLengthCurve->isChecked())
+    {
         QString desc = QString("%1(%2) - %3").arg(item->text()).arg(data->GetLengthSpline(item->text()))
                 .arg(tr("Curve length"));
         labelDescription->setText(desc);
@@ -389,7 +473,8 @@ void DialogTool::ValChenged(int row){
     }
 }
 
-void DialogTool::UpdateList(){
+void DialogTool::UpdateList()
+{
     Q_ASSERT(radioButtonSizeGrowth != 0);
     Q_ASSERT(radioButtonStandartTable != 0);
     Q_ASSERT(radioButtonIncrements != 0);
@@ -397,28 +482,36 @@ void DialogTool::UpdateList(){
     Q_ASSERT(radioButtonLengthArc != 0);
     Q_ASSERT(radioButtonLengthCurve != 0);
 
-    if(radioButtonSizeGrowth->isChecked()){
+    if (radioButtonSizeGrowth->isChecked())
+    {
         ShowVariable(data->DataBase());
     }
-    if(radioButtonStandartTable->isChecked()){
+    if (radioButtonStandartTable->isChecked())
+    {
         ShowVariable(data->DataStandartTable());
     }
-    if(radioButtonIncrements->isChecked()){
+    if (radioButtonIncrements->isChecked())
+    {
         ShowVariable(data->DataIncrementTable());
     }
-    if(radioButtonLengthLine->isChecked()){
+    if (radioButtonLengthLine->isChecked())
+    {
         ShowVariable(data->DataLengthLines());
     }
-    if(radioButtonLengthArc->isChecked()){
+    if (radioButtonLengthArc->isChecked())
+    {
         ShowVariable(data->DataLengthArcs());
     }
-    if(radioButtonLengthCurve->isChecked()){
+    if (radioButtonLengthCurve->isChecked())
+    {
         ShowVariable(data->DataLengthSplines());
     }
 }
 
-bool DialogTool::CheckObject(const qint64 &id){
-    if(mode == Draw::Calculation || idDetail == 0){
+bool DialogTool::CheckObject(const qint64 &id)
+{
+    if (mode == Draw::Calculation || idDetail == 0)
+    {
         return false;
     }
     VDetail det = data->GetDetail(idDetail);
@@ -426,20 +519,23 @@ bool DialogTool::CheckObject(const qint64 &id){
 }
 
 template <class key, class val>
-void DialogTool::ShowVariable(const QHash<key, val> *var){
+void DialogTool::ShowVariable(const QHash<key, val> *var)
+{
     Q_ASSERT(listWidget != 0);
     disconnect(listWidget, &QListWidget::currentRowChanged, this, &DialogTool::ValChenged);
     listWidget->clear();
 
     QHashIterator<key, val> i(*var);
     QMap<key, val> map;
-    while (i.hasNext()) {
+    while (i.hasNext())
+    {
         i.next();
         map.insert(i.key(), i.value());
     }
 
     QMapIterator<key, val> iMap(map);
-    while (iMap.hasNext()) {
+    while (iMap.hasNext())
+    {
         iMap.next();
         QListWidgetItem *item = new QListWidgetItem(iMap.key());
         item->setFont(QFont("Times", 12, QFont::Bold));
diff --git a/dialogs/dialogtool.h b/dialogs/dialogtool.h
index 02b3d56f6..02eea1fad 100644
--- a/dialogs/dialogtool.h
+++ b/dialogs/dialogtool.h
@@ -25,11 +25,11 @@
 #include <QDialog>
 #include <container/vcontainer.h>
 
-class DialogTool : public QDialog{
+class DialogTool : public QDialog
+{
     Q_OBJECT
 public:
-                     DialogTool(const VContainer *data, Draw::Draws mode = Draw::Calculation,
-                                QWidget *parent = 0);
+                     DialogTool(const VContainer *data, Draw::Draws mode = Draw::Calculation, QWidget *parent = 0);
     virtual          ~DialogTool() {}
     inline qint64    getIdDetail() const {return idDetail;}
     inline void      setIdDetail(const qint64 &value) {idDetail = value;}
diff --git a/dialogs/dialogtriangle.cpp b/dialogs/dialogtriangle.cpp
index c86e3c008..336ddd7cc 100644
--- a/dialogs/dialogtriangle.cpp
+++ b/dialogs/dialogtriangle.cpp
@@ -1,9 +1,10 @@
 #include "dialogtriangle.h"
 #include "ui_dialogtriangle.h"
 
-DialogTriangle::DialogTriangle(const VContainer *data, Draw::Draws mode, QWidget *parent) :
-    DialogTool(data, mode, parent), ui(new Ui::DialogTriangle), number(0), pointName(QString()), axisP1Id(0),
-    axisP2Id(0), firstPointId(0), secondPointId(0){
+DialogTriangle::DialogTriangle(const VContainer *data, Draw::Draws mode, QWidget *parent)
+    :DialogTool(data, mode, parent), ui(new Ui::DialogTriangle), number(0), pointName(QString()), axisP1Id(0),
+    axisP2Id(0), firstPointId(0), secondPointId(0)
+{
     ui->setupUi(this);
     labelEditNamePoint = ui->labelEditNamePoint;
     bOk = ui->buttonBox->button(QDialogButtonBox::Ok);
@@ -19,58 +20,71 @@ DialogTriangle::DialogTriangle(const VContainer *data, Draw::Draws mode, QWidget
     connect(ui->lineEditNamePoint, &QLineEdit::textChanged, this, &DialogTriangle::NamePointChanged);
 }
 
-DialogTriangle::~DialogTriangle(){
+DialogTriangle::~DialogTriangle()
+{
     delete ui;
 }
 
-void DialogTriangle::ChoosedObject(qint64 id, Scene::Scenes type){
-    if(idDetail == 0 && mode == Draw::Modeling){
-        if(type == Scene::Detail){
+void DialogTriangle::ChoosedObject(qint64 id, Scene::Scenes type)
+{
+    if (idDetail == 0 && mode == Draw::Modeling)
+    {
+        if (type == Scene::Detail)
+        {
             idDetail = id;
             return;
         }
     }
-    if(mode == Draw::Modeling){
-        if(!CheckObject(id)){
+    if (mode == Draw::Modeling)
+    {
+        if (CheckObject(id) == false)
+        {
             return;
         }
     }
-    if(type == Scene::Point){
+    if (type == Scene::Point)
+    {
         VPointF point;
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             point = data->GetPoint(id);
-        } else {
+        }
+        else
+        {
             point = data->GetModelingPoint(id);
         }
-        switch(number){
-        case(0):
-            ChangeCurrentText(ui->comboBoxAxisP1, point.name());
-            number++;
-            emit ToolTip(tr("Select second point of axis"));
-            break;
-        case(1):
-            ChangeCurrentText(ui->comboBoxAxisP2, point.name());
-            number++;
-            emit ToolTip(tr("Select first point"));
-            break;
-        case(2):
-            ChangeCurrentText(ui->comboBoxFirstPoint, point.name());
-            number++;
-            emit ToolTip(tr("Select second point"));
-            break;
-        case(3):
-            ChangeCurrentText(ui->comboBoxSecondPoint, point.name());
-            number = 0;
-            emit ToolTip(tr(""));
-            if(!isInitialized){
-                this->show();
-            }
-            break;
+        switch (number)
+        {
+            case (0):
+                ChangeCurrentText(ui->comboBoxAxisP1, point.name());
+                number++;
+                emit ToolTip(tr("Select second point of axis"));
+                break;
+            case (1):
+                ChangeCurrentText(ui->comboBoxAxisP2, point.name());
+                number++;
+                emit ToolTip(tr("Select first point"));
+                break;
+            case (2):
+                ChangeCurrentText(ui->comboBoxFirstPoint, point.name());
+                number++;
+                emit ToolTip(tr("Select second point"));
+                break;
+            case (3):
+                ChangeCurrentText(ui->comboBoxSecondPoint, point.name());
+                number = 0;
+                emit ToolTip(tr(""));
+                if (isInitialized == false)
+                {
+                    this->show();
+                }
+                break;
         }
     }
 }
 
-void DialogTriangle::DialogAccepted(){
+void DialogTriangle::DialogAccepted()
+{
     pointName = ui->lineEditNamePoint->text();
     firstPointId = getCurrentPointId(ui->comboBoxFirstPoint);
     secondPointId = getCurrentPointId(ui->comboBoxSecondPoint);
@@ -79,28 +93,32 @@ void DialogTriangle::DialogAccepted(){
     emit DialogClosed(QDialog::Accepted);
 }
 
-void DialogTriangle::setPointName(const QString &value){
+void DialogTriangle::setPointName(const QString &value)
+{
     pointName = value;
     ui->lineEditNamePoint->setText(pointName);
 }
 
-void DialogTriangle::setSecondPointId(const qint64 &value, const qint64 &id){
+void DialogTriangle::setSecondPointId(const qint64 &value, const qint64 &id)
+{
     secondPointId = value;
     setCurrentPointId(ui->comboBoxSecondPoint, secondPointId, value, id);
 }
 
-void DialogTriangle::setFirstPointId(const qint64 &value, const qint64 &id){
+void DialogTriangle::setFirstPointId(const qint64 &value, const qint64 &id)
+{
     firstPointId = value;
     setCurrentPointId(ui->comboBoxFirstPoint, firstPointId, value, id);
 }
 
-void DialogTriangle::setAxisP2Id(const qint64 &value, const qint64 &id){
+void DialogTriangle::setAxisP2Id(const qint64 &value, const qint64 &id)
+{
     axisP2Id = value;
     setCurrentPointId(ui->comboBoxAxisP2, axisP2Id, value, id);
 }
 
-void DialogTriangle::setAxisP1Id(const qint64 &value, const qint64 &id){
+void DialogTriangle::setAxisP1Id(const qint64 &value, const qint64 &id)
+{
     axisP1Id = value;
     setCurrentPointId(ui->comboBoxAxisP1, axisP1Id, value, id);
 }
-
diff --git a/dialogs/dialogtriangle.h b/dialogs/dialogtriangle.h
index 13b7c0c9d..3c43fc89f 100644
--- a/dialogs/dialogtriangle.h
+++ b/dialogs/dialogtriangle.h
@@ -24,15 +24,16 @@
 
 #include "dialogtool.h"
 
-namespace Ui {
-class DialogTriangle;
+namespace Ui
+{
+    class DialogTriangle;
 }
 
-class DialogTriangle : public DialogTool{
+class DialogTriangle : public DialogTool
+{
     Q_OBJECT
 public:
-                   DialogTriangle(const VContainer *data, Draw::Draws mode = Draw::Calculation,
-                                  QWidget *parent = 0);
+                   DialogTriangle(const VContainer *data, Draw::Draws mode = Draw::Calculation, QWidget *parent = 0);
                    ~DialogTriangle();
     inline qint64  getAxisP1Id() const {return axisP1Id;}
     void           setAxisP1Id(const qint64 &value, const qint64 &id);
diff --git a/exception/vexception.cpp b/exception/vexception.cpp
index a32b8ebde..07aaa4795 100644
--- a/exception/vexception.cpp
+++ b/exception/vexception.cpp
@@ -21,11 +21,13 @@
 
 #include "vexception.h"
 
-VException::VException(const QString &what):QException(), what(what){
-    Q_ASSERT_X(!what.isEmpty(), Q_FUNC_INFO, "Error message is empty");
+VException::VException(const QString &what):QException(), what(what)
+{
+    Q_ASSERT_X(what.isEmpty() == false, Q_FUNC_INFO, "Error message is empty");
 }
 
-QString VException::ErrorMessage() const{
+QString VException::ErrorMessage() const
+{
     QString error = QString("Exception: %1").arg(what);
     return error;
 }
diff --git a/exception/vexception.h b/exception/vexception.h
index 28fa4c037..87b34cfc0 100644
--- a/exception/vexception.h
+++ b/exception/vexception.h
@@ -25,7 +25,8 @@
 
 #include <QException>
 
-class VException : public QException{
+class VException : public QException
+{
 public:
                       VException(const QString &what);
                       VException(const VException &e):what(e.What()){}
diff --git a/exception/vexceptionbadid.cpp b/exception/vexceptionbadid.cpp
index 02bf10a76..f11841124 100644
--- a/exception/vexceptionbadid.cpp
+++ b/exception/vexceptionbadid.cpp
@@ -21,13 +21,16 @@
 
 #include "vexceptionbadid.h"
 
-QString VExceptionBadId::ErrorMessage() const{
+QString VExceptionBadId::ErrorMessage() const
+{
     QString error;
-    if(key.isEmpty()){
+    if (key.isEmpty())
+    {
         error = QString("ExceptionBadId: %1, id = %2").arg(what).arg(id);
-    } else {
+    }
+    else
+    {
         error = QString("ExceptionBadId: %1, id = %2").arg(what).arg(key);
     }
     return error;
 }
-
diff --git a/exception/vexceptionbadid.h b/exception/vexceptionbadid.h
index 89959d5d8..6ddf034c5 100644
--- a/exception/vexceptionbadid.h
+++ b/exception/vexceptionbadid.h
@@ -24,12 +24,15 @@
 
 #include "vexception.h"
 
-class VExceptionBadId : public VException{
+class VExceptionBadId : public VException
+{
 public:
-                    VExceptionBadId(const QString &what, const qint64 &id):VException(what), id(id),
-                        key(QString()){}
-                    VExceptionBadId(const QString &what, const QString &key):VException(what), id(0), key(key){}
-                    VExceptionBadId(const VExceptionBadId &e):VException(e), id(e.BadId()), key(e.BadKey()){}
+                    VExceptionBadId(const QString &what, const qint64 &id)
+                        :VException(what), id(id), key(QString()){}
+                    VExceptionBadId(const QString &what, const QString &key)
+                        :VException(what), id(0), key(key){}
+                    VExceptionBadId(const VExceptionBadId &e)
+                        :VException(e), id(e.BadId()), key(e.BadKey()){}
     virtual         ~VExceptionBadId() noexcept(true){}
     virtual QString ErrorMessage() const;
     inline qint64   BadId() const {return id; }
diff --git a/exception/vexceptionconversionerror.cpp b/exception/vexceptionconversionerror.cpp
index 487d7ad3b..9e53d1a54 100644
--- a/exception/vexceptionconversionerror.cpp
+++ b/exception/vexceptionconversionerror.cpp
@@ -22,11 +22,13 @@
 #include "vexceptionconversionerror.h"
 
 VExceptionConversionError::VExceptionConversionError(const QString &what, const QString &str)
-    :VException(what), str(str){
-    Q_ASSERT_X(!str.isEmpty(), Q_FUNC_INFO, "Error converting string is empty");
+    :VException(what), str(str)
+{
+    Q_ASSERT_X(str.isEmpty() == false, Q_FUNC_INFO, "Error converting string is empty");
 }
 
-QString VExceptionConversionError::ErrorMessage() const{
+QString VExceptionConversionError::ErrorMessage() const
+{
     QString error = QString("ExceptionConversionError: %1 %2").arg(what, str);
     return error;
 }
diff --git a/exception/vexceptionconversionerror.h b/exception/vexceptionconversionerror.h
index 904093e63..bd8313b3d 100644
--- a/exception/vexceptionconversionerror.h
+++ b/exception/vexceptionconversionerror.h
@@ -24,10 +24,12 @@
 
 #include "vexception.h"
 
-class VExceptionConversionError : public VException{
+class VExceptionConversionError : public VException
+{
 public:
                     VExceptionConversionError(const QString &what, const QString &str);
-                    VExceptionConversionError(const VExceptionConversionError &e):VException(e), str(e.String()){}
+                    VExceptionConversionError(const VExceptionConversionError &e)
+                        :VException(e), str(e.String()){}
     virtual         ~VExceptionConversionError() noexcept(true) {}
     virtual QString ErrorMessage() const;
     inline QString  String() const {return str;}
diff --git a/exception/vexceptionemptyparameter.cpp b/exception/vexceptionemptyparameter.cpp
index 31dc1550f..038f98f1d 100644
--- a/exception/vexceptionemptyparameter.cpp
+++ b/exception/vexceptionemptyparameter.cpp
@@ -22,22 +22,25 @@
 #include "vexceptionemptyparameter.h"
 
 VExceptionEmptyParameter::VExceptionEmptyParameter(const QString &what, const QString &name,
-                                                   const QDomElement &domElement): VException(what),
-    name(name), tagText(QString()), tagName(QString()), lineNumber(-1){
-    Q_ASSERT_X(!domElement.isNull(), Q_FUNC_INFO, "domElement is null");
-    Q_ASSERT_X(!name.isEmpty(), Q_FUNC_INFO, "Parameter name is empty");
+                                                   const QDomElement &domElement)
+    : VException(what), name(name), tagText(QString()), tagName(QString()), lineNumber(-1)
+{
+    Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
+    Q_ASSERT_X(name.isEmpty() == false, Q_FUNC_INFO, "Parameter name is empty");
     QTextStream stream(&tagText);
     domElement.save(stream, 4);
     tagName = domElement.tagName();
     lineNumber = domElement.lineNumber();
 }
 
-QString VExceptionEmptyParameter::ErrorMessage() const{
+QString VExceptionEmptyParameter::ErrorMessage() const
+{
     QString error = QString("ExceptionEmptyParameter: %1 %2").arg(what, name);
     return error;
 }
 
-QString VExceptionEmptyParameter::DetailedInformation() const{
+QString VExceptionEmptyParameter::DetailedInformation() const
+{
     QString detail = QString("tag: %1 in line %2\nFull tag:\n%3").arg(tagName).arg(lineNumber).arg(tagText);
     return detail;
 }
diff --git a/exception/vexceptionemptyparameter.h b/exception/vexceptionemptyparameter.h
index f03be1cec..c7fbae985 100644
--- a/exception/vexceptionemptyparameter.h
+++ b/exception/vexceptionemptyparameter.h
@@ -24,12 +24,13 @@
 
 #include "vexception.h"
 
-class VExceptionEmptyParameter : public VException{
+class VExceptionEmptyParameter : public VException
+{
 public:
-                    VExceptionEmptyParameter(const QString &what, const QString &name,
-                                             const QDomElement &domElement);
-                    VExceptionEmptyParameter(const VExceptionEmptyParameter &e):VException(e), name(e.Name()),
-                        tagText(e.TagText()), tagName(e.TagName()), lineNumber(e.LineNumber()){}
+                    VExceptionEmptyParameter(const QString &what, const QString &name, const QDomElement &domElement);
+                    VExceptionEmptyParameter(const VExceptionEmptyParameter &e)
+                        :VException(e), name(e.Name()), tagText(e.TagText()), tagName(e.TagName()),
+                          lineNumber(e.LineNumber()){}
     virtual         ~VExceptionEmptyParameter() noexcept(true) {}
     virtual QString ErrorMessage() const;
     virtual QString DetailedInformation() const;
diff --git a/exception/vexceptionobjecterror.cpp b/exception/vexceptionobjecterror.cpp
index 11d5be2b6..b1dcbfd5c 100644
--- a/exception/vexceptionobjecterror.cpp
+++ b/exception/vexceptionobjecterror.cpp
@@ -22,33 +22,41 @@
 #include "vexceptionobjecterror.h"
 #include <QDebug>
 
-VExceptionObjectError::VExceptionObjectError(const QString &what, const QDomElement &domElement):
-    VException(what), tagText(QString()), tagName(QString()), lineNumber(-1), moreInfo(QString()){
-    Q_ASSERT_X(!domElement.isNull(), Q_FUNC_INFO, "domElement is null");
+VExceptionObjectError::VExceptionObjectError(const QString &what, const QDomElement &domElement)
+    :VException(what), tagText(QString()), tagName(QString()), lineNumber(-1), moreInfo(QString())
+{
+    Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
     QTextStream stream(&tagText);
     domElement.save(stream, 4);
     tagName = domElement.tagName();
     lineNumber = domElement.lineNumber();
 }
 
-QString VExceptionObjectError::ErrorMessage() const{
+QString VExceptionObjectError::ErrorMessage() const
+{
     QString error = QString("ExceptionObjectError: %1").arg(what);
     return error;
 }
 
-QString VExceptionObjectError::DetailedInformation() const{
+QString VExceptionObjectError::DetailedInformation() const
+{
     QString detail;
-    if(!moreInfo.isEmpty()){
+    if (moreInfo.isEmpty() == false)
+    {
         QString i = QString("tag: %1 in line %2\n%3").arg(tagName).arg(lineNumber).arg(tagText);
         detail = QString("%1\n%2").arg(moreInfo, i);
-    } else {
+    }
+    else
+    {
         detail = QString("tag: %1 in line %2\n%3").arg(tagName).arg(lineNumber).arg(tagText);
     }
     return detail;
 }
 
-void VExceptionObjectError::AddMoreInformation(const QString &info){
-    if(info.isEmpty()){
+void VExceptionObjectError::AddMoreInformation(const QString &info)
+{
+    if (info.isEmpty())
+    {
         qWarning()<<"Error additional information is empty."<<Q_FUNC_INFO;
     }
     this->moreInfo.append(info);
diff --git a/exception/vexceptionobjecterror.h b/exception/vexceptionobjecterror.h
index db12bb943..f564347b8 100644
--- a/exception/vexceptionobjecterror.h
+++ b/exception/vexceptionobjecterror.h
@@ -24,11 +24,13 @@
 
 #include "vexception.h"
 
-class VExceptionObjectError : public VException{
+class VExceptionObjectError : public VException
+{
 public:
                     VExceptionObjectError(const QString &what, const QDomElement &domElement);
-                    VExceptionObjectError(const VExceptionObjectError &e):VException(e), tagText(e.TagText()),
-                        tagName(e.TagName()), lineNumber(e.LineNumber()), moreInfo(e.MoreInformation()){}
+                    VExceptionObjectError(const VExceptionObjectError &e)
+                        :VException(e), tagText(e.TagText()), tagName(e.TagName()), lineNumber(e.LineNumber()),
+                          moreInfo(e.MoreInformation()){}
     virtual         ~VExceptionObjectError() noexcept(true) {}
     virtual QString ErrorMessage() const;
     virtual QString DetailedInformation() const;
diff --git a/exception/vexceptionuniqueid.cpp b/exception/vexceptionuniqueid.cpp
index c33fb592d..9f38b31a7 100644
--- a/exception/vexceptionuniqueid.cpp
+++ b/exception/vexceptionuniqueid.cpp
@@ -1,20 +1,23 @@
 #include "vexceptionuniqueid.h"
 
 VExceptionUniqueId::VExceptionUniqueId(const QString &what, const QDomElement &domElement)
-    :VException(what), tagText(QString()), tagName(QString()), lineNumber(-1){
-    Q_ASSERT_X(!domElement.isNull(), Q_FUNC_INFO, "domElement is null");
+    :VException(what), tagText(QString()), tagName(QString()), lineNumber(-1)
+{
+    Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
     QTextStream stream(&tagText);
     domElement.save(stream, 4);
     tagName = domElement.tagName();
     lineNumber = domElement.lineNumber();
 }
 
-QString VExceptionUniqueId::ErrorMessage() const{
+QString VExceptionUniqueId::ErrorMessage() const
+{
     QString error = QString("ExceptionUniqueId: %1").arg(what);
     return error;
 }
 
-QString VExceptionUniqueId::DetailedInformation() const{
+QString VExceptionUniqueId::DetailedInformation() const
+{
     QString detail = QString("tag: %1 in line %2\nFull tag:\n%3").arg(tagName).arg(lineNumber).arg(tagText);
     return detail;
 }
diff --git a/exception/vexceptionuniqueid.h b/exception/vexceptionuniqueid.h
index d2e9cb5bd..bd5b833d1 100644
--- a/exception/vexceptionuniqueid.h
+++ b/exception/vexceptionuniqueid.h
@@ -3,11 +3,12 @@
 
 #include "vexception.h"
 
-class VExceptionUniqueId : public VException{
+class VExceptionUniqueId : public VException
+{
 public:
                     VExceptionUniqueId(const QString &what, const QDomElement &domElement);
-                    VExceptionUniqueId(const VExceptionUniqueId &e):VException(e), tagText(e.TagText()),
-                        tagName(e.TagName()), lineNumber(e.LineNumber()){}
+                    VExceptionUniqueId(const VExceptionUniqueId &e)
+                        :VException(e), tagText(e.TagText()), tagName(e.TagName()), lineNumber(e.LineNumber()){}
     virtual         ~VExceptionUniqueId() noexcept(true){}
     virtual QString ErrorMessage() const;
     virtual QString DetailedInformation() const;
diff --git a/exception/vexceptionwrongparameterid.cpp b/exception/vexceptionwrongparameterid.cpp
index 1ee8d090b..4e10560e3 100644
--- a/exception/vexceptionwrongparameterid.cpp
+++ b/exception/vexceptionwrongparameterid.cpp
@@ -22,21 +22,24 @@
 #include "vexceptionwrongparameterid.h"
 #include <QDebug>
 
-VExceptionWrongParameterId::VExceptionWrongParameterId(const QString &what, const QDomElement &domElement):
-    VException(what), tagText(QString()), tagName(QString()), lineNumber(-1){
-    Q_ASSERT_X(!domElement.isNull(), Q_FUNC_INFO, "domElement is null");
+VExceptionWrongParameterId::VExceptionWrongParameterId(const QString &what, const QDomElement &domElement)
+    :VException(what), tagText(QString()), tagName(QString()), lineNumber(-1)
+{
+    Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
     QTextStream stream(&tagText);
     domElement.save(stream, 4);
     tagName = domElement.tagName();
     lineNumber = domElement.lineNumber();
 }
 
-QString VExceptionWrongParameterId::ErrorMessage() const{
+QString VExceptionWrongParameterId::ErrorMessage() const
+{
     QString error = QString("ExceptionWrongParameterId: %1").arg(what);
     return error;
 }
 
-QString VExceptionWrongParameterId::DetailedInformation() const{
+QString VExceptionWrongParameterId::DetailedInformation() const
+{
     QString detail = QString("tag: %1 in line %2\n%3").arg(tagName).arg(lineNumber).arg(tagText);
     return detail;
 }
diff --git a/exception/vexceptionwrongparameterid.h b/exception/vexceptionwrongparameterid.h
index 6e81fcb43..905f32f11 100644
--- a/exception/vexceptionwrongparameterid.h
+++ b/exception/vexceptionwrongparameterid.h
@@ -24,11 +24,12 @@
 
 #include "vexception.h"
 
-class VExceptionWrongParameterId : public VException{
+class VExceptionWrongParameterId : public VException
+{
 public:
                     VExceptionWrongParameterId(const QString &what, const QDomElement &domElement);
-                    VExceptionWrongParameterId(const VExceptionWrongParameterId &e):VException(e),tagText(e.TagText()),
-                        tagName(e.TagName()), lineNumber(e.LineNumber()){}
+                    VExceptionWrongParameterId(const VExceptionWrongParameterId &e)
+                        :VException(e), tagText(e.TagText()), tagName(e.TagName()), lineNumber(e.LineNumber()){}
     virtual         ~VExceptionWrongParameterId() noexcept(true){}
     virtual QString ErrorMessage() const;
     virtual QString DetailedInformation() const;
diff --git a/geometry/varc.cpp b/geometry/varc.cpp
index cff5c6119..14528dd22 100644
--- a/geometry/varc.cpp
+++ b/geometry/varc.cpp
@@ -22,23 +22,23 @@
 #include "varc.h"
 #include <exception/vexception.h>
 
-VArc::VArc () : f1(0), formulaF1(QString()), f2(0), formulaF2(QString()), radius(0), formulaRadius(QString()),
-    center(0), points(QHash<qint64, VPointF>()), mode(Draw::Calculation), idObject(0){
-}
+VArc::VArc ()
+    : f1(0), formulaF1(QString()), f2(0), formulaF2(QString()), radius(0), formulaRadius(QString()),
+    center(0), points(QHash<qint64, VPointF>()), mode(Draw::Calculation), idObject(0){}
 
 VArc::VArc (const QHash<qint64, VPointF> *points, qint64 center, qreal radius, QString formulaRadius,
             qreal f1, QString formulaF1, qreal f2, QString formulaF2, Draw::Draws mode, qint64 idObject)
     : f1(f1), formulaF1(formulaF1), f2(f2), formulaF2(formulaF2), radius(radius), formulaRadius(formulaRadius),
-      center(center), points(*points), mode(mode), idObject(idObject){
-}
+      center(center), points(*points), mode(mode), idObject(idObject){}
 
-VArc::VArc(const VArc &arc): f1(arc.GetF1()), formulaF1(arc.GetFormulaF1()), f2(arc.GetF2()),
+VArc::VArc(const VArc &arc)
+    : f1(arc.GetF1()), formulaF1(arc.GetFormulaF1()), f2(arc.GetF2()),
     formulaF2(arc.GetFormulaF2()), radius(arc.GetRadius()), formulaRadius(arc.GetFormulaRadius()),
     center(arc.GetCenter()), points(arc.GetDataPoints()), mode(arc.getMode()),
-    idObject(arc.getIdObject()){
-}
+    idObject(arc.getIdObject()){}
 
-VArc &VArc::operator =(const VArc &arc){
+VArc &VArc::operator =(const VArc &arc)
+{
     this->points = arc.GetDataPoints();
     this->f1 = arc.GetF1();
     this->formulaF1 = arc.GetFormulaF1();
@@ -52,35 +52,43 @@ VArc &VArc::operator =(const VArc &arc){
     return *this;
 }
 
-QPointF VArc::GetCenterPoint() const{
-    if(points.contains(center)){
+QPointF VArc::GetCenterPoint() const
+{
+    if (points.contains(center))
+    {
         return points.value(center).toQPointF();
-    } else {
+    }
+    else
+    {
         QString error = QString(tr("Can't find id = %1 in table.")).arg(center);
         throw VException(error);
     }
     return QPointF();
 }
 
-QPointF VArc::GetP1() const{
+QPointF VArc::GetP1() const
+{
     QPointF p1 ( GetCenterPoint().x () + radius, GetCenterPoint().y () );
     QLineF centerP1(GetCenterPoint(), p1);
     centerP1.setAngle(f1);
     return centerP1.p2();
 }
 
-QPointF VArc::GetP2 () const{
+QPointF VArc::GetP2 () const
+{
     QPointF p2 ( GetCenterPoint().x () + radius, GetCenterPoint().y () );
     QLineF centerP2(GetCenterPoint(), p2);
     centerP2.setAngle(f2);
     return centerP2.p2();
 }
 
-const QHash<qint64, VPointF> VArc::GetDataPoints() const{
+const QHash<qint64, VPointF> VArc::GetDataPoints() const
+{
     return points;
 }
 
-QPainterPath VArc::GetPath() const{
+QPainterPath VArc::GetPath() const
+{
     QPainterPath Path;
     QPointF center = GetCenterPoint();
     QRectF rect(center.x()-radius, center.y()-radius, radius*2, radius*2);
@@ -90,74 +98,96 @@ QPainterPath VArc::GetPath() const{
     return Path;
 }
 
-qreal VArc::AngleArc() const{
-    QLineF l1(0,0, 100, 100);
+qreal VArc::AngleArc() const
+{
+    QLineF l1(0, 0, 100, 100);
     l1.setAngle(f1);
-    QLineF l2(0,0, 100, 100);
+    QLineF l2(0, 0, 100, 100);
     l2.setAngle(f2);
     return l1.angleTo(l2);
 }
 
-qint32 VArc::NumberSplOfArc() const{
+qint32 VArc::NumberSplOfArc() const
+{
     qint32 angArc = static_cast<qint32> (AngleArc ());
-    switch( angArc ){
-    case   0:{
-        QString error = QString(tr("Angle of arc can't be 0 degree."));
-        throw VException(error);
-    }
-    case  90:
-        return 1;
-    case 180:
-        return 2;
-    case 270:
-        return 3;
-    case 360:
-        return 4;
-    default :
-        return static_cast<qint32> (AngleArc ( ) / 90 + 1);
+    switch ( angArc )
+    {
+        case 0:
+        {
+            QString error = QString(tr("Angle of arc can't be 0 degree."));
+            throw VException(error);
+        }
+        case 90:
+            return 1;
+        case 180:
+            return 2;
+        case 270:
+            return 3;
+        case 360:
+            return 4;
+        default:
+            return static_cast<qint32> (AngleArc ( ) / 90 + 1);
     }
 }
 
-QVector<QPointF> VArc::GetPoints() const{
+QVector<QPointF> VArc::GetPoints() const
+{
     QVector<QPointF> points;
     qint32 numberSpl =  NumberSplOfArc();
-    for(qint32 i = 1; i <= numberSpl; ++i){
+    for (qint32 i = 1; i <= numberSpl; ++i)
+    {
         points<<SplOfArc ( i );
     }
     return points;
 }
 
-QVector<QPointF> VArc::SplOfArc(qint32 number) const{
+QVector<QPointF> VArc::SplOfArc(qint32 number) const
+{
     qint32 n = NumberSplOfArc ();
-    if( number > n ){
+    if ( number > n )
+    {
         QString error = QString(tr("Arc have not this number of part."));
         throw VException(error);
     }
     qreal f1 = GetF1 ();
     qreal f2 = GetF2 ();
     qint32 i;
-    for ( i = 0; i < n; ++i ){
-        if ( i == n - 1 ){
+    for ( i = 0; i < n; ++i )
+    {
+        if ( i == n - 1 )
+        {
             f2 = GetF2 ();
-        } else {
-            if ( f1 + 90 > 360 ){
+        }
+        else
+        {
+            if ( f1 + 90 > 360 )
+            {
                 f2 = f1 + 90 - 360;
-            } else {
+            }
+            else
+            {
                 f2 = f1 + 90;
             }
         }
         qreal anglF1, anglF2;
-        if ( f1 + 90 > 360 ){
-            anglF1 =  f1 + 90 - 360 ;
-        } else {
-            anglF1 = f1 + 90 ;
+        if ( f1 + 90 > 360 )
+        {
+            anglF1 =  f1 + 90 - 360;
         }
-        if ( f2 - 90 < 0 ){
-            anglF2 = 360 + f2 - 90 ;
-        } else {
-            anglF2 = f2 - 90 ;
+        else
+        {
+            anglF1 = f1 + 90;
         }
-        if ( i + 1 == number ){
+        if ( f2 - 90 < 0 )
+        {
+            anglF2 = 360 + f2 - 90;
+        }
+        else
+        {
+            anglF2 = f2 - 90;
+        }
+        if ( i + 1 == number )
+        {
             f1 = f2;
             return VSpline::SplinePoints(GetP1 (), GetP2 (), anglF1, anglF2, 1., 1., 1.);
         }
diff --git a/geometry/varc.h b/geometry/varc.h
index 1de78e3fd..6f4b4771b 100644
--- a/geometry/varc.h
+++ b/geometry/varc.h
@@ -27,7 +27,8 @@
 /**
  * @brief VArc клас, що реалізує дугу. Дуга розраховується за годиниковою стрілкою.
  */
-class VArc{
+class VArc
+{
     Q_DECLARE_TR_FUNCTIONS(VArc)
 public:
                  /**
@@ -42,7 +43,7 @@ public:
                   * @param f2 кінцевий кут в градусах.
                   */
                        VArc (const QHash<qint64, VPointF> *points, qint64 center, qreal radius, QString formulaRadius,
-                             qreal f1, QString formulaF1, qreal f2 , QString formulaF2,
+                             qreal f1, QString formulaF1, qreal f2, QString formulaF2,
                              Draw::Draws mode = Draw::Calculation, qint64 idObject = 0);
                        VArc(const VArc &arc);
                        VArc& operator= (const VArc &arc);
@@ -103,12 +104,12 @@ private:
     /**
      * @brief f1 початковий кут в градусах
      */
-    qreal              f1;			// початковий кут нахилу дуги (градуси)
+    qreal              f1;          // початковий кут нахилу дуги (градуси)
     QString            formulaF1;
     /**
      * @brief f2 кінцевий кут в градусах
      */
-    qreal              f2;			// кінцевий кут нахилу дуги (градуси)
+    qreal              f2;          // кінцевий кут нахилу дуги (градуси)
     QString            formulaF2;
     /**
      * @brief radius радіус дуги.
diff --git a/geometry/vdetail.cpp b/geometry/vdetail.cpp
index 2b4433444..6bfdf3add 100644
--- a/geometry/vdetail.cpp
+++ b/geometry/vdetail.cpp
@@ -21,20 +21,21 @@
 
 #include "vdetail.h"
 
-VDetail::VDetail():nodes(QVector<VNodeDetail>()),name(QString()), mx(0), my(0), supplement(true), closed(true),
-    width(10){
-}
+VDetail::VDetail()
+    :nodes(QVector<VNodeDetail>()), name(QString()), mx(0), my(0), supplement(true), closed(true), width(10){}
 
-VDetail::VDetail(const QString &name, const QVector<VNodeDetail> &nodes):nodes(QVector<VNodeDetail>()),
-    name(name), mx(0), my(0), supplement(true), closed(true), width(10){
+VDetail::VDetail(const QString &name, const QVector<VNodeDetail> &nodes)
+    :nodes(QVector<VNodeDetail>()), name(name), mx(0), my(0), supplement(true), closed(true), width(10)
+{
     this->nodes = nodes;
 }
 
-VDetail::VDetail(const VDetail &detail):nodes(detail.getNodes()), name(detail.getName()), mx(detail.getMx()),
-    my(detail.getMy()), supplement(detail.getSupplement()), closed(detail.getClosed()), width(detail.getWidth()){
-}
+VDetail::VDetail(const VDetail &detail)
+    :nodes(detail.getNodes()), name(detail.getName()), mx(detail.getMx()), my(detail.getMy()),
+      supplement(detail.getSupplement()), closed(detail.getClosed()), width(detail.getWidth()){}
 
-VDetail &VDetail::operator =(const VDetail &detail){
+VDetail &VDetail::operator =(const VDetail &detail)
+{
     nodes = detail.getNodes();
     name = detail.getName();
     mx = detail.getMx();
@@ -45,7 +46,8 @@ VDetail &VDetail::operator =(const VDetail &detail){
     return *this;
 }
 
-void VDetail::Clear(){
+void VDetail::Clear()
+{
     nodes.clear();
     name.clear();
     mx = 0;
@@ -55,17 +57,20 @@ void VDetail::Clear(){
     width = 10;
 }
 
-bool VDetail::Containes(const qint64 &id) const{
-    for(qint32 i = 0; i < nodes.size(); ++i){
+bool VDetail::Containes(const qint64 &id) const
+{
+    for (qint32 i = 0; i < nodes.size(); ++i)
+    {
         VNodeDetail node = nodes[i];
-        if(node.getId() == id){
+        if (node.getId() == id)
+        {
             return true;
         }
     }
     return false;
 }
 
-VNodeDetail &VDetail::operator [](int indx){
+VNodeDetail &VDetail::operator [](int indx)
+{
     return nodes[indx];
 }
-
diff --git a/geometry/vdetail.h b/geometry/vdetail.h
index f042f93a9..c715ea8da 100644
--- a/geometry/vdetail.h
+++ b/geometry/vdetail.h
@@ -24,7 +24,8 @@
 
 #include "vnodedetail.h"
 
-namespace Detail {
+namespace Detail
+{
     enum Contour { OpenContour, CloseContour };
     Q_DECLARE_FLAGS(Contours, Contour)
 
@@ -34,7 +35,8 @@ namespace Detail {
 Q_DECLARE_OPERATORS_FOR_FLAGS(Detail::Contours)
 Q_DECLARE_OPERATORS_FOR_FLAGS(Detail::Equidistants)
 
-class VDetail{
+class VDetail
+{
 public:
                    VDetail();
                    VDetail(const QString &name, const QVector<VNodeDetail> &nodes);
diff --git a/geometry/vnodedetail.cpp b/geometry/vnodedetail.cpp
index 33a5a1407..a3e62e51f 100644
--- a/geometry/vnodedetail.cpp
+++ b/geometry/vnodedetail.cpp
@@ -21,20 +21,19 @@
 
 #include "vnodedetail.h"
 
-VNodeDetail::VNodeDetail():id(0), typeTool(Tool::NodePoint), mode(Draw::Modeling),
-    typeNode(NodeDetail::Contour), mx(0), my(0){
-}
+VNodeDetail::VNodeDetail()
+    :id(0), typeTool(Tool::NodePoint), mode(Draw::Modeling), typeNode(NodeDetail::Contour), mx(0), my(0){}
 
 VNodeDetail::VNodeDetail(qint64 id, Tool::Tools typeTool, Draw::Draws mode, NodeDetail::NodeDetails typeNode,
-                         qreal mx, qreal my):id(id), typeTool(typeTool), mode(mode), typeNode(typeNode),
-    mx(mx), my(my){
-}
+                         qreal mx, qreal my)
+    :id(id), typeTool(typeTool), mode(mode), typeNode(typeNode), mx(mx), my(my){}
 
-VNodeDetail::VNodeDetail(const VNodeDetail &node):id(node.getId()), typeTool(node.getTypeTool()),
-    mode(node.getMode()), typeNode(node.getTypeNode()), mx(node.getMx()), my(node.getMy()){
-}
+VNodeDetail::VNodeDetail(const VNodeDetail &node)
+    :id(node.getId()), typeTool(node.getTypeTool()), mode(node.getMode()), typeNode(node.getTypeNode()),
+      mx(node.getMx()), my(node.getMy()){}
 
-VNodeDetail &VNodeDetail::operator =(const VNodeDetail &node){
+VNodeDetail &VNodeDetail::operator =(const VNodeDetail &node)
+{
     id = node.getId();
     typeTool = node.getTypeTool();
     mode = node.getMode();
diff --git a/geometry/vnodedetail.h b/geometry/vnodedetail.h
index 1b433aaa9..9735445d4 100644
--- a/geometry/vnodedetail.h
+++ b/geometry/vnodedetail.h
@@ -25,13 +25,15 @@
 #include <QMetaType>
 #include "options.h"
 
-namespace NodeDetail {
+namespace NodeDetail
+{
     enum NodeDetail { Contour, Modeling };
     Q_DECLARE_FLAGS(NodeDetails, NodeDetail)
 }
 Q_DECLARE_OPERATORS_FOR_FLAGS(NodeDetail::NodeDetails)
 
-class VNodeDetail{
+class VNodeDetail
+{
 public:
                   VNodeDetail();
                   VNodeDetail(qint64 id, Tool::Tools typeTool, Draw::Draws mode, NodeDetail::NodeDetails typeNode,
diff --git a/geometry/vspline.cpp b/geometry/vspline.cpp
index 1273a7f30..67ab29023 100644
--- a/geometry/vspline.cpp
+++ b/geometry/vspline.cpp
@@ -21,31 +21,34 @@
 
 #include "vspline.h"
 
-VSpline::VSpline():p1(0), p2(QPointF()), p3(QPointF()), p4(0), angle1(0), angle2(0), kAsm1(1), kAsm2(1),
-    kCurve(1), points(QHash<qint64, VPointF>()), mode(Draw::Calculation), idObject(0){
-}
+VSpline::VSpline()
+    :p1(0), p2(QPointF()), p3(QPointF()), p4(0), angle1(0), angle2(0), kAsm1(1), kAsm2(1), kCurve(1),
+      points(QHash<qint64, VPointF>()), mode(Draw::Calculation), idObject(0){}
 
-VSpline::VSpline ( const VSpline & spline ):p1(spline.GetP1 ()), p2(spline.GetP2 ()), p3(spline.GetP3 ()),
-    p4(spline.GetP4 ()), angle1(spline.GetAngle1 ()), angle2(spline.GetAngle2 ()), kAsm1(spline.GetKasm1()),
-    kAsm2(spline.GetKasm2()), kCurve(spline.GetKcurve()), points(spline.GetDataPoints()),
-    mode(spline.getMode()), idObject(spline.getIdObject()){
-}
+VSpline::VSpline ( const VSpline & spline )
+    :p1(spline.GetP1 ()), p2(spline.GetP2 ()), p3(spline.GetP3 ()), p4(spline.GetP4 ()), angle1(spline.GetAngle1 ()),
+      angle2(spline.GetAngle2 ()), kAsm1(spline.GetKasm1()), kAsm2(spline.GetKasm2()), kCurve(spline.GetKcurve()),
+      points(spline.GetDataPoints()), mode(spline.getMode()), idObject(spline.getIdObject()){}
 
 VSpline::VSpline (const QHash<qint64, VPointF> *points, qint64 p1, qint64 p4, qreal angle1, qreal angle2,
-                  qreal kAsm1, qreal kAsm2 , qreal kCurve, Draw::Draws mode, qint64 idObject):p1(p1), p2(QPointF()),
-    p3(QPointF()), p4(p4), angle1(angle1), angle2(angle2), kAsm1(kAsm1), kAsm2(kAsm2), kCurve(kCurve), points(*points),
-    mode(mode), idObject(idObject){
+                  qreal kAsm1, qreal kAsm2, qreal kCurve, Draw::Draws mode, qint64 idObject)
+    :p1(p1), p2(QPointF()), p3(QPointF()), p4(p4), angle1(angle1), angle2(angle2), kAsm1(kAsm1), kAsm2(kAsm2),
+      kCurve(kCurve), points(*points), mode(mode), idObject(idObject)
+{
     ModifiSpl ( p1, p4, angle1, angle2, kAsm1, kAsm2, kCurve );
 }
 
 VSpline::VSpline (const QHash<qint64, VPointF> *points, qint64 p1, QPointF p2, QPointF p3, qint64 p4,
-                  qreal kCurve, Draw::Draws mode, qint64 idObject):p1(p1), p2(p2), p3(p3), p4(p4), angle1(0),
-    angle2(0), kAsm1(1), kAsm2(1), kCurve(1), points(*points), mode(mode), idObject(idObject){
+                  qreal kCurve, Draw::Draws mode, qint64 idObject)
+    :p1(p1), p2(p2), p3(p3), p4(p4), angle1(0), angle2(0), kAsm1(1), kAsm2(1), kCurve(1), points(*points), mode(mode),
+      idObject(idObject)
+{
     ModifiSpl ( p1, p2, p3, p4, kCurve);
 }
 
 void VSpline::ModifiSpl ( qint64 p1, qint64 p4, qreal angle1, qreal angle2,
-                          qreal kAsm1, qreal kAsm2, qreal kCurve){
+                          qreal kAsm1, qreal kAsm2, qreal kCurve)
+{
     this->p1 = p1;
     this->p4 = p4;
     this->angle1 = angle1;
@@ -62,7 +65,7 @@ void VSpline::ModifiSpl ( qint64 p1, qint64 p4, qreal angle1, qreal angle2,
     //    }
     QPointF point1 = GetPointP1().toQPointF();
     QPointF point4 = GetPointP4().toQPointF();
-    radius = QLineF(QPointF(point1.x(), point4.y()),point4).length();
+    radius = QLineF(QPointF(point1.x(), point4.y()), point4).length();
     //    radius = QLineF(GetPointP1(), GetPointP4()).length() / 2 / sin( angle * M_PI / 180.0 );
     L = kCurve * radius * 4 / 3 * tan( angle * M_PI / 180.0 / 4 );
     QLineF p1p2(GetPointP1().x(), GetPointP1().y(), GetPointP1().x() + L * kAsm1, GetPointP1().y());
@@ -73,7 +76,8 @@ void VSpline::ModifiSpl ( qint64 p1, qint64 p4, qreal angle1, qreal angle2,
     this->p3 = p4p3.p2();
 }
 
-void VSpline::ModifiSpl (qint64 p1, QPointF p2, QPointF p3, qint64 p4, qreal kCurve){
+void VSpline::ModifiSpl (qint64 p1, QPointF p2, QPointF p3, qint64 p4, qreal kCurve)
+{
     this->p1 = p1;
     this->p2 = p2;
     this->p3 = p3;
@@ -90,7 +94,7 @@ void VSpline::ModifiSpl (qint64 p1, QPointF p2, QPointF p3, qint64 p4, qreal kCu
     //    }
     QPointF point1 = GetPointP1().toQPointF();
     QPointF point4 = GetPointP4().toQPointF();
-    radius = QLineF(QPointF(point1.x(), point4.y()),point4).length();
+    radius = QLineF(QPointF(point1.x(), point4.y()), point4).length();
     //    radius = QLineF(GetPointP1(), GetPointP4()).length() / 2 / sin( angle * M_PI / 180.0 );
     L = kCurve * radius * 4 / 3 * tan( angle * M_PI / 180.0 / 4 );
 
@@ -123,37 +127,48 @@ void VSpline::ModifiSpl (qint64 p1, QPointF p2, QPointF p3, qint64 p4, qreal kCu
 //    p4 = QPointF(p4.x()+mx, p4.y()+my);
 //}
 
-VPointF VSpline::GetPointP1() const{
-    if(points.contains(p1)){
+VPointF VSpline::GetPointP1() const
+{
+    if (points.contains(p1))
+    {
         return points.value(p1);
-    } else {
+    }
+    else
+    {
         qCritical()<<"Не можу знайти id = "<<p1<<" в таблиці.";
-        throw"Не можу знайти точку за id.";
+        throw "Не можу знайти точку за id.";
     }
     return VPointF();
 }
 
-VPointF VSpline::GetPointP4() const{
-    if(points.contains(p4)){
+VPointF VSpline::GetPointP4() const
+{
+    if (points.contains(p4))
+    {
         return points.value(p4);
-    } else {
+    }
+    else
+    {
         qCritical()<<"Не можу знайти id = "<<p4<<" в таблиці.";
-        throw"Не можу знайти точку за id.";
+        throw "Не можу знайти точку за id.";
     }
     return VPointF();
 }
 
-qreal VSpline::GetLength () const{
+qreal VSpline::GetLength () const
+{
     return LengthBezier ( GetPointP1().toQPointF(), this->p2, this->p3, GetPointP4().toQPointF());
 }
 
-QString VSpline::GetName() const{
+QString VSpline::GetName() const
+{
     VPointF first = GetPointP1();
     VPointF second = GetPointP4();
     return QString("Spl_%1_%2").arg(first.name(), second.name());
 }
 
-QLineF::IntersectType VSpline::CrossingSplLine ( const QLineF &line, QPointF *intersectionPoint ) const{
+QLineF::IntersectType VSpline::CrossingSplLine ( const QLineF &line, QPointF *intersectionPoint ) const
+{
     QVector<qreal> px;
     QVector<qreal> py;
     px.append ( GetPointP1 ().x () );
@@ -168,10 +183,12 @@ QLineF::IntersectType VSpline::CrossingSplLine ( const QLineF &line, QPointF *in
     qint32 i = 0;
     QPointF crosPoint;
     QLineF::IntersectType type = QLineF::NoIntersection;
-    for ( i = 0; i < px.count()-1; ++i ){
+    for ( i = 0; i < px.count()-1; ++i )
+    {
         type = line.intersect(QLineF ( QPointF ( px[i], py[i] ),
                                        QPointF ( px[i+1], py[i+1] )), &crosPoint);
-        if ( type == QLineF::BoundedIntersection ){
+        if ( type == QLineF::BoundedIntersection )
+        {
             *intersectionPoint = crosPoint;
             return type;
         }
@@ -236,7 +253,8 @@ QLineF::IntersectType VSpline::CrossingSplLine ( const QLineF &line, QPointF *in
 //    }
 //}
 
-QVector<QPointF> VSpline::GetPoints () const{
+QVector<QPointF> VSpline::GetPoints () const
+{
     return GetPoints(GetPointP1().toQPointF(), p2, p3, GetPointP4().toQPointF());
 //    QLineF line1(points.at(0).toPoint(), points.at(1).toPoint());
 //    line1.setLength(500);
@@ -260,7 +278,8 @@ QVector<QPointF> VSpline::GetPoints () const{
 //    }
 }
 
-QVector<QPointF> VSpline::GetPoints (QPointF p1, QPointF p2, QPointF p3, QPointF p4){
+QVector<QPointF> VSpline::GetPoints (QPointF p1, QPointF p2, QPointF p3, QPointF p4)
+{
     QVector<QPointF> pvector;
     QVector<qreal> x;
     QVector<qreal> y;
@@ -272,17 +291,20 @@ QVector<QPointF> VSpline::GetPoints (QPointF p1, QPointF p2, QPointF p3, QPointF
                     p3.x (), p3.y (), p4.x (), p4.y (), 0, wx, wy );
     x.append ( p4.x () );
     y.append ( p4.y () );
-    for ( qint32 i = 0; i < x.count(); ++i ){
+    for ( qint32 i = 0; i < x.count(); ++i )
+    {
         pvector.append( QPointF ( x[i], y[i] ) );
     }
     return pvector;
 }
 
-qreal VSpline::LengthBezier ( QPointF p1, QPointF p2, QPointF p3, QPointF p4 ) const{
+qreal VSpline::LengthBezier ( QPointF p1, QPointF p2, QPointF p3, QPointF p4 ) const
+{
     QPainterPath splinePath;
     QVector<QPointF> points = GetPoints (p1, p2, p3, p4);
     splinePath.moveTo(points[0]);
-    for (qint32 i = 1; i < points.count(); ++i){
+    for (qint32 i = 1; i < points.count(); ++i)
+    {
         splinePath.lineTo(points[i]);
     }
     return splinePath.length();
@@ -290,9 +312,10 @@ qreal VSpline::LengthBezier ( QPointF p1, QPointF p2, QPointF p3, QPointF p4 ) c
 
 void VSpline::PointBezier_r ( qreal x1, qreal y1, qreal x2, qreal y2,
                               qreal x3, qreal y3, qreal x4, qreal y4,
-                              qint16 level, QVector<qreal> &px, QVector<qreal> &py){
-    const double curve_collinearity_epsilon              	= 1e-30;
-    const double curve_angle_tolerance_epsilon           	= 0.01;
+                              qint16 level, QVector<qreal> &px, QVector<qreal> &py)
+{
+    const double curve_collinearity_epsilon                 = 1e-30;
+    const double curve_angle_tolerance_epsilon              = 0.01;
     const double m_angle_tolerance = 0.0;
     enum curve_recursion_limit_e { curve_recursion_limit = 32 };
     const double m_cusp_limit = 0.0;
@@ -302,7 +325,7 @@ void VSpline::PointBezier_r ( qreal x1, qreal y1, qreal x2, qreal y2,
     m_distance_tolerance_square = 0.5 / m_approximation_scale;
     m_distance_tolerance_square *= m_distance_tolerance_square;
     
-    if(level > curve_recursion_limit)
+    if (level > curve_recursion_limit)
     {
         return;
     }
@@ -332,217 +355,240 @@ void VSpline::PointBezier_r ( qreal x1, qreal y1, qreal x2, qreal y2,
     double d3 = fabs(((x3 - x4) * dy - (y3 - y4) * dx));
     double da1, da2, k;
     
-    switch((static_cast<int>(d2 > curve_collinearity_epsilon) << 1) +
-           static_cast<int>(d3 > curve_collinearity_epsilon))
+    switch ((static_cast<int>(d2 > curve_collinearity_epsilon) << 1) +
+             static_cast<int>(d3 > curve_collinearity_epsilon))
     {
-    case 0:
-        // All collinear OR p1==p4
-        //----------------------
-        k = dx*dx + dy*dy;
-        if(k == 0)
-        {
-            d2 = CalcSqDistance(x1, y1, x2, y2);
-            d3 = CalcSqDistance(x4, y4, x3, y3);
-        }
-        else
-        {
-            k   = 1 / k;
-            da1 = x2 - x1;
-            da2 = y2 - y1;
-            d2  = k * (da1*dx + da2*dy);
-            da1 = x3 - x1;
-            da2 = y3 - y1;
-            d3  = k * (da1*dx + da2*dy);
-            if(d2 > 0 && d2 < 1 && d3 > 0 && d3 < 1)
-            {
-                // Simple collinear case, 1---2---3---4
-                // We can leave just two endpoints
-                return;
-            }
-            if(d2 <= 0)
-                d2 = CalcSqDistance(x2, y2, x1, y1);
-            else if(d2 >= 1)
-                d2 = CalcSqDistance(x2, y2, x4, y4);
-            else
-                d2 = CalcSqDistance(x2, y2, x1 + d2*dx, y1 + d2*dy);
-            
-            if(d3 <= 0)
-                d3 = CalcSqDistance(x3, y3, x1, y1);
-            else if(d3 >= 1)
-                d3 = CalcSqDistance(x3, y3, x4, y4);
-            else
-                d3 = CalcSqDistance(x3, y3, x1 + d3*dx, y1 + d3*dy);
-        }
-        if(d2 > d3)
-        {
-            if(d2 < m_distance_tolerance_square)
-            {
-                
-                px.append(x2);
-                py.append(y2);
-                //m_points.add(point_d(x2, y2));
-                return;
-            }
-        }
-        else
-        {
-            if(d3 < m_distance_tolerance_square)
-            {
-                
-                px.append(x3);
-                py.append(y3);
-                //m_points.add(point_d(x3, y3));
-                return;
-            }
-        }
-        break;
-    case 1:
-        // p1,p2,p4 are collinear, p3 is significant
-        //----------------------
-        if(d3 * d3 <= m_distance_tolerance_square * (dx*dx + dy*dy))
-        {
-            if(m_angle_tolerance < curve_angle_tolerance_epsilon)
-            {
-                
-                px.append(x23);
-                py.append(y23);
-                //m_points.add(point_d(x23, y23));
-                return;
-            }
-            
-            // Angle Condition
+        case 0:
+            // All collinear OR p1==p4
             //----------------------
-            da1 = fabs(atan2(y4 - y3, x4 - x3) - atan2(y3 - y2, x3 - x2));
-            if(da1 >= M_PI)
-                da1 = 2*M_PI - da1;
-            
-            if(da1 < m_angle_tolerance)
+            k = dx*dx + dy*dy;
+            if (k == 0)
             {
-                
-                px.append(x2);
-                py.append(y2);
-                
-                px.append(x3);
-                py.append(y3);
-                //m_points.add(point_d(x2, y2));
-                //m_points.add(point_d(x3, y3));
-                return;
+                d2 = CalcSqDistance(x1, y1, x2, y2);
+                d3 = CalcSqDistance(x4, y4, x3, y3);
             }
-            
-            if(m_cusp_limit != 0.0)
+            else
             {
-                if(da1 > m_cusp_limit)
+                k   = 1 / k;
+                da1 = x2 - x1;
+                da2 = y2 - y1;
+                d2  = k * (da1*dx + da2*dy);
+                da1 = x3 - x1;
+                da2 = y3 - y1;
+                d3  = k * (da1*dx + da2*dy);
+                if (d2 > 0 && d2 < 1 && d3 > 0 && d3 < 1)
                 {
-                    
+                    // Simple collinear case, 1---2---3---4
+                    // We can leave just two endpoints
+                    return;
+                }
+                if (d2 <= 0)
+                {
+                    d2 = CalcSqDistance(x2, y2, x1, y1);
+                }
+                else if (d2 >= 1)
+                {
+                    d2 = CalcSqDistance(x2, y2, x4, y4);
+                }
+                else
+                {
+                    d2 = CalcSqDistance(x2, y2, x1 + d2*dx, y1 + d2*dy);
+                }
+
+                if (d3 <= 0)
+                {
+                    d3 = CalcSqDistance(x3, y3, x1, y1);
+                }
+                else if (d3 >= 1)
+                {
+                    d3 = CalcSqDistance(x3, y3, x4, y4);
+                }
+                else
+                {
+                    d3 = CalcSqDistance(x3, y3, x1 + d3*dx, y1 + d3*dy);
+                }
+            }
+            if (d2 > d3)
+            {
+                if (d2 < m_distance_tolerance_square)
+                {
+
+                    px.append(x2);
+                    py.append(y2);
+                    //m_points.add(point_d(x2, y2));
+                    return;
+                }
+            }
+            else
+            {
+                if (d3 < m_distance_tolerance_square)
+                {
+
                     px.append(x3);
                     py.append(y3);
                     //m_points.add(point_d(x3, y3));
                     return;
                 }
             }
-        }
-        break;
-        
-    case 2:
-        // p1,p3,p4 are collinear, p2 is significant
-        //----------------------
-        if(d2 * d2 <= m_distance_tolerance_square * (dx*dx + dy*dy))
-        {
-            if(m_angle_tolerance < curve_angle_tolerance_epsilon)
-            {
-                
-                px.append(x23);
-                py.append(y23);
-                //m_points.add(point_d(x23, y23));
-                return;
-            }
-            
-            // Angle Condition
+            break;
+        case 1:
+            // p1,p2,p4 are collinear, p3 is significant
             //----------------------
-            da1 = fabs(atan2(y3 - y2, x3 - x2) - atan2(y2 - y1, x2 - x1));
-            if(da1 >= M_PI) da1 = 2*M_PI - da1;
-            
-            if(da1 < m_angle_tolerance)
+            if (d3 * d3 <= m_distance_tolerance_square * (dx*dx + dy*dy))
             {
-                
-                px.append(x2);
-                py.append(y2);
-                
-                px.append(x3);
-                py.append(y3);
-                //m_points.add(point_d(x2, y2));
-                //m_points.add(point_d(x3, y3));
-                return;
-            }
-            
-            if(m_cusp_limit != 0.0)
-            {
-                if(da1 > m_cusp_limit)
+                if (m_angle_tolerance < curve_angle_tolerance_epsilon)
                 {
-                    px.append(x2);
-                    py.append(y2);
-                    
-                    //m_points.add(point_d(x2, y2));
+
+                    px.append(x23);
+                    py.append(y23);
+                    //m_points.add(point_d(x23, y23));
                     return;
                 }
-            }
-        }
-        break;
-        
-    case 3:
-        // Regular case
-        //-----------------
-        if((d2 + d3)*(d2 + d3) <= m_distance_tolerance_square * (dx*dx + dy*dy))
-        {
-            // If the curvature doesn't exceed the distance_tolerance value
-            // we tend to finish subdivisions.
-            //----------------------
-            if(m_angle_tolerance < curve_angle_tolerance_epsilon)
-            {
-                
-                px.append(x23);
-                py.append(y23);
-                //m_points.add(point_d(x23, y23));
-                return;
-            }
-            
-            // Angle & Cusp Condition
-            //----------------------
-            k   = atan2(y3 - y2, x3 - x2);
-            da1 = fabs(k - atan2(y2 - y1, x2 - x1));
-            da2 = fabs(atan2(y4 - y3, x4 - x3) - k);
-            if(da1 >= M_PI) da1 = 2*M_PI - da1;
-            if(da2 >= M_PI) da2 = 2*M_PI - da2;
-            
-            if(da1 + da2 < m_angle_tolerance)
-            {
-                // Finally we can stop the recursion
+
+                // Angle Condition
                 //----------------------
-                
-                px.append(x23);
-                py.append(y23);
-                //m_points.add(point_d(x23, y23));
-                return;
-            }
-            
-            if(m_cusp_limit != 0.0)
-            {
-                if(da1 > m_cusp_limit)
+                da1 = fabs(atan2(y4 - y3, x4 - x3) - atan2(y3 - y2, x3 - x2));
+                if (da1 >= M_PI)
                 {
+                    da1 = 2*M_PI - da1;
+                }
+
+                if (da1 < m_angle_tolerance)
+                {
+
                     px.append(x2);
                     py.append(y2);
-                    return;
-                }
-                
-                if(da2 > m_cusp_limit)
-                {
+
                     px.append(x3);
                     py.append(y3);
+                    //m_points.add(point_d(x2, y2));
+                    //m_points.add(point_d(x3, y3));
                     return;
                 }
+
+                if (m_cusp_limit != 0.0)
+                {
+                    if (da1 > m_cusp_limit)
+                    {
+
+                        px.append(x3);
+                        py.append(y3);
+                        //m_points.add(point_d(x3, y3));
+                        return;
+                    }
+                }
             }
-        }
-        break;
+            break;
+
+        case 2:
+            // p1,p3,p4 are collinear, p2 is significant
+            //----------------------
+            if (d2 * d2 <= m_distance_tolerance_square * (dx*dx + dy*dy))
+            {
+                if (m_angle_tolerance < curve_angle_tolerance_epsilon)
+                {
+
+                    px.append(x23);
+                    py.append(y23);
+                    //m_points.add(point_d(x23, y23));
+                    return;
+                }
+
+                // Angle Condition
+                //----------------------
+                da1 = fabs(atan2(y3 - y2, x3 - x2) - atan2(y2 - y1, x2 - x1));
+                if (da1 >= M_PI)
+                {
+                    da1 = 2*M_PI - da1;
+                }
+
+                if (da1 < m_angle_tolerance)
+                {
+
+                    px.append(x2);
+                    py.append(y2);
+
+                    px.append(x3);
+                    py.append(y3);
+                    //m_points.add(point_d(x2, y2));
+                    //m_points.add(point_d(x3, y3));
+                    return;
+                }
+
+                if (m_cusp_limit != 0.0)
+                {
+                    if (da1 > m_cusp_limit)
+                    {
+                        px.append(x2);
+                        py.append(y2);
+
+                        //m_points.add(point_d(x2, y2));
+                        return;
+                    }
+                }
+            }
+            break;
+
+        case 3:
+            // Regular case
+            //-----------------
+            if ((d2 + d3)*(d2 + d3) <= m_distance_tolerance_square * (dx*dx + dy*dy))
+            {
+                // If the curvature doesn't exceed the distance_tolerance value
+                // we tend to finish subdivisions.
+                //----------------------
+                if (m_angle_tolerance < curve_angle_tolerance_epsilon)
+                {
+
+                    px.append(x23);
+                    py.append(y23);
+                    //m_points.add(point_d(x23, y23));
+                    return;
+                }
+
+                // Angle & Cusp Condition
+                //----------------------
+                k   = atan2(y3 - y2, x3 - x2);
+                da1 = fabs(k - atan2(y2 - y1, x2 - x1));
+                da2 = fabs(atan2(y4 - y3, x4 - x3) - k);
+                if (da1 >= M_PI)
+                {
+                    da1 = 2*M_PI - da1;
+                }
+                if (da2 >= M_PI)
+                {
+                    da2 = 2*M_PI - da2;
+                }
+
+                if (da1 + da2 < m_angle_tolerance)
+                {
+                    // Finally we can stop the recursion
+                    //----------------------
+
+                    px.append(x23);
+                    py.append(y23);
+                    //m_points.add(point_d(x23, y23));
+                    return;
+                }
+
+                if (m_cusp_limit != 0.0)
+                {
+                    if (da1 > m_cusp_limit)
+                    {
+                        px.append(x2);
+                        py.append(y2);
+                        return;
+                    }
+
+                    if (da2 > m_cusp_limit)
+                    {
+                        px.append(x3);
+                        py.append(y3);
+                        return;
+                    }
+                }
+            }
+            break;
     }
     
     // Continue subdivision
@@ -551,28 +597,33 @@ void VSpline::PointBezier_r ( qreal x1, qreal y1, qreal x2, qreal y2,
     PointBezier_r(x1234, y1234, x234, y234, x34, y34, x4, y4, static_cast<qint16>(level + 1), px, py);
 }
 
-qreal VSpline::CalcSqDistance (qreal x1, qreal y1, qreal x2, qreal y2){
+qreal VSpline::CalcSqDistance (qreal x1, qreal y1, qreal x2, qreal y2)
+{
     qreal dx = x2 - x1;
     qreal dy = y2 - y1;
     return dx * dx + dy * dy;
 }
 
-QPainterPath VSpline::GetPath() const{
+QPainterPath VSpline::GetPath() const
+{
     QPainterPath splinePath;
     QVector<QPointF> points = GetPoints ();
-    if(points.count() >= 2){
-        for (qint32 i = 0; i < points.count()-1; ++i){
+    if (points.count() >= 2)
+    {
+        for (qint32 i = 0; i < points.count()-1; ++i)
+        {
             splinePath.moveTo(points[i]);
             splinePath.lineTo(points[i+1]);
         }
-    } else {
+    }
+    else
+    {
         qWarning()<<"points.count() < 2"<<Q_FUNC_INFO;
     }
     return splinePath;
 }
 
 /* Cubic equation solution. Real coefficients case.
-  
    int Cubic(double *x,double a,double b,double c);
    Parameters:
    x - solution array (size 3). On output:
@@ -588,7 +639,7 @@ QPainterPath VSpline::GetPath() const{
 */
 //qint32 VSpline::Cubic(qreal *x, qreal a, qreal b, qreal c){
 //    qreal q,r,r2,q3;
-    
+//
 //    q = (a*a - 3.*b)/9.;
 //    r = (a*(2.*a*a - 9.*b) + 27.*c)/54.;
 //    r2 = r*r;
@@ -624,24 +675,24 @@ QPainterPath VSpline::GetPath() const{
 //        return(1);
 //    }
 //}
-
+//
 //qreal VSpline::calc_t (qreal curve_coord1, qreal curve_coord2, qreal curve_coord3,
 //                       qreal curve_coord4, qreal point_coord) const{
 //    qreal P1, P2, P3, P4, Bt;
 //    qreal a, b, c, d, ret_t;
-    
+//
 //    qreal *t = static_cast<qreal *>(malloc(3*sizeof(qreal)));
 //    P1 = curve_coord1;
 //    P2 = curve_coord2;
 //    P3 = curve_coord3;
 //    P4 = curve_coord4;
 //    Bt = point_coord;
-    
+//
 //    a = -P1 + 3*P2 - 3*P3 + P4;
 //    b = 3*P1 - 6*P2 + 3*P3;
 //    c = -3*P1 + 3*P2;
 //    d = -Bt + P1;
-    
+//
 //    if(Cubic(t, b/a, c/a, d/a) == 3){
 //        ret_t = t[2];
 //    } else {
@@ -651,7 +702,7 @@ QPainterPath VSpline::GetPath() const{
 //      * Повертається три значення, але експереминтально знайдено що шукане
 //      * значення знаходиться в третьому.
 //      */
-    
+//
 //    free(t);
 //    if(ret_t<0 || ret_t>1){
 //        qDebug()<<"Неправильне значення параметра. фунція calc_t";
@@ -675,7 +726,7 @@ QPainterPath VSpline::GetPath() const{
 //    else
 //        return t_y;
 //}
-
+//
 //void VSpline::Mirror(const QPointF Pmirror){
 //    QPointF P1 = p1;
 //    P1 = QPointF(P1.x() - Pmirror.x(), P1.y() - Pmirror.y());
@@ -697,11 +748,12 @@ QPainterPath VSpline::GetPath() const{
 //}
 
 QVector<QPointF> VSpline::SplinePoints(QPointF p1, QPointF p4, qreal angle1, qreal angle2, qreal kAsm1,
-                                       qreal kAsm2, qreal kCurve){
+                                       qreal kAsm2, qreal kCurve)
+{
     QLineF p1pX(p1.x(), p1.y(), p1.x() + 100, p1.y());
     p1pX.setAngle( angle1 );
     qreal L = 0, radius = 0, angle = 90;
-    radius = QLineF(QPointF(p1.x(), p4.y()),p4).length();
+    radius = QLineF(QPointF(p1.x(), p4.y()), p4).length();
     L = kCurve * radius * 4 / 3 * tan( angle * M_PI / 180.0 / 4 );
     QLineF p1p2(p1.x(), p1.y(), p1.x() + L * kAsm1, p1.y());
     p1p2.setAngle(angle1);
@@ -712,7 +764,8 @@ QVector<QPointF> VSpline::SplinePoints(QPointF p1, QPointF p4, qreal angle1, qre
     return GetPoints(p1, p2, p3, p4);
 }
 
-VSpline &VSpline::operator =(const VSpline &spline){
+VSpline &VSpline::operator =(const VSpline &spline)
+{
     this->p1 = spline.GetP1 ();
     this->p2 = spline.GetP2 ();
     this->p3 = spline.GetP3 ();
diff --git a/geometry/vspline.h b/geometry/vspline.h
index 0b2b6dd40..cc85542c0 100644
--- a/geometry/vspline.h
+++ b/geometry/vspline.h
@@ -29,7 +29,8 @@
 /**
  * @brief VSpline клас, що реалізує сплайн.
  */
-class VSpline{
+class VSpline
+{
 public:
                    VSpline();
                      /**
@@ -196,27 +197,27 @@ private:
     /**
      * @brief p1 початкова точка сплайну
      */
-    qint64         p1;			// перша точка
+    qint64         p1;          // перша точка
     /**
      * @brief p2 перша контрольна точка сплайну.
      */
-    QPointF        p2;			// друга точка
+    QPointF        p2;          // друга точка
     /**
      * @brief p3 друга контрольна точка сплайну.
      */
-    QPointF        p3;			// третя точка
+    QPointF        p3;          // третя точка
     /**
      * @brief p4 кінцеві точка сплайну.
      */
-    qint64         p4;			// четверта точка
+    qint64         p4;          // четверта точка
     /**
      * @brief angle1 кут в градусах першої напрямної.
      */
-    qreal          angle1;		// кут нахилу дотичної в першій точці
+    qreal          angle1;      // кут нахилу дотичної в першій точці
     /**
      * @brief angle2 кут в градусах другої напрямної.
      */
-    qreal          angle2;		// кут нахилу дотичної в другій точці
+    qreal          angle2;      // кут нахилу дотичної в другій точці
     qreal          kAsm1;
     qreal          kAsm2;
     qreal          kCurve;
diff --git a/geometry/vsplinepath.cpp b/geometry/vsplinepath.cpp
index bfd448753..efbeacd20 100644
--- a/geometry/vsplinepath.cpp
+++ b/geometry/vsplinepath.cpp
@@ -22,36 +22,41 @@
 #include "vsplinepath.h"
 #include <exception/vexception.h>
 
-VSplinePath::VSplinePath(): path(QVector<VSplinePoint>()), kCurve(1), mode(Draw::Calculation),
-    points(QHash<qint64, VPointF>()), idObject(0){
-}
+VSplinePath::VSplinePath()
+    : path(QVector<VSplinePoint>()), kCurve(1), mode(Draw::Calculation), points(QHash<qint64, VPointF>()), idObject(0){}
 
-VSplinePath::VSplinePath(const QHash<qint64, VPointF> *points, qreal kCurve, Draw::Draws mode, qint64 idObject): path(QVector<VSplinePoint>()),
-    kCurve(kCurve), mode(mode), points(*points), idObject(idObject){
-}
+VSplinePath::VSplinePath(const QHash<qint64, VPointF> *points, qreal kCurve, Draw::Draws mode, qint64 idObject)
+    : path(QVector<VSplinePoint>()), kCurve(kCurve), mode(mode), points(*points), idObject(idObject){}
 
-VSplinePath::VSplinePath(const VSplinePath &splPath): path(*splPath.GetPoint()),
-    kCurve(splPath.getKCurve()), mode(splPath.getMode()), points(splPath.GetDataPoints()),
-    idObject(splPath.getIdObject()){
-}
+VSplinePath::VSplinePath(const VSplinePath &splPath)
+    : path(*splPath.GetPoint()), kCurve(splPath.getKCurve()), mode(splPath.getMode()), points(splPath.GetDataPoints()),
+    idObject(splPath.getIdObject()){}
 
-void VSplinePath::append(VSplinePoint point){
+void VSplinePath::append(VSplinePoint point)
+{
     path.append(point);
 }
 
-qint32 VSplinePath::Count() const{
-    if(path.size() == 0){
+qint32 VSplinePath::Count() const
+{
+    if (path.size() == 0)
+    {
         return 0;
-    } else {
+    }
+    else
+    {
         return path.size() - 1;
     }
 }
 
-VSpline VSplinePath::GetSpline(qint32 index) const{
-    if(Count()<1){
+VSpline VSplinePath::GetSpline(qint32 index) const
+{
+    if (Count()<1)
+    {
         throw VException(tr("Not enough points to create the spline."));
     }
-    if(index < 1 || index > Count()){
+    if (index < 1 || index > Count())
+    {
         throw VException(tr("This spline is not exist."));
     }
     VSpline spl(&points, path[index-1].P(), path[index].P(), path[index-1].Angle2(), path[index].Angle1(),
@@ -59,9 +64,11 @@ VSpline VSplinePath::GetSpline(qint32 index) const{
     return spl;
 }
 
-QPainterPath VSplinePath::GetPath() const{
+QPainterPath VSplinePath::GetPath() const
+{
     QPainterPath painterPath;
-    for(qint32 i = 1; i <= Count(); ++i){
+    for (qint32 i = 1; i <= Count(); ++i)
+    {
         VSpline spl(&points, path[i-1].P(), path[i].P(), path[i-1].Angle2(), path[i].Angle1(),
                 path[i-1].KAsm2(), path[i].KAsm1(), this->kCurve);
         painterPath.addPath(spl.GetPath());
@@ -69,22 +76,27 @@ QPainterPath VSplinePath::GetPath() const{
     return painterPath;
 }
 
-QVector<QPointF> VSplinePath::GetPathPoints() const{
+QVector<QPointF> VSplinePath::GetPathPoints() const
+{
     QVector<QPointF> pathPoints;
-    for(qint32 i = 1; i <= Count(); ++i){
+    for (qint32 i = 1; i <= Count(); ++i)
+    {
         VSpline spl(&points, path[i-1].P(), path[i].P(), path[i-1].Angle2(), path[i].Angle1(),
                 path[i-1].KAsm2(), path[i].KAsm1(), this->kCurve);
         QVector<QPointF> splP = spl.GetPoints();
-        for(qint32 j = 0; j < splP.size(); ++j){
+        for (qint32 j = 0; j < splP.size(); ++j)
+        {
             pathPoints.append(splP[j]);
         }
     }
     return pathPoints;
 }
 
-qreal VSplinePath::GetLength() const{
+qreal VSplinePath::GetLength() const
+{
     qreal length = 0;
-    for(qint32 i = 1; i <= Count(); ++i){
+    for (qint32 i = 1; i <= Count(); ++i)
+    {
         VSpline spl(&points, path[i-1].P(), path[i].P(), path[i-1].Angle2(), path[i].Angle1(), path[i-1].KAsm2(),
                 path[i].KAsm1(), kCurve);
         length += spl.GetLength();
@@ -92,29 +104,40 @@ qreal VSplinePath::GetLength() const{
     return length;
 }
 
-void VSplinePath::UpdatePoint(qint32 indexSpline, SplinePoint::Position pos, VSplinePoint point){
-    if(indexSpline < 1 || indexSpline > Count()){
+void VSplinePath::UpdatePoint(qint32 indexSpline, SplinePoint::Position pos, VSplinePoint point)
+{
+    if (indexSpline < 1 || indexSpline > Count())
+    {
         throw VException(tr("This spline is not exist."));
     }
-    if(pos == SplinePoint::FirstPoint){
+    if (pos == SplinePoint::FirstPoint)
+    {
         path[indexSpline-1] = point;
-    } else {
+    }
+    else
+    {
         path[indexSpline] = point;
     }
 }
 
-VSplinePoint VSplinePath::GetSplinePoint(qint32 indexSpline, SplinePoint::Position pos) const{
-    if(indexSpline < 1 || indexSpline > Count()){
+VSplinePoint VSplinePath::GetSplinePoint(qint32 indexSpline, SplinePoint::Position pos) const
+{
+    if (indexSpline < 1 || indexSpline > Count())
+    {
         throw VException(tr("This spline is not exist."));
     }
-    if(pos == SplinePoint::FirstPoint){
+    if (pos == SplinePoint::FirstPoint)
+    {
         return path.at(indexSpline-1);
-    } else {
+    }
+    else
+    {
         return path.at(indexSpline);
     }
 }
 
-VSplinePath &VSplinePath::operator =(const VSplinePath &path){
+VSplinePath &VSplinePath::operator =(const VSplinePath &path)
+{
     this->path = path.GetSplinePath();
     this->kCurve = path.getKCurve();
     this->mode = path.getMode();
@@ -123,6 +146,7 @@ VSplinePath &VSplinePath::operator =(const VSplinePath &path){
     return *this;
 }
 
-VSplinePoint & VSplinePath::operator[](int indx){
+VSplinePoint & VSplinePath::operator[](int indx)
+{
     return path[indx];
 }
diff --git a/geometry/vsplinepath.h b/geometry/vsplinepath.h
index d8012b1ce..6ac235ec7 100644
--- a/geometry/vsplinepath.h
+++ b/geometry/vsplinepath.h
@@ -27,16 +27,18 @@
 #include "vspline.h"
 #include <QApplication>
 
-namespace SplinePoint{
-enum Position { FirstPoint, LastPoint };
-Q_DECLARE_FLAGS(Positions, Position)
+namespace SplinePoint
+{
+    enum Position { FirstPoint, LastPoint };
+    Q_DECLARE_FLAGS(Positions, Position)
 }
 Q_DECLARE_OPERATORS_FOR_FLAGS( SplinePoint::Positions )
 
 /**
  * @brief The VSplinePath клас, що розраховує шлях сплайнів.
  */
-class VSplinePath{
+class VSplinePath
+{
     Q_DECLARE_TR_FUNCTIONS(VSplinePath)
 public:
                           /**
diff --git a/geometry/vsplinepoint.cpp b/geometry/vsplinepoint.cpp
index 93ad612ab..7913d0fe9 100644
--- a/geometry/vsplinepoint.cpp
+++ b/geometry/vsplinepoint.cpp
@@ -21,19 +21,11 @@
 
 #include "vsplinepoint.h"
 
-VSplinePoint::VSplinePoint():pSpline(0), angle(0), kAsm1(1), kAsm2(1){
-}
-
-VSplinePoint::VSplinePoint(qint64 pSpline, qreal kAsm1, qreal angle , qreal kAsm2):pSpline(pSpline),
-    angle(angle), kAsm1(kAsm1), kAsm2(kAsm2){
-}
-
-VSplinePoint::VSplinePoint(const VSplinePoint &point):pSpline(point.P()), angle(point.Angle2()),
-    kAsm1(point.KAsm1()), kAsm2(point.KAsm2()){
-}
-
-
-
-
+VSplinePoint::VSplinePoint()
+    :pSpline(0), angle(0), kAsm1(1), kAsm2(1){}
 
+VSplinePoint::VSplinePoint(qint64 pSpline, qreal kAsm1, qreal angle, qreal kAsm2)
+    :pSpline(pSpline), angle(angle), kAsm1(kAsm1), kAsm2(kAsm2){}
 
+VSplinePoint::VSplinePoint(const VSplinePoint &point)
+    :pSpline(point.P()), angle(point.Angle2()), kAsm1(point.KAsm1()), kAsm2(point.KAsm2()){}
diff --git a/geometry/vsplinepoint.h b/geometry/vsplinepoint.h
index 58fb845c8..41f2f9672 100644
--- a/geometry/vsplinepoint.h
+++ b/geometry/vsplinepoint.h
@@ -27,7 +27,8 @@
 /**
  * @brief The VSplinePoint клас, що містить у собі інформацію про точки сплайну.
  */
-class VSplinePoint{
+class VSplinePoint
+{
 public:
             /**
              * @brief VSplinePoint конструктор по замповчуванню.
diff --git a/main.cpp b/main.cpp
index 0ff386dd9..bc8d1598c 100644
--- a/main.cpp
+++ b/main.cpp
@@ -24,29 +24,32 @@
 #include <QTextCodec>
 #include "tablewindow.h"
 
-void myMessageOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg){
+void myMessageOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg)
+{
     QByteArray localMsg = msg.toLocal8Bit();
-    switch (type) {
-    case QtDebugMsg:
-        fprintf(stderr, "Debug: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line,
-                context.function);
-        break;
-    case QtWarningMsg:
-        fprintf(stderr, "Warning: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line,
-                context.function);
-        break;
-    case QtCriticalMsg:
-        fprintf(stderr, "Critical: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line,
-                context.function);
-        break;
-    case QtFatalMsg:
-        fprintf(stderr, "Fatal: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line,
-                context.function);
-        abort();
+    switch (type)
+    {
+        case QtDebugMsg:
+            fprintf(stderr, "Debug: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line,
+                    context.function);
+            break;
+        case QtWarningMsg:
+            fprintf(stderr, "Warning: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line,
+                    context.function);
+            break;
+        case QtCriticalMsg:
+            fprintf(stderr, "Critical: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line,
+                    context.function);
+            break;
+        case QtFatalMsg:
+            fprintf(stderr, "Fatal: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line,
+                    context.function);
+            abort();
     }
 }
 
-int main(int argc, char *argv[]){
+int main(int argc, char *argv[])
+{
     qInstallMessageHandler(myMessageOutput);
     VApplication app(argc, argv);
 
@@ -56,7 +59,7 @@ int main(int argc, char *argv[]){
     app.installTranslator(&qtTranslator);
 
     QTranslator appTranslator;
-    appTranslator.load("valentina_" + QLocale::system().name(),".");
+    appTranslator.load("valentina_" + QLocale::system().name(), ".");
     app.installTranslator(&appTranslator);
 
     MainWindow w;
@@ -70,23 +73,31 @@ int main(int argc, char *argv[]){
     QString fileName;
     QRegExp rxArgOpenFile("-o");//parameter open file
 
-    if(args.size()>1){
-        for (int i = 1; i < args.size(); ++i) {
-            if (rxArgOpenFile.indexIn(args.at(i)) != -1 ) {
-                if(args.at(i+1).isEmpty() == false){
+    if (args.size()>1)
+    {
+        for (int i = 1; i < args.size(); ++i)
+        {
+            if (rxArgOpenFile.indexIn(args.at(i)) != -1 )
+            {
+                if (args.at(i+1).isEmpty() == false)
+                {
                     fileName =  args.at(i+1);
                     qDebug() << args.at(i)<< ":" << fileName;
                     w.OpenPattern(fileName);
                 }
                 w.show();
                 break;
-            } else {
+            }
+            else
+            {
                 qDebug() << "Uknown arg:" << args.at(i);
                 w.show();
                 break;
             }
         }
-    } else {
+    }
+    else
+    {
         w.show();
     }
     return app.exec();
diff --git a/mainwindow.cpp b/mainwindow.cpp
index 536c86482..167d19f71 100644
--- a/mainwindow.cpp
+++ b/mainwindow.cpp
@@ -29,8 +29,8 @@
 #include "exception/vexceptionuniqueid.h"
 #include "version.h"
 
-MainWindow::MainWindow(QWidget *parent) :
-    QMainWindow(parent), ui(new Ui::MainWindow), tool(Tool::ArrowTool), currentScene(0), sceneDraw(0),
+MainWindow::MainWindow(QWidget *parent)
+    :QMainWindow(parent), ui(new Ui::MainWindow), tool(Tool::ArrowTool), currentScene(0), sceneDraw(0),
     sceneDetails(0), mouseCoordinate(0), helpLabel(0), view(0), isInitialized(false), dialogTable(0),
     dialogEndLine(QSharedPointer<DialogEndLine>()), dialogLine(QSharedPointer<DialogLine>()),
     dialogAlongLine(QSharedPointer<DialogAlongLine>()),
@@ -43,7 +43,8 @@ MainWindow::MainWindow(QWidget *parent) :
     dialogTriangle(QSharedPointer<DialogTriangle>()),
     dialogPointOfIntersection(QSharedPointer<DialogPointOfIntersection>()),
     dialogHistory(0), doc(0), data(0), comboBoxDraws(0), fileName(QString()), changeInFile(false),
-    mode(Draw::Calculation){
+    mode(Draw::Calculation)
+{
     ui->setupUi(this);
     ToolBarOption();
     ToolBarDraws();
@@ -111,7 +112,8 @@ MainWindow::MainWindow(QWidget *parent) :
     ui->toolBox->setCurrentIndex(0);
 }
 
-void MainWindow::ActionNewDraw(){
+void MainWindow::ActionNewDraw()
+{
     QString nameDraw;
     bool bOk;
     qint32 index;
@@ -121,25 +123,31 @@ void MainWindow::ActionNewDraw(){
     dlg->setLabelText(tr("Drawing:"));
     dlg->setTextEchoMode(QLineEdit::Normal);
     dlg->setWindowTitle(tr("Enter a name for the drawing."));
-    dlg->resize(300,100);
+    dlg->resize(300, 100);
     dlg->setTextValue(nDraw);
-    while(1){
+    while (1)
+    {
         bOk = dlg->exec();
         nameDraw = dlg->textValue();
-        if(!bOk || nameDraw.isEmpty()){
+        if (bOk == false || nameDraw.isEmpty())
+        {
             delete dlg;
             return;
         }
         index = comboBoxDraws->findText(nameDraw);
-        if(index != -1){//we already have this name
+        if (index != -1)
+        {//we already have this name
             qCritical()<<tr("Error. Drawing of same name already exists.");
-        } else {
+        }
+        else
+        {
             break;
         }
     }
     delete dlg;
     bOk = doc->appendDraw(nameDraw);
-    if(bOk == false){
+    if (bOk == false)
+    {
         qCritical()<<tr("Error creating drawing with the name")<<nameDraw<<".";
         return;
     }
@@ -147,7 +155,8 @@ void MainWindow::ActionNewDraw(){
                this, &MainWindow::currentDrawChanged);
     comboBoxDraws->addItem(nameDraw);
     index = comboBoxDraws->findText(nameDraw);
-    if ( index != -1 ) { // -1 for not found
+    if ( index != -1 )
+    { // -1 for not found
         comboBoxDraws->setCurrentIndex(index);
         currentDrawChanged( index );
     }
@@ -168,9 +177,9 @@ void MainWindow::ActionNewDraw(){
     changeInFile = true;
 }
 
-void MainWindow::OptionDraw(){
+void MainWindow::OptionDraw()
+{
     QString nameDraw;
-    bool bOk = false;
     qint32 index;
     QString nDraw = doc->GetNameActivDraw();
     QInputDialog *dlg = new QInputDialog(this);
@@ -178,27 +187,35 @@ void MainWindow::OptionDraw(){
     dlg->setLabelText(tr("Drawing:"));
     dlg->setTextEchoMode(QLineEdit::Normal);
     dlg->setWindowTitle(tr("Enter a new name for the drawing."));
-    dlg->resize(300,100);
+    dlg->resize(300, 100);
     dlg->setTextValue(nDraw);
-    while(1){
-        bOk = dlg->exec();
+    while (1)
+    {
+        bool bOk = dlg->exec();
         nameDraw = dlg->textValue();
-        if(!bOk || nameDraw.isEmpty()){
+        if (bOk == false || nameDraw.isEmpty())
+        {
             delete dlg;
             return;
         }
         index = comboBoxDraws->findText(nameDraw);
-        if(index != -1){//we already have this name
+        if (index != -1)
+        {//we already have this name
             qCritical()<<tr("Error. Drawing of same name already exists.");
-        } else {
+        }
+        else
+        {
             break;
         }
     }
     delete dlg;
     index = comboBoxDraws->findText(doc->GetNameActivDraw());
-    if(doc->SetNameDraw(nameDraw)){
+    if (doc->SetNameDraw(nameDraw))
+    {
         comboBoxDraws->setItemText(index, nameDraw);
-    } else {
+    }
+    else
+    {
         QMessageBox::warning(this, tr("Error saving change!!!"), tr("Can't save new name of drawing"));
     }
 
@@ -206,8 +223,10 @@ void MainWindow::OptionDraw(){
 
 template <typename Dialog, typename Func>
 void MainWindow::SetToolButton(bool checked, Tool::Tools t, const QString &cursor, const QString &toolTip,
-                               QSharedPointer<Dialog> &dialog, Func closeDialogSlot){
-    if(checked){
+                               QSharedPointer<Dialog> &dialog, Func closeDialogSlot)
+{
+    if (checked)
+    {
         CanselTool();
         tool = t;
         QPixmap pixmap(cursor);
@@ -219,8 +238,11 @@ void MainWindow::SetToolButton(bool checked, Tool::Tools t, const QString &curso
         connect(dialog.data(), &Dialog::DialogClosed, this, closeDialogSlot);
         connect(dialog.data(), &Dialog::ToolTip, this, &MainWindow::ShowToolTip);
         connect(doc, &VDomDocument::FullUpdateFromFile, dialog.data(), &Dialog::UpdateList);
-    } else {
-        if(QToolButton *tButton = qobject_cast< QToolButton * >(this->sender())){
+    }
+    else
+    {
+        if (QToolButton *tButton = qobject_cast< QToolButton * >(this->sender()))
+        {
             Q_ASSERT(tButton != 0);
             tButton->setChecked(true);
         }
@@ -228,7 +250,8 @@ void MainWindow::SetToolButton(bool checked, Tool::Tools t, const QString &curso
 }
 
 template <typename T>
-void MainWindow::AddToolToDetail(T *tool, const qint64 &id, Tool::Tools typeTool, const qint64 &idDetail){
+void MainWindow::AddToolToDetail(T *tool, const qint64 &id, Tool::Tools typeTool, const qint64 &idDetail)
+{
     QHash<qint64, VDataTool*>* tools = doc->getTools();
     VToolDetail *det = qobject_cast<VToolDetail*>(tools->value(idDetail));
     Q_ASSERT(det != 0);
@@ -236,11 +259,16 @@ void MainWindow::AddToolToDetail(T *tool, const qint64 &id, Tool::Tools typeTool
 }
 
 template <typename DrawTool, typename ModelingTool, typename Dialog>
-void MainWindow::ClosedDialog(QSharedPointer<Dialog> &dialog, int result){
-    if(result == QDialog::Accepted){
-        if(mode == Draw::Calculation){
+void MainWindow::ClosedDialog(QSharedPointer<Dialog> &dialog, int result)
+{
+    if (result == QDialog::Accepted)
+    {
+        if (mode == Draw::Calculation)
+        {
             DrawTool::Create(dialog, currentScene, doc, data);
-        } else {
+        }
+        else
+        {
             ModelingTool *endLine = ModelingTool::Create(dialog, doc, data);
             AddToolToDetail(endLine, endLine->getId(), tool, dialog->getIdDetail());
         }
@@ -248,111 +276,135 @@ void MainWindow::ClosedDialog(QSharedPointer<Dialog> &dialog, int result){
     ArrowTool();
 }
 
-void MainWindow::ToolEndLine(bool checked){
+void MainWindow::ToolEndLine(bool checked)
+{
     SetToolButton(checked, Tool::EndLineTool, ":/cursor/endline_cursor.png", tr("Select point"),
                   dialogEndLine, &MainWindow::ClosedDialogEndLine);
 }
 
-void MainWindow::ClosedDialogEndLine(int result){
+void MainWindow::ClosedDialogEndLine(int result)
+{
     ClosedDialog<VToolEndLine, VModelingEndLine>(dialogEndLine, result);
 }
 
-void MainWindow::ToolLine(bool checked){
+void MainWindow::ToolLine(bool checked)
+{
     SetToolButton(checked, Tool::LineTool, ":/cursor/line_cursor.png", tr("Select first point"),
                   dialogLine, &MainWindow::ClosedDialogLine);
 }
 
-void MainWindow::ClosedDialogLine(int result){
+void MainWindow::ClosedDialogLine(int result)
+{
     ClosedDialog<VToolLine, VModelingLine>(dialogLine, result);
 }
 
-void MainWindow::ToolAlongLine(bool checked){
+void MainWindow::ToolAlongLine(bool checked)
+{
     SetToolButton(checked, Tool::AlongLineTool, ":/cursor/alongline_cursor.png", tr("Select point"),
                   dialogAlongLine, &MainWindow::ClosedDialogAlongLine);
 }
 
-void MainWindow::ClosedDialogAlongLine(int result){
+void MainWindow::ClosedDialogAlongLine(int result)
+{
     ClosedDialog<VToolAlongLine, VModelingAlongLine>(dialogAlongLine, result);
 }
 
-void MainWindow::ToolShoulderPoint(bool checked){
+void MainWindow::ToolShoulderPoint(bool checked)
+{
     SetToolButton(checked, Tool::ShoulderPointTool, ":/cursor/shoulder_cursor.png",
                   tr("Select first point of line"),  dialogShoulderPoint,
                   &MainWindow::ClosedDialogShoulderPoint);
 }
 
-void MainWindow::ClosedDialogShoulderPoint(int result){
+void MainWindow::ClosedDialogShoulderPoint(int result)
+{
     ClosedDialog<VToolShoulderPoint, VModelingShoulderPoint>(dialogShoulderPoint, result);
 }
 
-void MainWindow::ToolNormal(bool checked){
+void MainWindow::ToolNormal(bool checked)
+{
     SetToolButton(checked, Tool::NormalTool, ":/cursor/normal_cursor.png",
                   tr("Select first point of line"), dialogNormal, &MainWindow::ClosedDialogNormal);
 }
 
-void MainWindow::ClosedDialogNormal(int result){
+void MainWindow::ClosedDialogNormal(int result)
+{
     ClosedDialog<VToolNormal, VModelingNormal>(dialogNormal, result);
 }
 
-void MainWindow::ToolBisector(bool checked){
+void MainWindow::ToolBisector(bool checked)
+{
     SetToolButton(checked, Tool::BisectorTool, ":/cursor/bisector_cursor.png",
                   tr("Select first point of angle"), dialogBisector, &MainWindow::ClosedDialogBisector);
 }
 
-void MainWindow::ClosedDialogBisector(int result){
+void MainWindow::ClosedDialogBisector(int result)
+{
     ClosedDialog<VToolBisector, VModelingBisector>(dialogBisector, result);
 }
 
-void MainWindow::ToolLineIntersect(bool checked){
+void MainWindow::ToolLineIntersect(bool checked)
+{
     SetToolButton(checked, Tool::LineIntersectTool, ":/cursor/intersect_cursor.png",
                   tr("Select first point of first line"), dialogLineIntersect,
                   &MainWindow::ClosedDialogLineIntersect);
 }
 
-void MainWindow::ClosedDialogLineIntersect(int result){
+void MainWindow::ClosedDialogLineIntersect(int result)
+{
     ClosedDialog<VToolLineIntersect, VModelingLineIntersect>(dialogLineIntersect, result);
 }
 
-void MainWindow::ToolSpline(bool checked){
+void MainWindow::ToolSpline(bool checked)
+{
     SetToolButton(checked, Tool::SplineTool, ":/cursor/spline_cursor.png",
                   tr("Select first point curve"), dialogSpline, &MainWindow::ClosedDialogSpline);
 }
 
-void MainWindow::ClosedDialogSpline(int result){
+void MainWindow::ClosedDialogSpline(int result)
+{
     ClosedDialog<VToolSpline, VModelingSpline>(dialogSpline, result);
 }
 
-void MainWindow::ToolArc(bool checked){
+void MainWindow::ToolArc(bool checked)
+{
     SetToolButton(checked, Tool::ArcTool, ":/cursor/arc_cursor.png",
                   tr("Select point of center of arc"), dialogArc, &MainWindow::ClosedDialogArc);
 }
 
-void MainWindow::ClosedDialogArc(int result){
+void MainWindow::ClosedDialogArc(int result)
+{
     ClosedDialog<VToolArc, VModelingArc>(dialogArc, result);
 }
 
-void MainWindow::ToolSplinePath(bool checked){
+void MainWindow::ToolSplinePath(bool checked)
+{
     SetToolButton(checked, Tool::SplinePathTool, ":/cursor/splinepath_cursor.png",
                   tr("Select point of curve path"), dialogSplinePath,
                   &MainWindow::ClosedDialogSplinePath);
 }
 
-void MainWindow::ClosedDialogSplinePath(int result){
+void MainWindow::ClosedDialogSplinePath(int result)
+{
     ClosedDialog<VToolSplinePath, VModelingSplinePath>(dialogSplinePath, result);
 }
 
-void MainWindow::ToolPointOfContact(bool checked){
+void MainWindow::ToolPointOfContact(bool checked)
+{
     SetToolButton(checked, Tool::PointOfContact, ":/cursor/pointcontact_cursor.png",
                   tr("Select first point of line"), dialogPointOfContact,
                   &MainWindow::ClosedDialogPointOfContact);
 }
 
-void MainWindow::ClosedDialogPointOfContact(int result){
+void MainWindow::ClosedDialogPointOfContact(int result)
+{
     ClosedDialog<VToolPointOfContact, VModelingPointOfContact>(dialogPointOfContact, result);
 }
 
-void MainWindow::ToolDetail(bool checked){
-    if(checked){
+void MainWindow::ToolDetail(bool checked)
+{
+    if (checked)
+    {
         CanselTool();
         tool = Tool::Detail;
         QPixmap pixmap("://cursor/new_detail_cursor.png");
@@ -364,76 +416,95 @@ void MainWindow::ToolDetail(bool checked){
                 &DialogDetail::ChoosedObject);
         connect(dialogDetail.data(), &DialogDetail::DialogClosed, this, &MainWindow::ClosedDialogDetail);
         connect(doc, &VDomDocument::FullUpdateFromFile, dialogDetail.data(), &DialogDetail::UpdateList);
-    } else {
-        if(QToolButton *tButton = qobject_cast< QToolButton * >(this->sender())){
+    }
+    else
+    {
+        if (QToolButton *tButton = qobject_cast< QToolButton * >(this->sender()))
+        {
             tButton->setChecked(true);
         }
     }
 }
 
-void MainWindow::ClosedDialogDetail(int result){
-    if(result == QDialog::Accepted){
+void MainWindow::ClosedDialogDetail(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         VToolDetail::Create(dialogDetail, sceneDetails, doc, data);
     }
     ArrowTool();
 }
 
-void MainWindow::ToolHeight(bool checked){
+void MainWindow::ToolHeight(bool checked)
+{
     SetToolButton(checked, Tool::Height, ":/cursor/height_cursor.png", tr("Select base point"),
                   dialogHeight, &MainWindow::ClosedDialogHeight);
 }
 
-void MainWindow::ClosedDialogHeight(int result){
+void MainWindow::ClosedDialogHeight(int result)
+{
     ClosedDialog<VToolHeight, VModelingHeight>(dialogHeight, result);
 }
 
-void MainWindow::ToolTriangle(bool checked){
+void MainWindow::ToolTriangle(bool checked)
+{
     SetToolButton(checked, Tool::Triangle, ":/cursor/triangle_cursor.png", tr("Select first point of axis"),
                   dialogTriangle, &MainWindow::ClosedDialogTriangle);
 }
 
-void MainWindow::ClosedDialogTriangle(int result){
+void MainWindow::ClosedDialogTriangle(int result)
+{
     ClosedDialog<VToolTriangle, VModelingTriangle>(dialogTriangle, result);
 }
 
-void MainWindow::ToolPointOfIntersection(bool checked){
+void MainWindow::ToolPointOfIntersection(bool checked)
+{
     SetToolButton(checked, Tool::PointOfIntersection, ":/cursor/pointofintersect_cursor.png",
                   tr("Select point vertically"),
                   dialogPointOfIntersection, &MainWindow::ClosedDialogPointOfIntersection);
 }
 
-void MainWindow::ClosedDialogPointOfIntersection(int result){
+void MainWindow::ClosedDialogPointOfIntersection(int result)
+{
     ClosedDialog<VToolPointOfIntersection, VModelingPointOfIntersection>(dialogPointOfIntersection, result);
 }
 
-void MainWindow::About(){
+void MainWindow::About()
+{
     QString fullName = QString("Valentina %1").arg(APP_VERSION);
     QString qtBase(tr("Based on Qt %2 (32 bit)").arg(QT_VERSION_STR));
     QString buildOn(tr("Built on %3 at %4").arg(__DATE__).arg(__TIME__));
-    QString about = QString(tr("<h1>%1</h1> %2 <br/><br/> %3 <br/><br/> %4")).arg(fullName).arg(qtBase).arg(buildOn).arg(WARRANTY);
+    QString about = QString(tr("<h1>%1</h1> %2 <br/><br/> %3 <br/><br/> %4")).arg(fullName).arg(qtBase).arg(
+                buildOn).arg(WARRANTY);
     QMessageBox::about(this, tr("About Valentina"), about);
 }
 
-void MainWindow::AboutQt(){
+void MainWindow::AboutQt()
+{
     QMessageBox::aboutQt(this, tr("About Qt"));
 }
 
-void MainWindow::ShowToolTip(const QString &toolTip){
+void MainWindow::ShowToolTip(const QString &toolTip)
+{
     helpLabel->setText(toolTip);
 }
 
-void MainWindow::tableClosed(){
+void MainWindow::tableClosed()
+{
     show();
     MinimumScrollBar();
 }
 
-void MainWindow::showEvent( QShowEvent *event ){
+void MainWindow::showEvent( QShowEvent *event )
+{
     QMainWindow::showEvent( event );
-    if( event->spontaneous() ){
+    if ( event->spontaneous() )
+    {
         return;
     }
 
-    if(isInitialized){
+    if (isInitialized)
+    {
         return;
     }
     // do your init stuff here
@@ -442,8 +513,10 @@ void MainWindow::showEvent( QShowEvent *event ){
     isInitialized = true;//first show windows are held
 }
 
-void MainWindow::closeEvent(QCloseEvent *event){
-    if(changeInFile == true){
+void MainWindow::closeEvent(QCloseEvent *event)
+{
+    if (changeInFile == true)
+    {
         QMessageBox msgBox;
         msgBox.setText(tr("The pattern has been modified."));
         msgBox.setInformativeText(tr("Do you want to save your changes?"));
@@ -451,50 +524,58 @@ void MainWindow::closeEvent(QCloseEvent *event){
         msgBox.setDefaultButton(QMessageBox::Save);
         msgBox.setIcon(QMessageBox::Question);
         int ret = msgBox.exec();
-        switch (ret) {
-        case QMessageBox::Save:
-            // Save was clicked
-            if(fileName.isEmpty()){
-                ActionSaveAs();
-            } else {
-                ActionSave();
-            }
-            if(changeInFile){
-                // We did't save file
-                event->ignore();
-            } else {
-                // We have successfully saved the file
+        switch (ret)
+        {
+            case QMessageBox::Save:
+                // Save was clicked
+                if (fileName.isEmpty())
+                {
+                    ActionSaveAs();
+                }
+                else
+                {
+                    ActionSave();
+                }
+                if (changeInFile)
+                {
+                    // We did't save file
+                    event->ignore();
+                }
+                else
+                {
+                    // We have successfully saved the file
+                    event->accept();
+                }
+                break;
+            case QMessageBox::Discard:
+                // Don't Save was clicked
                 event->accept();
-            }
-            break;
-        case QMessageBox::Discard:
-            // Don't Save was clicked
-            event->accept();
-            break;
-        case QMessageBox::Cancel:
-            // Cancel was clicked
-            event->ignore();
-            break;
-        default:
-            // should never be reached
-            event->accept();
-            break;
+                break;
+            case QMessageBox::Cancel:
+                // Cancel was clicked
+                event->ignore();
+                break;
+            default:
+                // should never be reached
+                event->accept();
+                break;
         }
     }
 }
 
-void MainWindow::ToolBarOption(){
+void MainWindow::ToolBarOption()
+{
     QLabel * labelGrowth = new QLabel;
     labelGrowth->setText(tr("Growth: "));
     ui->toolBarOption->addWidget(labelGrowth);
 
     QStringList list;
-    list << "104"<<"110"<<"116"<<"122"<<"128"<<"134"<<"140"<<"146"<<"152"<<"158"<<"164"<<"170"<<"176"
-         << "182" << "188";
+    list <<"92"<<"98"<<"104"<<"110"<<"116"<<"122"<<"128"<<"134"<<"140"<<"146"<<"152"<<"158"<<"164"<<"170"<<"176"
+         <<"182"<<"188";
     QComboBox *comboBoxGrow = new QComboBox;
     comboBoxGrow->clear();
     comboBoxGrow->addItems(list);
-    comboBoxGrow->setCurrentIndex(12);
+    comboBoxGrow->setCurrentIndex(14);
     ui->toolBarOption->addWidget(comboBoxGrow);
     connect(comboBoxGrow,
             static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::currentIndexChanged),
@@ -505,11 +586,11 @@ void MainWindow::ToolBarOption(){
     ui->toolBarOption->addWidget(labelSize);
 
     list.clear();
-    list << "28"<<"30"<<"32"<<"34"<<"36"<<"38"<<"40"<<"42"<<"44"<<"46"<<"48"<<"50" << "52" << "54" << "56";
+    list <<"22"<<"24"<<"26"<<"28"<<"30"<<"32"<<"34"<<"36"<<"38"<<"40"<<"42"<<"44"<<"46"<<"48"<<"50"<<"52"<<"54"<<"56";
     QComboBox *comboBoxSize = new QComboBox;
     comboBoxSize->clear();
     comboBoxSize->addItems(list);
-    comboBoxSize->setCurrentIndex(11);
+    comboBoxSize->setCurrentIndex(14);
     ui->toolBarOption->addWidget(comboBoxSize);
     connect(comboBoxSize,
             static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::currentIndexChanged),
@@ -523,7 +604,8 @@ void MainWindow::ToolBarOption(){
 
 }
 
-void MainWindow::ToolBarDraws(){
+void MainWindow::ToolBarDraws()
+{
     QLabel * labelNameDraw = new QLabel;
     labelNameDraw ->setText(tr("Drawing: "));
     ui->toolBarDraws->addWidget(labelNameDraw);
@@ -548,125 +630,131 @@ void MainWindow::ToolBarDraws(){
     connect(ui->actionLayout, &QAction::triggered, this, &MainWindow::ActionLayout);
 }
 
-void MainWindow::currentDrawChanged( int index ){
-    if(index != -1) {
+void MainWindow::currentDrawChanged( int index )
+{
+    if (index != -1)
+    {
         doc->setCurrentData();
         doc->ChangeActivDraw(comboBoxDraws->itemText(index));
     }
 }
 
-void MainWindow::mouseMove(QPointF scenePos){
+void MainWindow::mouseMove(QPointF scenePos)
+{
     QString string = QString("%1, %2")
                             .arg(static_cast<qint32>(toMM(scenePos.x())))
                             .arg(static_cast<qint32>(toMM(scenePos.y())));
     mouseCoordinate->setText(string);
 }
 
-void MainWindow::CanselTool(){
-    switch( tool ){
-    case Tool::ArrowTool:
-        ui->actionArrowTool->setChecked(false);
-        helpLabel->setText("");
-        break;
-    case Tool::SinglePointTool:
-        Q_UNREACHABLE();
-        //Nothing to do here because we can't create this tool from main window.
-        break;
-    case Tool::EndLineTool:
-        dialogEndLine.clear();
-        ui->toolButtonEndLine->setChecked(false);
-        currentScene->setFocus(Qt::OtherFocusReason);
-        currentScene->clearSelection();
-        break;
-    case Tool::LineTool:
-        dialogLine.clear();
-        ui->toolButtonLine->setChecked(false);
-        currentScene->setFocus(Qt::OtherFocusReason);
-        currentScene->clearFocus();
-        break;
-    case Tool::AlongLineTool:
-        dialogAlongLine.clear();
-        ui->toolButtonAlongLine->setChecked(false);
-        currentScene->setFocus(Qt::OtherFocusReason);
-        currentScene->clearSelection();
-        break;
-    case Tool::ShoulderPointTool:
-        dialogShoulderPoint.clear();
-        ui->toolButtonShoulderPoint->setChecked(false);
-        currentScene->setFocus(Qt::OtherFocusReason);
-        currentScene->clearSelection();
-        break;
-    case Tool::NormalTool:
-        dialogNormal.clear();
-        ui->toolButtonNormal->setChecked(false);
-        currentScene->setFocus(Qt::OtherFocusReason);
-        currentScene->clearSelection();
-        break;
-    case Tool::BisectorTool:
-        dialogBisector.clear();
-        ui->toolButtonBisector->setChecked(false);
-        currentScene->setFocus(Qt::OtherFocusReason);
-        currentScene->clearSelection();
-        break;
-    case Tool::LineIntersectTool:
-        dialogLineIntersect.clear();
-        ui->toolButtonLineIntersect->setChecked(false);
-        currentScene->setFocus(Qt::OtherFocusReason);
-        currentScene->clearSelection();
-        break;
-    case Tool::SplineTool:
-        dialogSpline.clear();
-        ui->toolButtonSpline->setChecked(false);
-        currentScene->setFocus(Qt::OtherFocusReason);
-        currentScene->clearSelection();
-        break;
-    case Tool::ArcTool:
-        dialogArc.clear();
-        ui->toolButtonArc->setChecked(false);
-        currentScene->setFocus(Qt::OtherFocusReason);
-        currentScene->clearSelection();
-        break;
-    case Tool::SplinePathTool:
-        dialogSplinePath.clear();
-        ui->toolButtonSplinePath->setChecked(false);
-        currentScene->setFocus(Qt::OtherFocusReason);
-        currentScene->clearSelection();
-        break;
-    case Tool::PointOfContact:
-        dialogPointOfContact.clear();
-        ui->toolButtonPointOfContact->setChecked(false);
-        currentScene->setFocus(Qt::OtherFocusReason);
-        currentScene->clearSelection();
-        break;
-    case Tool::Detail:
-        dialogDetail.clear();
-        ui->toolButtonNewDetail->setChecked(false);
-        break;
-    case Tool::Height:
-        dialogHeight.clear();
-        ui->toolButtonHeight->setChecked(false);
-        currentScene->setFocus(Qt::OtherFocusReason);
-        currentScene->clearSelection();
-        break;
-    case Tool::Triangle:
-        dialogTriangle.clear();
-        ui->toolButtonTriangle->setChecked(false);
-        currentScene->setFocus(Qt::OtherFocusReason);
-        currentScene->clearSelection();
-        break;
-    case Tool::PointOfIntersection:
-        dialogPointOfIntersection.clear();
-        ui->toolButtonPointOfIntersection->setChecked(false);
-        currentScene->setFocus(Qt::OtherFocusReason);
-        currentScene->clearSelection();
-        break;
-    default:
-        qWarning()<<"Get wrong tool type. Ignore.";
-        break;
+void MainWindow::CanselTool()
+{
+    switch ( tool )
+    {
+        case Tool::ArrowTool:
+            ui->actionArrowTool->setChecked(false);
+            helpLabel->setText("");
+            break;
+        case Tool::SinglePointTool:
+            Q_UNREACHABLE();
+            //Nothing to do here because we can't create this tool from main window.
+            break;
+        case Tool::EndLineTool:
+            dialogEndLine.clear();
+            ui->toolButtonEndLine->setChecked(false);
+            currentScene->setFocus(Qt::OtherFocusReason);
+            currentScene->clearSelection();
+            break;
+        case Tool::LineTool:
+            dialogLine.clear();
+            ui->toolButtonLine->setChecked(false);
+            currentScene->setFocus(Qt::OtherFocusReason);
+            currentScene->clearFocus();
+            break;
+        case Tool::AlongLineTool:
+            dialogAlongLine.clear();
+            ui->toolButtonAlongLine->setChecked(false);
+            currentScene->setFocus(Qt::OtherFocusReason);
+            currentScene->clearSelection();
+            break;
+        case Tool::ShoulderPointTool:
+            dialogShoulderPoint.clear();
+            ui->toolButtonShoulderPoint->setChecked(false);
+            currentScene->setFocus(Qt::OtherFocusReason);
+            currentScene->clearSelection();
+            break;
+        case Tool::NormalTool:
+            dialogNormal.clear();
+            ui->toolButtonNormal->setChecked(false);
+            currentScene->setFocus(Qt::OtherFocusReason);
+            currentScene->clearSelection();
+            break;
+        case Tool::BisectorTool:
+            dialogBisector.clear();
+            ui->toolButtonBisector->setChecked(false);
+            currentScene->setFocus(Qt::OtherFocusReason);
+            currentScene->clearSelection();
+            break;
+        case Tool::LineIntersectTool:
+            dialogLineIntersect.clear();
+            ui->toolButtonLineIntersect->setChecked(false);
+            currentScene->setFocus(Qt::OtherFocusReason);
+            currentScene->clearSelection();
+            break;
+        case Tool::SplineTool:
+            dialogSpline.clear();
+            ui->toolButtonSpline->setChecked(false);
+            currentScene->setFocus(Qt::OtherFocusReason);
+            currentScene->clearSelection();
+            break;
+        case Tool::ArcTool:
+            dialogArc.clear();
+            ui->toolButtonArc->setChecked(false);
+            currentScene->setFocus(Qt::OtherFocusReason);
+            currentScene->clearSelection();
+            break;
+        case Tool::SplinePathTool:
+            dialogSplinePath.clear();
+            ui->toolButtonSplinePath->setChecked(false);
+            currentScene->setFocus(Qt::OtherFocusReason);
+            currentScene->clearSelection();
+            break;
+        case Tool::PointOfContact:
+            dialogPointOfContact.clear();
+            ui->toolButtonPointOfContact->setChecked(false);
+            currentScene->setFocus(Qt::OtherFocusReason);
+            currentScene->clearSelection();
+            break;
+        case Tool::Detail:
+            dialogDetail.clear();
+            ui->toolButtonNewDetail->setChecked(false);
+            break;
+        case Tool::Height:
+            dialogHeight.clear();
+            ui->toolButtonHeight->setChecked(false);
+            currentScene->setFocus(Qt::OtherFocusReason);
+            currentScene->clearSelection();
+            break;
+        case Tool::Triangle:
+            dialogTriangle.clear();
+            ui->toolButtonTriangle->setChecked(false);
+            currentScene->setFocus(Qt::OtherFocusReason);
+            currentScene->clearSelection();
+            break;
+        case Tool::PointOfIntersection:
+            dialogPointOfIntersection.clear();
+            ui->toolButtonPointOfIntersection->setChecked(false);
+            currentScene->setFocus(Qt::OtherFocusReason);
+            currentScene->clearSelection();
+            break;
+        default:
+            qWarning()<<"Get wrong tool type. Ignore.";
+            break;
     }
 }
 
-void  MainWindow::ArrowTool(){
+void  MainWindow::ArrowTool()
+{
     CanselTool();
     ui->actionArrowTool->setChecked(true);
     tool = Tool::ArrowTool;
@@ -675,12 +763,15 @@ void  MainWindow::ArrowTool(){
     helpLabel->setText("");
 }
 
-void MainWindow::ActionAroowTool(){
+void MainWindow::ActionAroowTool()
+{
     ArrowTool();
 }
 
-void MainWindow::keyPressEvent ( QKeyEvent * event ){
-    switch(event->key()){
+void MainWindow::keyPressEvent ( QKeyEvent * event )
+{
+    switch (event->key())
+    {
         case Qt::Key_Escape:
             ArrowTool();
             break;
@@ -688,8 +779,10 @@ void MainWindow::keyPressEvent ( QKeyEvent * event ){
     QMainWindow::keyPressEvent ( event );
 }
 
-void MainWindow::ActionDraw(bool checked){
-    if(checked){
+void MainWindow::ActionDraw(bool checked)
+{
+    if (checked)
+    {
         ui->actionDetails->setChecked(false);
         /*Save scroll bars value for previous scene.*/
         QScrollBar *horScrollBar = view->horizontalScrollBar();
@@ -707,13 +800,17 @@ void MainWindow::ActionDraw(bool checked){
 
         mode = Draw::Calculation;
         doc->setCurrentData();
-    } else {
+    }
+    else
+    {
         ui->actionDraw->setChecked(true);
     }
 }
 
-void MainWindow::ActionDetails(bool checked){
-    if(checked){
+void MainWindow::ActionDetails(bool checked)
+{
+    if (checked)
+    {
         ui->actionDraw->setChecked(false);
         /*Save scroll bars value for previous scene.*/
         QScrollBar *horScrollBar = view->horizontalScrollBar();
@@ -729,19 +826,25 @@ void MainWindow::ActionDetails(bool checked){
         verScrollBar = view->verticalScrollBar();
         verScrollBar->setValue(currentScene->getVerScrollBar());
         mode = Draw::Modeling;
-    } else {
+    }
+    else
+    {
         ui->actionDetails->setChecked(true);
     }
 }
 
-void MainWindow::ActionSaveAs(){
+void MainWindow::ActionSaveAs()
+{
     QString filters(tr("Lekalo files (*.xml);;All files (*.*)"));
     QString defaultFilter(tr("Lekalo files (*.xml)"));
     QString fName = QFileDialog::getSaveFileName(this, tr("Save as"), QDir::homePath(),
                                                  filters, &defaultFilter);
-    if(fName.isEmpty())
+    if (fName.isEmpty())
+    {
         return;
-    if(fName.indexOf(".xml",fName.size()-4)<0){
+    }
+    if (fName.indexOf(".xml", fName.size()-4)<0)
+    {
         fName.append(".xml");
     }
     fileName = fName;
@@ -749,17 +852,22 @@ void MainWindow::ActionSaveAs(){
     ActionSave();
 }
 
-void MainWindow::ActionSave(){
-    if(!fileName.isEmpty()){
+void MainWindow::ActionSave()
+{
+    if (fileName.isEmpty() == false)
+    {
         bool result = SafeSaveing(fileName);
-        if(result){
+        if (result)
+        {
             ui->actionSave->setEnabled(false);
             changeInFile = false;
             QFileInfo info(fileName);
             QString title(info.fileName());
             title.append("-Valentina");
             setWindowTitle(title);
-        } else {
+        }
+        else
+        {
             QMessageBox msgBox;
             msgBox.setWindowTitle(tr("Error!"));
             msgBox.setText(tr("Error saving file. Can't save file."));
@@ -771,14 +879,20 @@ void MainWindow::ActionSave(){
     }
 }
 
-void MainWindow::ActionOpen(){
+void MainWindow::ActionOpen()
+{
     QString filter(tr("Lekalo files (*.xml)"));
     QString fName = QFileDialog::getOpenFileName(this, tr("Open file"), QDir::homePath(), filter);
-    if(fName.isEmpty())
+    if (fName.isEmpty())
+    {
         return;
-    if(fileName.isEmpty() && changeInFile == false){
+    }
+    if (fileName.isEmpty() && changeInFile == false)
+    {
         OpenPattern(fName);
-    } else {
+    }
+    else
+    {
         /*Open new copy application*/
         QProcess *v = new QProcess(this);
         QStringList arguments;
@@ -788,7 +902,8 @@ void MainWindow::ActionOpen(){
     }
 }
 
-void MainWindow::Clear(){
+void MainWindow::Clear()
+{
     setWindowTitle("Valentina");
     fileName.clear();
     data->Clear();
@@ -803,14 +918,17 @@ void MainWindow::Clear(){
     SetEnableTool(false);
 }
 
-void MainWindow::ActionNew(){
+void MainWindow::ActionNew()
+{
     QProcess *v = new QProcess(this);
     v->startDetached(QCoreApplication::applicationFilePath ());
     delete v;
 }
 
-void MainWindow::haveChange(){
-    if(!fileName.isEmpty()){
+void MainWindow::haveChange()
+{
+    if (fileName.isEmpty() == false)
+    {
         ui->actionSave->setEnabled(true);
         changeInFile = true;
         QFileInfo info(fileName);
@@ -820,61 +938,75 @@ void MainWindow::haveChange(){
     }
 }
 
-void MainWindow::ChangedSize(const QString & text){
+void MainWindow::ChangedSize(const QString & text)
+{
     qint32 size = text.toInt();
     data->SetSize(size*10);
     doc->FullUpdateTree();
 }
 
-void MainWindow::ChangedGrowth(const QString &text){
+void MainWindow::ChangedGrowth(const QString &text)
+{
     qint32 growth = text.toInt();
     data->SetGrowth(growth*10);
     doc->FullUpdateTree();
 }
 
-void MainWindow::SetEnableWidgets(bool enable){
+void MainWindow::SetEnableWidgets(bool enable)
+{
     ui->actionSaveAs->setEnabled(enable);
     ui->actionDraw->setEnabled(enable);
     ui->actionDetails->setEnabled(enable);
     ui->actionOptionDraw->setEnabled(enable);
-    if(enable == true && !fileName.isEmpty()){
+    if (enable == true && fileName.isEmpty() == false)
+    {
         ui->actionSave->setEnabled(enable);
     }
     ui->actionTable->setEnabled(enable);
     ui->actionHistory->setEnabled(enable);
 }
 
-void MainWindow::ActionTable(bool checked){
-    if(checked){
+void MainWindow::ActionTable(bool checked)
+{
+    if (checked)
+    {
         dialogTable = new DialogIncrements(data, doc, this);
         connect(dialogTable, &DialogIncrements::DialogClosed, this,
                 &MainWindow::ClosedActionTable);
         dialogTable->show();
-    } else {
+    }
+    else
+    {
         ui->actionTable->setChecked(true);
         dialogTable->activateWindow();
     }
 }
 
-void MainWindow::ClosedActionTable(){
+void MainWindow::ClosedActionTable()
+{
     ui->actionTable->setChecked(false);
     delete dialogTable;
 }
 
-void MainWindow::ActionHistory(bool checked){
-    if(checked){
+void MainWindow::ActionHistory(bool checked)
+{
+    if (checked)
+    {
         dialogHistory = new DialogHistory(data, doc, this);
         dialogHistory->setWindowFlags(Qt::Window);
         connect(dialogHistory, &DialogHistory::DialogClosed, this,
                 &MainWindow::ClosedActionHistory);
         dialogHistory->show();
-    } else {
+    }
+    else
+    {
         ui->actionHistory->setChecked(true);
         dialogHistory->activateWindow();
     }
 }
 
-void MainWindow::ActionLayout(bool checked){
+void MainWindow::ActionLayout(bool checked)
+{
     Q_UNUSED(checked);
     hide();
     QVector<VItem*> listDetails;
@@ -882,12 +1014,14 @@ void MainWindow::ActionLayout(bool checked){
     emit ModelChosen(listDetails);
 }
 
-void MainWindow::ClosedActionHistory(){
+void MainWindow::ClosedActionHistory()
+{
     ui->actionHistory->setChecked(false);
     delete dialogHistory;
 }
 
-void MainWindow::SetEnableTool(bool enable){
+void MainWindow::SetEnableTool(bool enable)
+{
     ui->toolButtonEndLine->setEnabled(enable);
     ui->toolButtonLine->setEnabled(enable);
     ui->toolButtonAlongLine->setEnabled(enable);
@@ -905,18 +1039,22 @@ void MainWindow::SetEnableTool(bool enable){
     ui->toolButtonPointOfIntersection->setEnabled(enable);
 }
 
-void MainWindow::MinimumScrollBar(){
+void MainWindow::MinimumScrollBar()
+{
     QScrollBar *horScrollBar = view->horizontalScrollBar();
     horScrollBar->setValue(horScrollBar->minimum());
     QScrollBar *verScrollBar = view->verticalScrollBar();
     verScrollBar->setValue(verScrollBar->minimum());
 }
 
-bool MainWindow::SafeSaveing(const QString &fileName) const{
-    try{
+bool MainWindow::SafeSaveing(const QString &fileName) const
+{
+    try
+    {
         doc->TestUniqueId();
     }
-    catch(const VExceptionUniqueId &e){
+    catch (const VExceptionUniqueId &e)
+    {
         QMessageBox msgBox;
         msgBox.setWindowTitle(tr("Error!"));
         msgBox.setText(tr("Error don't unique id."));
@@ -928,7 +1066,8 @@ bool MainWindow::SafeSaveing(const QString &fileName) const{
         msgBox.exec();
         return false;
     }
-    if(fileName.isEmpty()){
+    if (fileName.isEmpty())
+    {
         qWarning()<<tr("Got empty file name.");
         return false;
     }
@@ -937,7 +1076,8 @@ bool MainWindow::SafeSaveing(const QString &fileName) const{
     QString temp = tempInfo.absolutePath() + "/" + tempInfo.baseName() + ".tmp";
     qDebug()<<"file "<<fileName<<"temp file "<<temp;
     QFile tempFile(temp);
-    if(tempFile.open(QIODevice::WriteOnly| QIODevice::Truncate)){
+    if (tempFile.open(QIODevice::WriteOnly| QIODevice::Truncate))
+    {
         const int Indent = 4;
         QTextStream out(&tempFile);
         doc->save(out, Indent);
@@ -948,31 +1088,42 @@ bool MainWindow::SafeSaveing(const QString &fileName) const{
     QFile patternFile(fileName);
     // We need here temporary file because we need restore pattern after error of copying temp file.
     QTemporaryFile tempOfPattern;
-    if (tempOfPattern.open()) {
+    if (tempOfPattern.open())
+    {
         patternFile.copy(tempOfPattern.fileName());
     }
-    if ( !patternFile.exists() || patternFile.remove() ) {
-        if ( !tempFile.copy(patternFile.fileName()) ){
+    if ( patternFile.exists() == false || patternFile.remove() )
+    {
+        if ( tempFile.copy(patternFile.fileName()) == false )
+        {
             qCritical()<<tr("Could not copy temp file to pattern file")<<Q_FUNC_INFO;
             tempOfPattern.copy(fileName);
             result = false;
-        } else {
+        }
+        else
+        {
             result = true;
         }
-    } else {
+    }
+    else
+    {
         qCritical()<<tr("Could not remove pattern file")<<Q_FUNC_INFO;
         result = false;
     }
-    if(result){
+    if (result)
+    {
         tempFile.remove();
     }
     return result;
 }
 
-void MainWindow::AutoSavePattern(){
-    if(!fileName.isEmpty() && changeInFile == true){
+void MainWindow::AutoSavePattern()
+{
+    if (fileName.isEmpty() == false && changeInFile == true)
+    {
         bool result = SafeSaveing(fileName);
-        if(result){
+        if (result)
+        {
             ui->actionSave->setEnabled(false);
             changeInFile = false;
             QFileInfo info(fileName);
@@ -983,18 +1134,22 @@ void MainWindow::AutoSavePattern(){
     }
 }
 
-MainWindow::~MainWindow(){
+MainWindow::~MainWindow()
+{
     CanselTool();
     delete ui;
 
     delete data;
-    if(!doc->isNull()){
+    if (doc->isNull() == false)
+    {
         delete doc;
     }
 }
 
-void MainWindow::OpenPattern(const QString &fileName){
-    if(fileName.isEmpty()){
+void MainWindow::OpenPattern(const QString &fileName)
+{
+    if (fileName.isEmpty())
+    {
         qWarning()<<tr("Can't open pattern file. File name empty")<<Q_FUNC_INFO;
         return;
     }
@@ -1002,14 +1157,18 @@ void MainWindow::OpenPattern(const QString &fileName){
     QString errorMsg;
     qint32 errorLine = 0;
     qint32 errorColumn = 0;
-    if(file.open(QIODevice::ReadOnly)){
-        if(doc->setContent(&file, &errorMsg, &errorLine, &errorColumn)){
+    if (file.open(QIODevice::ReadOnly))
+    {
+        if (doc->setContent(&file, &errorMsg, &errorLine, &errorColumn))
+        {
             disconnect(comboBoxDraws,  static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
                        this, &MainWindow::currentDrawChanged);
-            try{
-            doc->Parse(Document::FullParse, sceneDraw, sceneDetails);
+            try
+            {
+                doc->Parse(Document::FullParse, sceneDraw, sceneDetails);
             }
-            catch(const VExceptionObjectError &e){
+            catch (const VExceptionObjectError &e)
+            {
                 QMessageBox msgBox;
                 msgBox.setWindowTitle(tr("Error!"));
                 msgBox.setText(tr("Error parsing file."));
@@ -1023,7 +1182,8 @@ void MainWindow::OpenPattern(const QString &fileName){
                 Clear();
                 return;
             }
-            catch(const VExceptionConversionError &e){
+            catch (const VExceptionConversionError &e)
+            {
                 QMessageBox msgBox;
                 msgBox.setWindowTitle(tr("Error!"));
                 msgBox.setText(tr("Error can't convert value."));
@@ -1036,7 +1196,8 @@ void MainWindow::OpenPattern(const QString &fileName){
                 Clear();
                 return;
             }
-            catch(const VExceptionEmptyParameter &e){
+            catch (const VExceptionEmptyParameter &e)
+            {
                 QMessageBox msgBox;
                 msgBox.setWindowTitle(tr("Error!"));
                 msgBox.setText(tr("Error empty parameter."));
@@ -1050,7 +1211,8 @@ void MainWindow::OpenPattern(const QString &fileName){
                 Clear();
                 return;
             }
-            catch(const VExceptionWrongParameterId &e){
+            catch (const VExceptionWrongParameterId &e)
+            {
                 QMessageBox msgBox;
                 msgBox.setWindowTitle(tr("Error!"));
                 msgBox.setText(tr("Error wrong id."));
@@ -1064,7 +1226,8 @@ void MainWindow::OpenPattern(const QString &fileName){
                 Clear();
                 return;
             }
-            catch(const VExceptionUniqueId &e){
+            catch (const VExceptionUniqueId &e)
+            {
                 QMessageBox msgBox;
                 msgBox.setWindowTitle(tr("Error!"));
                 msgBox.setText(tr("Error don't unique id."));
@@ -1082,16 +1245,22 @@ void MainWindow::OpenPattern(const QString &fileName){
                     this, &MainWindow::currentDrawChanged);
             QString nameDraw = doc->GetNameActivDraw();
             qint32 index = comboBoxDraws->findText(nameDraw);
-            if ( index != -1 ) { // -1 for not found
+            if ( index != -1 )
+            { // -1 for not found
                 comboBoxDraws->setCurrentIndex(index);
             }
-            if(comboBoxDraws->count() > 0){
+            if (comboBoxDraws->count() > 0)
+            {
                 SetEnableTool(true);
-            } else {
+            }
+            else
+            {
                 SetEnableTool(false);
             }
             SetEnableWidgets(true);
-        } else {
+        }
+        else
+        {
             QMessageBox msgBox;
             msgBox.setWindowTitle(tr("Error!"));
             msgBox.setText(tr("Error parsing pattern file."));
diff --git a/mainwindow.h b/mainwindow.h
index 76a331375..5d8027420 100644
--- a/mainwindow.h
+++ b/mainwindow.h
@@ -32,14 +32,16 @@
 #include "tools/modelingTools/modelingtools.h"
 #include "xml/vdomdocument.h"
 
-namespace Ui {
-class MainWindow;
+namespace Ui
+{
+    class MainWindow;
 }
 
-class MainWindow : public QMainWindow{
-    Q_OBJECT    
+class MainWindow : public QMainWindow
+{
+    Q_OBJECT
 public:
-    explicit           MainWindow(QWidget *parent = 0);
+              explicit MainWindow(QWidget *parent = 0);
                        ~MainWindow();
     void               OpenPattern(const QString &fileName);
 public slots:
@@ -152,9 +154,8 @@ private:
     void               SetEnableWidgets(bool enable);
     void               SetEnableTool(bool enable);
     template <typename Dialog, typename Func>
-    void               SetToolButton(bool checked, Tool::Tools t, const QString &cursor,
-                                     const QString &toolTip,QSharedPointer<Dialog> &dialog,
-                                     Func closeDialogSlot);
+    void               SetToolButton(bool checked, Tool::Tools t, const QString &cursor, const QString &toolTip,
+                                     QSharedPointer<Dialog> &dialog, Func closeDialogSlot);
     void               MinimumScrollBar();
     template <typename T>
     void               AddToolToDetail(T *tool, const qint64 &id, Tool::Tools typeTool,
diff --git a/options.h b/options.h
index 06dcc5a69..bf2fbad48 100644
--- a/options.h
+++ b/options.h
@@ -31,44 +31,49 @@
 #define widthMainLine toPixel(1.2)
 #define widthHairLine widthMainLine/3
 
-namespace Scene{
-enum Scene { Point, Line, Spline, Arc, SplinePath, Detail };
-Q_DECLARE_FLAGS(Scenes, Scene)
+namespace Scene
+{
+    enum Scene { Point, Line, Spline, Arc, SplinePath, Detail };
+    Q_DECLARE_FLAGS(Scenes, Scene)
 }
 Q_DECLARE_OPERATORS_FOR_FLAGS( Scene::Scenes )
 
-namespace Tool{
-enum Tool {ArrowTool,
-           SinglePointTool,
-           EndLineTool,
-           LineTool,
-           AlongLineTool,
-           ShoulderPointTool,
-           NormalTool,
-           BisectorTool,
-           LineIntersectTool,
-           SplineTool,
-           ArcTool,
-           SplinePathTool,
-           PointOfContact,
-           Detail,
-           NodePoint,
-           NodeArc,
-           NodeSpline,
-           NodeSplinePath,
-           Height,
-           Triangle,
-           PointOfIntersection
-};
-Q_DECLARE_FLAGS(Tools, Tool)
+namespace Tool
+{
+    enum Tool
+    {
+        ArrowTool,
+        SinglePointTool,
+        EndLineTool,
+        LineTool,
+        AlongLineTool,
+        ShoulderPointTool,
+        NormalTool,
+        BisectorTool,
+        LineIntersectTool,
+        SplineTool,
+        ArcTool,
+        SplinePathTool,
+        PointOfContact,
+        Detail,
+        NodePoint,
+        NodeArc,
+        NodeSpline,
+        NodeSplinePath,
+        Height,
+        Triangle,
+        PointOfIntersection
+    };
+    Q_DECLARE_FLAGS(Tools, Tool)
 
-enum Source { FromGui, FromFile };
-Q_DECLARE_FLAGS(Sources, Source)
+    enum Source { FromGui, FromFile };
+    Q_DECLARE_FLAGS(Sources, Source)
 }
 Q_DECLARE_OPERATORS_FOR_FLAGS( Tool::Tools )
 Q_DECLARE_OPERATORS_FOR_FLAGS( Tool::Sources )
 
-namespace Draw  {
+namespace Draw
+{
     enum Draw { Calculation, Modeling };
     Q_DECLARE_FLAGS(Draws, Draw)
 }
diff --git a/tablewindow.cpp b/tablewindow.cpp
index c23c5c1f1..d597590ff 100644
--- a/tablewindow.cpp
+++ b/tablewindow.cpp
@@ -24,11 +24,12 @@
 #include "widgets/vtablegraphicsview.h"
 #include "options.h"
 
-TableWindow::TableWindow(QWidget *parent) :
-    QMainWindow(parent), numberDetal(0), colission(0), ui(new Ui::TableWindow),
+TableWindow::TableWindow(QWidget *parent)
+    :QMainWindow(parent), numberDetal(0), colission(0), ui(new Ui::TableWindow),
     listDetails(QVector<VItem*>()), outItems(false), collidingItems(false), currentScene(0),
     paper(0), shadowPaper(0), listOutItems(0), listCollidingItems(QList<QGraphicsItem*>()),
-    indexDetail(0), sceneRect(QRectF()){
+    indexDetail(0), sceneRect(QRectF())
+{
     ui->setupUi(this);
     numberDetal = new QLabel("Залишилось 0 деталей.", this);
     colission = new QLabel("Колізій не знайдено.", this);
@@ -43,7 +44,7 @@ TableWindow::TableWindow(QWidget *parent) :
     brush->setColor( QColor( Qt::gray ) );
     currentScene->setBackgroundBrush( *brush );
     VTableGraphicsView* view = new VTableGraphicsView(currentScene);
-    view->fitInView(view->scene()->sceneRect(),Qt::KeepAspectRatio);
+    view->fitInView(view->scene()->sceneRect(), Qt::KeepAspectRatio);
     ui->horizontalLayout->addWidget(view);
     connect(ui->actionTurn, &QAction::triggered, view, &VTableGraphicsView::rotateItems);
     connect(ui->actionMirror, &QAction::triggered, view, &VTableGraphicsView::MirrorItem);
@@ -57,30 +58,34 @@ TableWindow::TableWindow(QWidget *parent) :
     connect(view, &VTableGraphicsView::itemChect, this, &TableWindow::itemChect);
 }
 
-TableWindow::~TableWindow(){
+TableWindow::~TableWindow()
+{
     delete ui;
 }
 
-void TableWindow::AddPaper(){
+void TableWindow::AddPaper()
+{
     qreal x1, y1, x2, y2;
     sceneRect.getCoords(&x1, &y1, &x2, &y2);
-    shadowPaper = new QGraphicsRectItem(QRectF(x1+4,y1+4,x2+4, y2+4));
+    shadowPaper = new QGraphicsRectItem(QRectF(x1+4, y1+4, x2+4, y2+4));
     shadowPaper->setBrush(QBrush(Qt::black));
     currentScene->addItem(shadowPaper);
-    paper = new QGraphicsRectItem(QRectF(x1,y1,x2, y2));
+    paper = new QGraphicsRectItem(QRectF(x1, y1, x2, y2));
     paper->setPen(QPen(Qt::black, toPixel(widthMainLine)));
     paper->setBrush(QBrush(Qt::white));
     currentScene->addItem(paper);
     qDebug()<<paper->rect().size().toSize();
 }
 
-void TableWindow::AddDetail(){
-    if(indexDetail<listDetails.count()){
+void TableWindow::AddDetail()
+{
+    if (indexDetail<listDetails.count())
+    {
         currentScene->clearSelection();
         VItem* Detail = listDetails[indexDetail];
-        QObject::connect(Detail, SIGNAL(itemOut(int,bool)), this, SLOT(itemOut(int,bool)));
-        QObject::connect(Detail, SIGNAL(itemColliding(QList<QGraphicsItem*>,int)), this,
-                         SLOT(itemColliding(QList<QGraphicsItem*>,int)));
+        QObject::connect(Detail, SIGNAL(itemOut(int, bool)), this, SLOT(itemOut(int, bool)));
+        QObject::connect(Detail, SIGNAL(itemColliding(QList<QGraphicsItem*>, int)), this,
+                         SLOT(itemColliding(QList<QGraphicsItem*>, int)));
         QObject::connect(this, SIGNAL(LengthChanged()), Detail, SLOT(LengthChanged()));
         Detail->setPen(QPen(Qt::black, toPixel(widthMainLine)));
         Detail->setBrush(QBrush(Qt::white));
@@ -91,7 +96,8 @@ void TableWindow::AddDetail(){
         Detail->setParentItem(paper);
         Detail->setSelected(true);
         indexDetail++;
-        if(indexDetail==listDetails.count()){
+        if (indexDetail==listDetails.count())
+        {
             ui->actionSave->setEnabled(true);
         }
     }
@@ -101,7 +107,8 @@ void TableWindow::AddDetail(){
 /*
  * Отримуємо деталі розрахованої моделі для подальшого укладання.
  */
-void TableWindow::ModelChosen(QVector<VItem*> listDetails){
+void TableWindow::ModelChosen(QVector<VItem*> listDetails)
+{
     this->listDetails = listDetails;
     listOutItems = new QBitArray(this->listDetails.count());
     AddPaper();
@@ -110,23 +117,27 @@ void TableWindow::ModelChosen(QVector<VItem*> listDetails){
     show();
 }
 
-void TableWindow::closeEvent(QCloseEvent *event){
+void TableWindow::closeEvent(QCloseEvent *event)
+{
     event->ignore();
     StopTable();
 }
 
-void TableWindow::moveToCenter(){
+void TableWindow::moveToCenter()
+{
     QRect rect = frameGeometry();
     rect.moveCenter(QDesktopWidget().availableGeometry().center());
     move(rect.topLeft());
 }
 
-void TableWindow::showEvent ( QShowEvent * event ){
+void TableWindow::showEvent ( QShowEvent * event )
+{
     QMainWindow::showEvent(event);
     moveToCenter();
 }
 
-void TableWindow::StopTable(){
+void TableWindow::StopTable()
+{
     hide();
     currentScene->clear();
     delete listOutItems;
@@ -136,9 +147,11 @@ void TableWindow::StopTable(){
     emit closed();
 }
 
-void TableWindow::saveScene(){
+void TableWindow::saveScene()
+{
     QString name = QFileDialog::getSaveFileName(0, tr("Save layout"), "", "Images (*.png);;Svg files (*.svg)");
-    if(name.isNull()){
+    if (name.isNull())
+    {
         return;
     }
 
@@ -153,9 +166,12 @@ void TableWindow::saveScene(){
     currentScene->setSceneRect(currentScene->itemsBoundingRect());
 
     QFileInfo fi(name);
-    if(fi.suffix() == "svg"){
+    if (fi.suffix() == "svg")
+    {
         SvgFile(name);
-    } else if(fi.suffix() == "png"){
+    }
+    else if (fi.suffix() == "png")
+    {
         PngFile(name);
     }
 
@@ -166,32 +182,43 @@ void TableWindow::saveScene(){
     shadowPaper->setBrush(QBrush(Qt::black));
 }
 
-void TableWindow::itemChect(bool flag){
+void TableWindow::itemChect(bool flag)
+{
     ui->actionTurn->setDisabled(flag);
     ui->actionMirror->setDisabled(flag);
 }
 
-void TableWindow::checkNext(){
-    if(outItems == true && collidingItems == true){
+void TableWindow::checkNext()
+{
+    if (outItems == true && collidingItems == true)
+    {
         colission->setText("Колізій не знайдено.");
-        if(indexDetail==listDetails.count()){
+        if (indexDetail==listDetails.count())
+        {
             ui->actionSave->setEnabled(true);
             ui->actionNext->setDisabled(true);
-        } else {
+        }
+        else
+        {
             ui->actionNext->setDisabled(false);
             ui->actionSave->setEnabled(false);
         }
-    } else {
+    }
+    else
+    {
         colission->setText("Знайдено колізії.");
         ui->actionNext->setDisabled(true);
         ui->actionSave->setEnabled(false);
     }
 }
 
-void TableWindow::itemOut(int number, bool flag){
-    listOutItems->setBit(number,flag);
-    for( int i = 0; i < listOutItems->count(); ++i ){
-        if(listOutItems->at(i)==true){
+void TableWindow::itemOut(int number, bool flag)
+{
+    listOutItems->setBit(number, flag);
+    for ( int i = 0; i < listOutItems->count(); ++i )
+    {
+        if (listOutItems->at(i)==true)
+        {
             outItems=false;
             qDebug()<<"itemOut::outItems="<<outItems<<"&& collidingItems"<<collidingItems;
             checkNext();
@@ -202,50 +229,75 @@ void TableWindow::itemOut(int number, bool flag){
     checkNext();
 }
 
-void TableWindow::itemColliding(QList<QGraphicsItem *> list, int number){
+void TableWindow::itemColliding(QList<QGraphicsItem *> list, int number)
+{
     //qDebug()<<"number="<<number;
-    if(number==0){
-        if(listCollidingItems.isEmpty()==false){
-            if(listCollidingItems.contains(list.at(0))==true){
+    if (number==0)
+    {
+        if (listCollidingItems.isEmpty()==false)
+        {
+            if (listCollidingItems.contains(list.at(0))==true)
+            {
                 listCollidingItems.removeAt(listCollidingItems.indexOf(list.at(0)));
-                if(listCollidingItems.size()>1){
-                    for( int i = 0; i < listCollidingItems.count(); ++i ){
-                        QList<QGraphicsItem *> l = listCollidingItems.at(i)->collidingItems();
-                        if(l.size()-2 <= 0){
+                if (listCollidingItems.size()>1)
+                {
+                    for ( int i = 0; i < listCollidingItems.count(); ++i )
+                    {
+                        QList<QGraphicsItem *> lis = listCollidingItems.at(i)->collidingItems();
+                        if (lis.size()-2 <= 0)
+                        {
                             VItem * bitem = qgraphicsitem_cast<VItem *> ( listCollidingItems.at(i) );
-                            if (bitem == 0){
+                            if (bitem == 0)
+                            {
                                 qDebug()<<"Не можу привести тип об'єкту";
-                            } else {
+                            }
+                            else
+                            {
                                 bitem->setPen(QPen(Qt::black, toPixel(widthMainLine)));
                             }
                             listCollidingItems.removeAt(i);
                         }
                     }
-                } else if(listCollidingItems.size()==1){
+                }
+                else if (listCollidingItems.size()==1)
+                {
                     VItem * bitem = qgraphicsitem_cast<VItem *> ( listCollidingItems.at(0) );
-                    if (bitem == 0){
+                    if (bitem == 0)
+                    {
                         qDebug()<<"Не можу привести тип об'єкту";
-                    } else {
+                    }
+                    else
+                    {
                         bitem->setPen(QPen(Qt::black, toPixel(widthMainLine)));
                     }
                     listCollidingItems.clear();
                     collidingItems = true;
                 }
-            } else {
+            }
+            else
+            {
                 collidingItems = true;
             }
-        } else {
+        }
+        else
+        {
             collidingItems = true;
         }
-    } else if(number==1){
-        if(list.contains(paper)==true){
+    }
+    else if (number==1)
+    {
+        if (list.contains(paper)==true)
+        {
             list.removeAt(list.indexOf(paper));
         }
-        if(list.contains(shadowPaper)==true){
+        if (list.contains(shadowPaper)==true)
+        {
             list.removeAt(list.indexOf(shadowPaper));
         }
-        for( int i = 0; i < list.count(); ++i ){
-            if(listCollidingItems.contains(list.at(i))==false){
+        for ( int i = 0; i < list.count(); ++i )
+        {
+            if (listCollidingItems.contains(list.at(i))==false)
+            {
                 listCollidingItems.append(list.at(i));
             }
         }
@@ -255,11 +307,13 @@ void TableWindow::itemColliding(QList<QGraphicsItem *> list, int number){
     checkNext();
 }
 
-void TableWindow::GetNextDetail(){
+void TableWindow::GetNextDetail()
+{
     AddDetail();
 }
 
-void TableWindow::AddLength(){
+void TableWindow::AddLength()
+{
     QRectF rect = currentScene->sceneRect();
     rect.setHeight(rect.height()+toPixel(279));
     currentScene->setSceneRect(rect);
@@ -273,8 +327,10 @@ void TableWindow::AddLength(){
     emit LengthChanged();
 }
 
-void TableWindow::RemoveLength(){
-    if(sceneRect.height()<=currentScene->sceneRect().height()-100){
+void TableWindow::RemoveLength()
+{
+    if (sceneRect.height()<=currentScene->sceneRect().height()-100)
+    {
         QRectF rect = currentScene->sceneRect();
         rect.setHeight(rect.height()-toPixel(279));
         currentScene->setSceneRect(rect);
@@ -284,18 +340,24 @@ void TableWindow::RemoveLength(){
         rect = paper->rect();
         rect.setHeight(rect.height()-toPixel(279));
         paper->setRect(rect);
-        if(sceneRect.height()==currentScene->sceneRect().height()){
+        if (sceneRect.height()==currentScene->sceneRect().height())
+        {
             ui->actionRemove->setDisabled(true);
         }
         emit LengthChanged();
-    } else {
+    }
+    else
+    {
         ui->actionRemove->setDisabled(true);
     }
 }
 
-void TableWindow::keyPressEvent ( QKeyEvent * event ){
-    if( event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return ){
-        if(ui->actionNext->isEnabled() == true ){
+void TableWindow::keyPressEvent ( QKeyEvent * event )
+{
+    if ( event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return )
+    {
+        if (ui->actionNext->isEnabled() == true )
+        {
             AddDetail();
             qDebug()<<"Додали деталь.";
         }
@@ -304,7 +366,8 @@ void TableWindow::keyPressEvent ( QKeyEvent * event ){
 }
 
 
-void TableWindow::SvgFile(const QString &name) const{
+void TableWindow::SvgFile(const QString &name) const
+{
     QSvgGenerator generator;
     generator.setFileName(name);
     generator.setSize(paper->rect().size().toSize());
@@ -322,11 +385,13 @@ void TableWindow::SvgFile(const QString &name) const{
     painter.end();
 }
 
-void TableWindow::PngFile(const QString &name) const{
+void TableWindow::PngFile(const QString &name) const
+{
     QRectF r = paper->rect();
     qreal x=0, y=0, w=0, h=0;
-    r.getRect(&x,&y,&w,&h);// Re-shrink the scene to it's bounding contents
-    QImage image(QSize(static_cast<qint32>(w), static_cast<qint32>(h)), QImage::Format_ARGB32);  // Create the image with the exact size of the shrunk scene
+    r.getRect(&x, &y, &w, &h);// Re-shrink the scene to it's bounding contents
+    // Create the image with the exact size of the shrunk scene
+    QImage image(QSize(static_cast<qint32>(w), static_cast<qint32>(h)), QImage::Format_ARGB32);
     image.fill(Qt::transparent);                                              // Start all pixels transparent
     QPainter painter(&image);
     painter.setFont( QFont( "Arial", 8, QFont::Normal ) );
diff --git a/tablewindow.h b/tablewindow.h
index bda643db8..33facb88e 100644
--- a/tablewindow.h
+++ b/tablewindow.h
@@ -25,14 +25,16 @@
 #include <QMainWindow>
 #include "widgets/vitem.h"
 
-namespace Ui {
+namespace Ui
+{
     class TableWindow;
 }
 
 /**
  * @brief TableWindow клас вікна створення розкладки.
  */
-class TableWindow : public QMainWindow{
+class TableWindow : public QMainWindow
+{
     Q_OBJECT
 public:
     /**
@@ -47,7 +49,7 @@ public:
      * @brief TableWindow Конструктор класу вікна створення розкладки.
      * @param parent Батько об'єкту. За замовчуванням = 0.
      */
-    explicit              TableWindow(QWidget *parent = 0);
+                 explicit TableWindow(QWidget *parent = 0);
     /**
      * @brief ~TableWindow Деструктор класу вікна.
      */
diff --git a/tools/drawTools/vdrawtool.cpp b/tools/drawTools/vdrawtool.cpp
index b6290d45a..28e3a859b 100644
--- a/tools/drawTools/vdrawtool.cpp
+++ b/tools/drawTools/vdrawtool.cpp
@@ -23,24 +23,31 @@
 
 qreal VDrawTool::factor = 1;
 
-VDrawTool::VDrawTool(VDomDocument *doc, VContainer *data, qint64 id, QObject *parent) :
-    VAbstractTool(doc, data, id, parent), ignoreContextMenuEvent(false), ignoreFullUpdate(false),
-    nameActivDraw(doc->GetNameActivDraw()){
+VDrawTool::VDrawTool(VDomDocument *doc, VContainer *data, qint64 id, QObject *parent)
+    :VAbstractTool(doc, data, id, parent), ignoreContextMenuEvent(false), ignoreFullUpdate(false),
+    nameActivDraw(doc->GetNameActivDraw())
+{
     connect(this->doc, &VDomDocument::ChangedActivDraw, this, &VDrawTool::ChangedActivDraw);
     connect(this->doc, &VDomDocument::ChangedNameDraw, this, &VDrawTool::ChangedNameDraw);
     connect(this->doc, &VDomDocument::ShowTool, this, &VDrawTool::ShowTool);
 }
 
-void VDrawTool::AddRecord(const qint64 id, Tool::Tools toolType, VDomDocument *doc){
+void VDrawTool::AddRecord(const qint64 id, Tool::Tools toolType, VDomDocument *doc)
+{
     qint64 cursor = doc->getCursor();
     QVector<VToolRecord> *history = doc->getHistory();
-    if(cursor <= 0){
+    if (cursor <= 0)
+    {
         history->append(VToolRecord(id, toolType, doc->GetNameActivDraw()));
-    } else {
+    }
+    else
+    {
         qint32 index = 0;
-        for(qint32 i = 0; i<history->size(); ++i){
+        for (qint32 i = 0; i<history->size(); ++i)
+        {
             VToolRecord rec = history->at(i);
-            if(rec.getId() == cursor){
+            if (rec.getId() == cursor)
+            {
                 index = i;
                 break;
             }
@@ -49,49 +56,68 @@ void VDrawTool::AddRecord(const qint64 id, Tool::Tools toolType, VDomDocument *d
     }
 }
 
-void VDrawTool::ShowTool(qint64 id, Qt::GlobalColor color, bool enable){
+void VDrawTool::ShowTool(qint64 id, Qt::GlobalColor color, bool enable)
+{
     Q_UNUSED(id);
     Q_UNUSED(color);
     Q_UNUSED(enable);
 }
 
-void VDrawTool::ChangedActivDraw(const QString newName){
-    if(nameActivDraw == newName){
+void VDrawTool::ChangedActivDraw(const QString newName)
+{
+    if (nameActivDraw == newName)
+    {
         ignoreContextMenuEvent = false;
-    } else {
+    }
+    else
+    {
         ignoreContextMenuEvent = true;
     }
 }
 
-void VDrawTool::ChangedNameDraw(const QString oldName, const QString newName){
-    if(nameActivDraw == oldName){
+void VDrawTool::ChangedNameDraw(const QString oldName, const QString newName)
+{
+    if (nameActivDraw == oldName)
+    {
         nameActivDraw = newName;
     }
 }
 
-void VDrawTool::SetFactor(qreal factor){
-    if(factor <= 2 && factor >= 0.5){
+void VDrawTool::SetFactor(qreal factor)
+{
+    if (factor <= 2 && factor >= 0.5)
+    {
         this->factor = factor;
     }
 }
 
-void VDrawTool::AddToCalculation(const QDomElement &domElement){
+void VDrawTool::AddToCalculation(const QDomElement &domElement)
+{
     QDomElement calcElement;
     bool ok = doc->GetActivCalculationElement(calcElement);
-    if(ok){
+    if (ok)
+    {
         qint64 id = doc->getCursor();
-        if(id <= 0){
+        if (id <= 0)
+        {
             calcElement.appendChild(domElement);
-        } else {
+        }
+        else
+        {
             QDomElement refElement = doc->elementById(QString().setNum(doc->getCursor()));
-            if(refElement.isElement()){
-                calcElement.insertAfter(domElement,refElement);
+            if (refElement.isElement())
+            {
+                calcElement.insertAfter(domElement, refElement);
                 doc->setCursor(0);
-            } else {
+            }
+            else
+            {
                 qCritical()<<tr("Can not find the element after which you want to insert.")<< Q_FUNC_INFO;
             }
         }
-    } else {
+    }
+    else
+    {
         qCritical()<<tr("Can't find tag Calculation")<< Q_FUNC_INFO;
     }
     emit toolhaveChange();
diff --git a/tools/drawTools/vdrawtool.h b/tools/drawTools/vdrawtool.h
index e761422ee..215a48ba9 100644
--- a/tools/drawTools/vdrawtool.h
+++ b/tools/drawTools/vdrawtool.h
@@ -24,7 +24,8 @@
 
 #include "../vabstracttool.h"
 
-class VDrawTool : public VAbstractTool{
+class VDrawTool : public VAbstractTool
+{
     Q_OBJECT
 public:
                  VDrawTool(VDomDocument *doc, VContainer *data, qint64 id, QObject *parent = 0);
@@ -46,29 +47,37 @@ protected:
     void         AddToCalculation(const QDomElement &domElement);
     template <typename Dialog, typename Tool>
     void ContextMenu(QSharedPointer<Dialog> &dialog, Tool *tool, QGraphicsSceneContextMenuEvent *event,
-                     bool showRemove = true){
+                     bool showRemove = true)
+    {
         Q_ASSERT(tool != 0);
         Q_ASSERT(event != 0);
-        if(!ignoreContextMenuEvent){
+        if (ignoreContextMenuEvent == false)
+        {
             QMenu menu;
             QAction *actionOption = menu.addAction(tr("Options"));
             QAction *actionRemove = 0;
-            if(showRemove){
+            if (showRemove)
+            {
                 actionRemove = menu.addAction(tr("Delete"));
-                if(_referens > 1){
+                if (_referens > 1)
+                {
                     actionRemove->setEnabled(false);
-                } else {
+                }
+                else
+                {
                     actionRemove->setEnabled(true);
                 }
             }
             QAction *selectedAction = menu.exec(event->screenPos());
-            if(selectedAction == actionOption){
+            if (selectedAction == actionOption)
+            {
                 dialog = QSharedPointer<Dialog>(new Dialog(getData()));
 
                 connect(qobject_cast< VMainGraphicsScene * >(tool->scene()),
                         &VMainGraphicsScene::ChoosedObject, dialog.data(), &Dialog::ChoosedObject);
                 connect(dialog.data(), &Dialog::DialogClosed, tool, &Tool::FullUpdateFromGui);
-                if(!ignoreFullUpdate){
+                if (ignoreFullUpdate == false)
+                {
                     connect(doc, &VDomDocument::FullUpdateFromFile, dialog.data(), &Dialog::UpdateList);
                 }
 
@@ -76,16 +85,20 @@ protected:
 
                 dialog->show();
             }
-            if(showRemove){
-                if(selectedAction == actionRemove){
+            if (showRemove)
+            {
+                if (selectedAction == actionRemove)
+                {
                     //deincrement referens
                     RemoveReferens();
                     //remove form xml file
                     QDomElement domElement = doc->elementById(QString().setNum(id));
-                    if(domElement.isElement()){
+                    if (domElement.isElement())
+                    {
                         QDomElement element;
                         bool ok = doc->GetActivCalculationElement(element);
-                        if(ok){
+                        if (ok)
+                        {
                             element.removeChild(domElement);
                             //update xml file
                             emit FullUpdateTree();
@@ -98,12 +111,17 @@ protected:
         }
     }
     template <typename Item>
-    void ShowItem(Item *item, qint64 id, Qt::GlobalColor color, bool enable){
+    void ShowItem(Item *item, qint64 id, Qt::GlobalColor color, bool enable)
+    {
         Q_ASSERT(item != 0);
-        if(id == item->id){
-            if(enable == false){
+        if (id == item->id)
+        {
+            if (enable == false)
+            {
                 currentColor = baseColor;
-            } else {
+            }
+            else
+            {
                 currentColor = color;
             }
             item->setPen(QPen(currentColor, widthHairLine/factor));
diff --git a/tools/drawTools/vtoolalongline.cpp b/tools/drawTools/vtoolalongline.cpp
index 3df25583e..e95cd586e 100644
--- a/tools/drawTools/vtoolalongline.cpp
+++ b/tools/drawTools/vtoolalongline.cpp
@@ -27,18 +27,22 @@ const QString VToolAlongLine::ToolType = QStringLiteral("alongLine");
 VToolAlongLine::VToolAlongLine(VDomDocument *doc, VContainer *data, qint64 id, const QString &formula,
                                const qint64 &firstPointId, const qint64 &secondPointId,
                                const QString &typeLine, Tool::Sources typeCreation,
-                               QGraphicsItem *parent):
-    VToolLinePoint(doc, data, id, typeLine, formula, firstPointId, 0, parent), secondPointId(secondPointId),
-    dialogAlongLine(QSharedPointer<DialogAlongLine>()){
+                               QGraphicsItem *parent)
+    :VToolLinePoint(doc, data, id, typeLine, formula, firstPointId, 0, parent), secondPointId(secondPointId),
+    dialogAlongLine(QSharedPointer<DialogAlongLine>())
+{
 
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VToolAlongLine::FullUpdateFromFile(){
+void VToolAlongLine::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         typeLine = domElement.attribute(AttrTypeLine, "");
         formula = domElement.attribute(AttrLength, "");
         basePointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
@@ -47,10 +51,13 @@ void VToolAlongLine::FullUpdateFromFile(){
     RefreshGeometry();
 }
 
-void VToolAlongLine::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolAlongLine::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogAlongLine->getPointName());
             domElement.setAttribute(AttrTypeLine, dialogAlongLine->getTypeLine());
             domElement.setAttribute(AttrLength, dialogAlongLine->getFormula());
@@ -62,16 +69,19 @@ void VToolAlongLine::FullUpdateFromGui(int result){
     dialogAlongLine.clear();
 }
 
-void VToolAlongLine::SetFactor(qreal factor){
+void VToolAlongLine::SetFactor(qreal factor)
+{
     VDrawTool::SetFactor(factor);
     RefreshGeometry();
 }
 
-void VToolAlongLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolAlongLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogAlongLine, this, event);
 }
 
-void VToolAlongLine::AddToFile(){
+void VToolAlongLine::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -89,25 +99,26 @@ void VToolAlongLine::AddToFile(){
     AddToCalculation(domElement);
 }
 
-void VToolAlongLine::RemoveReferens(){
+void VToolAlongLine::RemoveReferens()
+{
     doc->DecrementReferens(secondPointId);
     VToolLinePoint::RemoveReferens();
 }
 
-void VToolAlongLine::setDialog(){
-    Q_ASSERT(!dialogAlongLine.isNull());
-    if(!dialogAlongLine.isNull()){
-        VPointF p = VAbstractTool::data.GetPoint(id);
-        dialogAlongLine->setTypeLine(typeLine);
-        dialogAlongLine->setFormula(formula);
-        dialogAlongLine->setFirstPointId(basePointId, id);
-        dialogAlongLine->setSecondPointId(secondPointId, id);
-        dialogAlongLine->setPointName(p.name());
-    }
+void VToolAlongLine::setDialog()
+{
+    Q_ASSERT(dialogAlongLine.isNull() == false);
+    VPointF p = VAbstractTool::data.GetPoint(id);
+    dialogAlongLine->setTypeLine(typeLine);
+    dialogAlongLine->setFormula(formula);
+    dialogAlongLine->setFirstPointId(basePointId, id);
+    dialogAlongLine->setSecondPointId(secondPointId, id);
+    dialogAlongLine->setPointName(p.name());
 }
 
 void VToolAlongLine::Create(QSharedPointer<DialogAlongLine> &dialog, VMainGraphicsScene *scene,
-                            VDomDocument *doc, VContainer *data){
+                            VDomDocument *doc, VContainer *data)
+{
     QString formula = dialog->getFormula();
     qint64 firstPointId = dialog->getFirstPointId();
     qint64 secondPointId = dialog->getSecondPointId();
@@ -120,30 +131,37 @@ void VToolAlongLine::Create(QSharedPointer<DialogAlongLine> &dialog, VMainGraphi
 void VToolAlongLine::Create(const qint64 _id, const QString &pointName, const QString &typeLine,
                             const QString &formula, const qint64 &firstPointId, const qint64 &secondPointId,
                             const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VDomDocument *doc,
-                            VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation){
+                            VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation)
+{
     VPointF firstPoint = data->GetPoint(firstPointId);
     VPointF secondPoint = data->GetPoint(secondPointId);
     QLineF line = QLineF(firstPoint.toQPointF(), secondPoint.toQPointF());
     Calculator cal(data);
     QString errorMsg;
     qreal result = cal.eval(formula, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         line.setLength(toPixel(result));
         qint64 id = _id;
-        if(typeCreation == Tool::FromGui){
+        if (typeCreation == Tool::FromGui)
+        {
             id = data->AddPoint(VPointF(line.p2().x(), line.p2().y(), pointName, mx, my));
             data->AddLine(firstPointId, id);
             data->AddLine(id, secondPointId);
-        } else {
+        }
+        else
+        {
             data->UpdatePoint(id, VPointF(line.p2().x(), line.p2().y(), pointName, mx, my));
             data->AddLine(firstPointId, id);
             data->AddLine(id, secondPointId);
-            if(parse != Document::FullParse){
+            if (parse != Document::FullParse)
+            {
                 doc->UpdateToolData(id, data);
             }
         }
         VDrawTool::AddRecord(id, Tool::AlongLineTool, doc);
-        if(parse == Document::FullParse){
+        if (parse == Document::FullParse)
+        {
             VToolAlongLine *point = new VToolAlongLine(doc, data, id, formula, firstPointId,
                                                        secondPointId, typeLine, typeCreation);
             scene->addItem(point);
diff --git a/tools/drawTools/vtoolalongline.h b/tools/drawTools/vtoolalongline.h
index 35734aab9..22b0e7996 100644
--- a/tools/drawTools/vtoolalongline.h
+++ b/tools/drawTools/vtoolalongline.h
@@ -25,7 +25,8 @@
 #include "vtoollinepoint.h"
 #include "dialogs/dialogalongline.h"
 
-class VToolAlongLine : public VToolLinePoint{
+class VToolAlongLine : public VToolLinePoint
+{
     Q_OBJECT
 public:
                  VToolAlongLine(VDomDocument *doc, VContainer *data, qint64 id, const QString &formula,
@@ -49,7 +50,7 @@ protected:
     virtual void RemoveReferens();
 private:
     qint64       secondPointId;
-    QSharedPointer<DialogAlongLine> dialogAlongLine; 
+    QSharedPointer<DialogAlongLine> dialogAlongLine;
 };
 
 #endif // VTOOLALONGLINE_H
diff --git a/tools/drawTools/vtoolarc.cpp b/tools/drawTools/vtoolarc.cpp
index 149560c3d..bda386b36 100644
--- a/tools/drawTools/vtoolarc.cpp
+++ b/tools/drawTools/vtoolarc.cpp
@@ -26,8 +26,9 @@ const QString VToolArc::TagName = QStringLiteral("arc");
 const QString VToolArc::ToolType = QStringLiteral("simple");
 
 VToolArc::VToolArc(VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources typeCreation,
-                   QGraphicsItem *parent):VDrawTool(doc, data, id), QGraphicsPathItem(parent),
-    dialogArc(QSharedPointer<DialogArc>()){
+                   QGraphicsItem *parent)
+    :VDrawTool(doc, data, id), QGraphicsPathItem(parent), dialogArc(QSharedPointer<DialogArc>())
+{
     VArc arc = data->GetArc(id);
     QPainterPath path;
     path.addPath(arc.GetPath());
@@ -37,24 +38,25 @@ VToolArc::VToolArc(VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources
     this->setFlag(QGraphicsItem::ItemIsSelectable, true);
     this->setAcceptHoverEvents(true);
 
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VToolArc::setDialog(){
-    Q_ASSERT(!dialogArc.isNull());
-    if(!dialogArc.isNull()){
-        VArc arc = VAbstractTool::data.GetArc(id);
-        dialogArc->SetCenter(arc.GetCenter());
-        dialogArc->SetF1(arc.GetFormulaF1());
-        dialogArc->SetF2(arc.GetFormulaF2());
-        dialogArc->SetRadius(arc.GetFormulaRadius());
-    }
+void VToolArc::setDialog()
+{
+    Q_ASSERT(dialogArc.isNull() == false);
+    VArc arc = VAbstractTool::data.GetArc(id);
+    dialogArc->SetCenter(arc.GetCenter());
+    dialogArc->SetF1(arc.GetFormulaF1());
+    dialogArc->SetF2(arc.GetFormulaF2());
+    dialogArc->SetRadius(arc.GetFormulaRadius());
 }
 
 void VToolArc::Create(QSharedPointer<DialogArc> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
-                      VContainer *data){
+                      VContainer *data)
+{
     qint64 center = dialog->GetCenter();
     QString radius = dialog->GetRadius();
     QString f1 = dialog->GetF1();
@@ -63,43 +65,52 @@ void VToolArc::Create(QSharedPointer<DialogArc> &dialog, VMainGraphicsScene *sce
 }
 
 void VToolArc::Create(const qint64 _id, const qint64 &center, const QString &radius, const QString &f1,
-                      const QString &f2, VMainGraphicsScene *scene, VDomDocument *doc,
-                      VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation){
+                      const QString &f2, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
+                      const Document::Documents &parse, Tool::Sources typeCreation)
+{
     qreal calcRadius = 0, calcF1 = 0, calcF2 = 0;
 
     Calculator cal(data);
     QString errorMsg;
     qreal result = cal.eval(radius, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         calcRadius = toPixel(result);
     }
 
     errorMsg.clear();
     result = cal.eval(f1, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         calcF1 = result;
     }
 
     errorMsg.clear();
     result = cal.eval(f2, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         calcF2 = result;
     }
 
     VArc arc = VArc(data->DataPoints(), center, calcRadius, radius, calcF1, f1, calcF2, f2 );
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->AddArc(arc);
-        data->AddLengthArc(data->GetNameArc(center,id), toMM(arc.GetLength()));
-    } else {
+        data->AddLengthArc(data->GetNameArc(center, id), toMM(arc.GetLength()));
+    }
+    else
+    {
         data->UpdateArc(id, arc);
-        data->AddLengthArc(data->GetNameArc(center,id), toMM(arc.GetLength()));
-        if(parse != Document::FullParse){
+        data->AddLengthArc(data->GetNameArc(center, id), toMM(arc.GetLength()));
+        if (parse != Document::FullParse)
+        {
             doc->UpdateToolData(id, data);
         }
     }
     VDrawTool::AddRecord(id, Tool::ArcTool, doc);
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         VToolArc *toolArc = new VToolArc(doc, data, id, typeCreation);
         scene->addItem(toolArc);
         connect(toolArc, &VToolArc::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
@@ -109,14 +120,18 @@ void VToolArc::Create(const qint64 _id, const qint64 &center, const QString &rad
     }
 }
 
-void VToolArc::FullUpdateFromFile(){
+void VToolArc::FullUpdateFromFile()
+{
     RefreshGeometry();
 }
 
-void VToolArc::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolArc::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrCenter, QString().setNum(dialogArc->GetCenter()));
             domElement.setAttribute(AttrRadius, dialogArc->GetRadius());
             domElement.setAttribute(AttrAngle1, dialogArc->GetF1());
@@ -127,12 +142,16 @@ void VToolArc::FullUpdateFromGui(int result){
     dialogArc.clear();
 }
 
-void VToolArc::ChangedActivDraw(const QString newName){
+void VToolArc::ChangedActivDraw(const QString newName)
+{
     bool selectable = false;
-    if(nameActivDraw == newName){
+    if (nameActivDraw == newName)
+    {
         selectable = true;
         currentColor = Qt::black;
-    } else {
+    }
+    else
+    {
         selectable = false;
         currentColor = Qt::gray;
     }
@@ -142,20 +161,24 @@ void VToolArc::ChangedActivDraw(const QString newName){
     VDrawTool::ChangedActivDraw(newName);
 }
 
-void VToolArc::ShowTool(qint64 id, Qt::GlobalColor color, bool enable){
+void VToolArc::ShowTool(qint64 id, Qt::GlobalColor color, bool enable)
+{
     ShowItem(this, id, color, enable);
 }
 
-void VToolArc::SetFactor(qreal factor){
+void VToolArc::SetFactor(qreal factor)
+{
     VDrawTool::SetFactor(factor);
     RefreshGeometry();
 }
 
-void VToolArc::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolArc::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogArc, this, event);
 }
 
-void VToolArc::AddToFile(){
+void VToolArc::AddToFile()
+{
     VArc arc = VAbstractTool::data.GetArc(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -169,29 +192,35 @@ void VToolArc::AddToFile(){
     AddToCalculation(domElement);
 }
 
-void VToolArc::mouseReleaseEvent(QGraphicsSceneMouseEvent *event){
-    if(event->button() == Qt::LeftButton){
+void VToolArc::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
         emit ChoosedTool(id, Scene::Arc);
     }
     QGraphicsItem::mouseReleaseEvent(event);
 }
 
-void VToolArc::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VToolArc::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthMainLine/factor));
 }
 
-void VToolArc::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VToolArc::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthHairLine/factor));
 }
 
-void VToolArc::RemoveReferens(){
+void VToolArc::RemoveReferens()
+{
     VArc arc = VAbstractTool::data.GetArc(id);
     doc->DecrementReferens(arc.GetCenter());
 }
 
-void VToolArc::RefreshGeometry(){
+void VToolArc::RefreshGeometry()
+{
     this->setPen(QPen(currentColor, widthHairLine/factor));
     VArc arc = VAbstractTool::data.GetArc(id);
     QPainterPath path;
diff --git a/tools/drawTools/vtoolarc.h b/tools/drawTools/vtoolarc.h
index a743b96e1..75ea37bfa 100644
--- a/tools/drawTools/vtoolarc.h
+++ b/tools/drawTools/vtoolarc.h
@@ -27,7 +27,8 @@
 #include "dialogs/dialogarc.h"
 #include "widgets/vcontrolpointspline.h"
 
-class VToolArc :public VDrawTool, public QGraphicsPathItem{
+class VToolArc :public VDrawTool, public QGraphicsPathItem
+{
     Q_OBJECT
 public:
                  VToolArc(VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources typeCreation,
diff --git a/tools/drawTools/vtoolbisector.cpp b/tools/drawTools/vtoolbisector.cpp
index 9e21737ab..26af32886 100644
--- a/tools/drawTools/vtoolbisector.cpp
+++ b/tools/drawTools/vtoolbisector.cpp
@@ -27,47 +27,53 @@ const QString VToolBisector::ToolType = QStringLiteral("bisector");
 VToolBisector::VToolBisector(VDomDocument *doc, VContainer *data, const qint64 &id,
                              const QString &typeLine, const QString &formula, const qint64 &firstPointId,
                              const qint64 &secondPointId, const qint64 &thirdPointId, Tool::Sources typeCreation,
-                             QGraphicsItem *parent):
-    VToolLinePoint(doc, data, id, typeLine, formula, secondPointId, 0, parent), firstPointId(0),
-    thirdPointId(0), dialogBisector(QSharedPointer<DialogBisector>()){
+                             QGraphicsItem *parent)
+    :VToolLinePoint(doc, data, id, typeLine, formula, secondPointId, 0, parent), firstPointId(0),
+    thirdPointId(0), dialogBisector(QSharedPointer<DialogBisector>())
+{
     this->firstPointId = firstPointId;
     this->thirdPointId = thirdPointId;
 
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
 QPointF VToolBisector::FindPoint(const QPointF &firstPoint, const QPointF &secondPoint,
-                                 const QPointF &thirdPoint, const qreal &length){
+                                 const QPointF &thirdPoint, const qreal &length)
+{
     QLineF line1(secondPoint, firstPoint);
     QLineF line2(secondPoint, thirdPoint);
     qreal angle = line1.angleTo(line2);
-    if(angle>180){
+    if (angle>180)
+    {
         angle = 360 - angle;
         line1.setAngle(line1.angle()-angle/2);
-    } else {
+    }
+    else
+    {
         line1.setAngle(line1.angle()+angle/2);
     }
     line1.setLength(length);
     return line1.p2();
 }
 
-void VToolBisector::setDialog(){
-    Q_ASSERT(!dialogBisector.isNull());
-    if(!dialogBisector.isNull()){
-        VPointF p = VAbstractTool::data.GetPoint(id);
-        dialogBisector->setTypeLine(typeLine);
-        dialogBisector->setFormula(formula);
-        dialogBisector->setFirstPointId(firstPointId, id);
-        dialogBisector->setSecondPointId(basePointId, id);
-        dialogBisector->setThirdPointId(thirdPointId, id);
-        dialogBisector->setPointName(p.name());
-    }
+void VToolBisector::setDialog()
+{
+    Q_ASSERT(dialogBisector.isNull() == false);
+    VPointF p = VAbstractTool::data.GetPoint(id);
+    dialogBisector->setTypeLine(typeLine);
+    dialogBisector->setFormula(formula);
+    dialogBisector->setFirstPointId(firstPointId, id);
+    dialogBisector->setSecondPointId(basePointId, id);
+    dialogBisector->setThirdPointId(thirdPointId, id);
+    dialogBisector->setPointName(p.name());
 }
 
-void VToolBisector::Create(QSharedPointer<DialogBisector> &dialog, VMainGraphicsScene *scene,
-                           VDomDocument *doc, VContainer *data){
+void VToolBisector::Create(QSharedPointer<DialogBisector> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
+                           VContainer *data)
+{
     QString formula = dialog->getFormula();
     qint64 firstPointId = dialog->getFirstPointId();
     qint64 secondPointId = dialog->getSecondPointId();
@@ -82,7 +88,8 @@ void VToolBisector::Create(const qint64 _id, const QString &formula, const qint6
                            const qint64 &secondPointId, const qint64 &thirdPointId, const QString &typeLine,
                            const QString &pointName, const qreal &mx, const qreal &my,
                            VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
-                           const Document::Documents &parse, Tool::Sources typeCreation){
+                           const Document::Documents &parse, Tool::Sources typeCreation)
+{
     VPointF firstPoint = data->GetPoint(firstPointId);
     VPointF secondPoint = data->GetPoint(secondPointId);
     VPointF thirdPoint = data->GetPoint(thirdPointId);
@@ -90,22 +97,28 @@ void VToolBisector::Create(const qint64 _id, const QString &formula, const qint6
     Calculator cal(data);
     QString errorMsg;
     qreal result = cal.eval(formula, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         QPointF fPoint = VToolBisector::FindPoint(firstPoint.toQPointF(), secondPoint.toQPointF(),
                                                   thirdPoint.toQPointF(), toPixel(result));
         qint64 id = _id;
-        if(typeCreation == Tool::FromGui){
+        if (typeCreation == Tool::FromGui)
+        {
             id = data->AddPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
             data->AddLine(firstPointId, id);
-        } else {
+        }
+        else
+        {
             data->UpdatePoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
             data->AddLine(firstPointId, id);
-            if(parse != Document::FullParse){
+            if (parse != Document::FullParse)
+            {
                 doc->UpdateToolData(id, data);
             }
         }
         VDrawTool::AddRecord(id, Tool::BisectorTool, doc);
-        if(parse == Document::FullParse){
+        if (parse == Document::FullParse)
+        {
             VToolBisector *point = new VToolBisector(doc, data, id, typeLine, formula, firstPointId, secondPointId,
                                                      thirdPointId, typeCreation);
             scene->addItem(point);
@@ -120,9 +133,11 @@ void VToolBisector::Create(const qint64 _id, const QString &formula, const qint6
     }
 }
 
-void VToolBisector::FullUpdateFromFile(){
+void VToolBisector::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         typeLine = domElement.attribute(AttrTypeLine, "");
         formula = domElement.attribute(AttrLength, "");
         firstPointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
@@ -132,10 +147,13 @@ void VToolBisector::FullUpdateFromFile(){
     RefreshGeometry();
 }
 
-void VToolBisector::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolBisector::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogBisector->getPointName());
             domElement.setAttribute(AttrTypeLine, dialogBisector->getTypeLine());
             domElement.setAttribute(AttrLength, dialogBisector->getFormula());
@@ -148,16 +166,19 @@ void VToolBisector::FullUpdateFromGui(int result){
     dialogBisector.clear();
 }
 
-void VToolBisector::SetFactor(qreal factor){
+void VToolBisector::SetFactor(qreal factor)
+{
     VDrawTool::SetFactor(factor);
     RefreshGeometry();
 }
 
-void VToolBisector::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolBisector::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogBisector, this, event);
 }
 
-void VToolBisector::AddToFile(){
+void VToolBisector::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -176,7 +197,8 @@ void VToolBisector::AddToFile(){
     AddToCalculation(domElement);
 }
 
-void VToolBisector::RemoveReferens(){
+void VToolBisector::RemoveReferens()
+{
     doc->DecrementReferens(firstPointId);
     doc->DecrementReferens(thirdPointId);
     VToolLinePoint::RemoveReferens();
diff --git a/tools/drawTools/vtoolbisector.h b/tools/drawTools/vtoolbisector.h
index 6e0603f01..9f7434538 100644
--- a/tools/drawTools/vtoolbisector.h
+++ b/tools/drawTools/vtoolbisector.h
@@ -25,7 +25,8 @@
 #include "vtoollinepoint.h"
 #include "dialogs/dialogbisector.h"
 
-class VToolBisector : public VToolLinePoint{
+class VToolBisector : public VToolLinePoint
+{
 public:
                    VToolBisector(VDomDocument *doc, VContainer *data, const qint64 &id, const QString &typeLine,
                                  const QString &formula, const qint64 &firstPointId, const qint64 &secondPointId,
diff --git a/tools/drawTools/vtoolendline.cpp b/tools/drawTools/vtoolendline.cpp
index d2b58d931..cbd18add4 100644
--- a/tools/drawTools/vtoolendline.cpp
+++ b/tools/drawTools/vtoolendline.cpp
@@ -27,17 +27,20 @@ const QString VToolEndLine::ToolType = QStringLiteral("endLine");
 
 VToolEndLine::VToolEndLine(VDomDocument *doc, VContainer *data, const qint64 &id,  const QString &typeLine,
                            const QString &formula, const qreal &angle, const qint64 &basePointId,
-                           Tool::Sources typeCreation, QGraphicsItem *parent):
-    VToolLinePoint(doc, data, id, typeLine, formula, basePointId, angle, parent),
-    dialogEndLine(QSharedPointer<DialogEndLine>()){
+                           Tool::Sources typeCreation, QGraphicsItem *parent)
+    :VToolLinePoint(doc, data, id, typeLine, formula, basePointId, angle, parent),
+    dialogEndLine(QSharedPointer<DialogEndLine>())
+{
 
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VToolEndLine::setDialog(){
-    Q_ASSERT(!dialogEndLine.isNull());
+void VToolEndLine::setDialog()
+{
+    Q_ASSERT(dialogEndLine.isNull() == false);
     VPointF p = VAbstractTool::data.GetPoint(id);
     dialogEndLine->setTypeLine(typeLine);
     dialogEndLine->setFormula(formula);
@@ -46,8 +49,9 @@ void VToolEndLine::setDialog(){
     dialogEndLine->setPointName(p.name());
 }
 
-void VToolEndLine::Create(QSharedPointer<DialogEndLine> &dialog, VMainGraphicsScene *scene,
-                          VDomDocument *doc, VContainer *data){
+void VToolEndLine::Create(QSharedPointer<DialogEndLine> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
+                          VContainer *data)
+{
     QString pointName = dialog->getPointName();
     QString typeLine = dialog->getTypeLine();
     QString formula = dialog->getFormula();
@@ -60,29 +64,35 @@ void VToolEndLine::Create(QSharedPointer<DialogEndLine> &dialog, VMainGraphicsSc
 void VToolEndLine::Create(const qint64 _id, const QString &pointName, const QString &typeLine,
                           const QString &formula, const qreal &angle, const qint64 &basePointId,
                           const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VDomDocument *doc,
-                          VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation){
-
+                          VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation)
+{
     VPointF basePoint = data->GetPoint(basePointId);
     QLineF line = QLineF(basePoint.toQPointF(), QPointF(basePoint.x()+100, basePoint.y()));
     Calculator cal(data);
     QString errorMsg;
     qreal result = cal.eval(formula, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         line.setLength(toPixel(result));
         line.setAngle(angle);
         qint64 id = _id;
-        if(typeCreation == Tool::FromGui){
+        if (typeCreation == Tool::FromGui)
+        {
             id = data->AddPoint(VPointF(line.p2().x(), line.p2().y(), pointName, mx, my));
             data->AddLine(basePointId, id);
-        } else {
+        }
+        else
+        {
             data->UpdatePoint(id, VPointF(line.p2().x(), line.p2().y(), pointName, mx, my));
             data->AddLine(basePointId, id);
-            if(parse != Document::FullParse){
+            if (parse != Document::FullParse)
+            {
                 doc->UpdateToolData(id, data);
             }
         }
         VDrawTool::AddRecord(id, Tool::EndLineTool, doc);
-        if(parse == Document::FullParse){
+        if (parse == Document::FullParse)
+        {
             VToolEndLine *point = new VToolEndLine(doc, data, id, typeLine, formula, angle,
                                                    basePointId, typeCreation);
             scene->addItem(point);
@@ -95,9 +105,11 @@ void VToolEndLine::Create(const qint64 _id, const QString &pointName, const QStr
     }
 }
 
-void VToolEndLine::FullUpdateFromFile(){
+void VToolEndLine::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         typeLine = domElement.attribute(AttrTypeLine, "");
         formula = domElement.attribute(AttrLength, "");
         basePointId = domElement.attribute(AttrBasePoint, "").toLongLong();
@@ -106,14 +118,18 @@ void VToolEndLine::FullUpdateFromFile(){
     RefreshGeometry();
 }
 
-void VToolEndLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolEndLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogEndLine, this, event);
 }
 
-void VToolEndLine::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolEndLine::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogEndLine->getPointName());
             domElement.setAttribute(AttrTypeLine, dialogEndLine->getTypeLine());
             domElement.setAttribute(AttrLength, dialogEndLine->getFormula());
@@ -125,7 +141,8 @@ void VToolEndLine::FullUpdateFromGui(int result){
     dialogEndLine.clear();
 }
 
-void VToolEndLine::AddToFile(){
+void VToolEndLine::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -142,4 +159,3 @@ void VToolEndLine::AddToFile(){
 
     AddToCalculation(domElement);
 }
-
diff --git a/tools/drawTools/vtoolendline.h b/tools/drawTools/vtoolendline.h
index 75ce3cfeb..9e7171a7f 100644
--- a/tools/drawTools/vtoolendline.h
+++ b/tools/drawTools/vtoolendline.h
@@ -25,7 +25,8 @@
 #include "vtoollinepoint.h"
 #include "dialogs/dialogendline.h"
 
-class VToolEndLine : public VToolLinePoint{
+class VToolEndLine : public VToolLinePoint
+{
     Q_OBJECT
 public:
                  VToolEndLine(VDomDocument *doc, VContainer *data, const qint64 &id, const QString &typeLine,
diff --git a/tools/drawTools/vtoolheight.cpp b/tools/drawTools/vtoolheight.cpp
index 0ab9ff998..e8b4d502f 100644
--- a/tools/drawTools/vtoolheight.cpp
+++ b/tools/drawTools/vtoolheight.cpp
@@ -6,15 +6,18 @@ VToolHeight::VToolHeight(VDomDocument *doc, VContainer *data, const qint64 &id,
                          const qint64 &basePointId, const qint64 &p1LineId, const qint64 &p2LineId,
                          Tool::Sources typeCreation, QGraphicsItem * parent)
     :VToolLinePoint(doc, data, id, typeLine, QString(), basePointId, 0, parent),
-      dialogHeight(QSharedPointer<DialogHeight>()), p1LineId(p1LineId), p2LineId(p2LineId){
+      dialogHeight(QSharedPointer<DialogHeight>()), p1LineId(p1LineId), p2LineId(p2LineId)
+{
     ignoreFullUpdate = true;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VToolHeight::setDialog(){
-    Q_ASSERT(!dialogHeight.isNull());
+void VToolHeight::setDialog()
+{
+    Q_ASSERT(dialogHeight.isNull() == false);
     VPointF p = VAbstractTool::data.GetPoint(id);
     dialogHeight->setTypeLine(typeLine);
     dialogHeight->setBasePointId(basePointId, id);
@@ -24,7 +27,8 @@ void VToolHeight::setDialog(){
 }
 
 void VToolHeight::Create(QSharedPointer<DialogHeight> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
-                         VContainer *data){
+                         VContainer *data)
+{
     disconnect(doc, &VDomDocument::FullUpdateFromFile, dialog.data(), &DialogHeight::UpdateList);
     QString pointName = dialog->getPointName();
     QString typeLine = dialog->getTypeLine();
@@ -38,29 +42,35 @@ void VToolHeight::Create(QSharedPointer<DialogHeight> &dialog, VMainGraphicsScen
 void VToolHeight::Create(const qint64 _id, const QString &pointName, const QString &typeLine,
                          const qint64 &basePointId, const qint64 &p1LineId, const qint64 &p2LineId,
                          const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VDomDocument *doc,
-                         VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation){
+                         VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation)
+{
     VPointF basePoint = data->GetPoint(basePointId);
     VPointF p1Line = data->GetPoint(p1LineId);
     VPointF p2Line = data->GetPoint(p2LineId);
 
     QPointF pHeight = FindPoint(QLineF(p1Line.toQPointF(), p2Line.toQPointF()), basePoint.toQPointF());
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->AddPoint(VPointF(pHeight.x(), pHeight.y(), pointName, mx, my));
         data->AddLine(basePointId, id);
         data->AddLine(p1LineId, id);
         data->AddLine(p2LineId, id);
-    } else {
+    }
+    else
+    {
         data->UpdatePoint(id, VPointF(pHeight.x(), pHeight.y(), pointName, mx, my));
         data->AddLine(basePointId, id);
         data->AddLine(p1LineId, id);
         data->AddLine(p2LineId, id);
-        if(parse != Document::FullParse){
+        if (parse != Document::FullParse)
+        {
             doc->UpdateToolData(id, data);
         }
     }
     VDrawTool::AddRecord(id, Tool::Height, doc);
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         VToolHeight *point = new VToolHeight(doc, data, id, typeLine, basePointId, p1LineId, p2LineId,
                                              typeCreation);
         scene->addItem(point);
@@ -74,24 +84,30 @@ void VToolHeight::Create(const qint64 _id, const QString &pointName, const QStri
     }
 }
 
-QPointF VToolHeight::FindPoint(const QLineF &line, const QPointF &point){
+QPointF VToolHeight::FindPoint(const QLineF &line, const QPointF &point)
+{
     qreal a = 0, b = 0, c = 0;
     LineCoefficients(line, &a, &b, &c);
     qreal x = point.x() + a;
     qreal y = b + point.y();
-    QLineF l (point, QPointF(x, y));
+    QLineF lin (point, QPointF(x, y));
     QPointF p;
-    QLineF::IntersectType intersect = line.intersect(l, &p);
-    if(intersect == QLineF::UnboundedIntersection || intersect == QLineF::BoundedIntersection){
+    QLineF::IntersectType intersect = line.intersect(lin, &p);
+    if (intersect == QLineF::UnboundedIntersection || intersect == QLineF::BoundedIntersection)
+    {
         return p;
-    } else {
+    }
+    else
+    {
         return QPointF();
     }
 }
 
-void VToolHeight::FullUpdateFromFile(){
+void VToolHeight::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         typeLine = domElement.attribute(AttrTypeLine, "");
         basePointId = domElement.attribute(AttrBasePoint, "").toLongLong();
         p1LineId = domElement.attribute(AttrP1Line, "").toLongLong();
@@ -101,10 +117,13 @@ void VToolHeight::FullUpdateFromFile(){
 
 }
 
-void VToolHeight::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolHeight::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogHeight->getPointName());
             domElement.setAttribute(AttrTypeLine, dialogHeight->getTypeLine());
             domElement.setAttribute(AttrBasePoint, QString().setNum(dialogHeight->getBasePointId()));
@@ -116,11 +135,13 @@ void VToolHeight::FullUpdateFromGui(int result){
     dialogHeight.clear();
 }
 
-void VToolHeight::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolHeight::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogHeight, this, event);
 }
 
-void VToolHeight::AddToFile(){
+void VToolHeight::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
diff --git a/tools/drawTools/vtoolheight.h b/tools/drawTools/vtoolheight.h
index 06158aca4..2dd0145e7 100644
--- a/tools/drawTools/vtoolheight.h
+++ b/tools/drawTools/vtoolheight.h
@@ -25,7 +25,8 @@
 #include "vtoollinepoint.h"
 #include "dialogs/dialogheight.h"
 
-class VToolHeight: public VToolLinePoint{
+class VToolHeight: public VToolLinePoint
+{
     Q_OBJECT
 public:
                    VToolHeight(VDomDocument *doc, VContainer *data, const qint64 &id, const QString &typeLine,
diff --git a/tools/drawTools/vtoolline.cpp b/tools/drawTools/vtoolline.cpp
index 98d24fb94..2dccf5b97 100644
--- a/tools/drawTools/vtoolline.cpp
+++ b/tools/drawTools/vtoolline.cpp
@@ -24,9 +24,10 @@
 const QString VToolLine::TagName = QStringLiteral("line");
 
 VToolLine::VToolLine(VDomDocument *doc, VContainer *data, qint64 id, qint64 firstPoint, qint64 secondPoint,
-                     Tool::Sources typeCreation, QGraphicsItem *parent):VDrawTool(doc, data, id),
-    QGraphicsLineItem(parent), firstPoint(firstPoint), secondPoint(secondPoint),
-    dialogLine(QSharedPointer<DialogLine>()){
+                     Tool::Sources typeCreation, QGraphicsItem *parent)
+    :VDrawTool(doc, data, id), QGraphicsLineItem(parent), firstPoint(firstPoint), secondPoint(secondPoint),
+    dialogLine(QSharedPointer<DialogLine>())
+{
     ignoreFullUpdate = true;
     //Лінія
     VPointF first = data->GetPoint(firstPoint);
@@ -37,18 +38,21 @@ VToolLine::VToolLine(VDomDocument *doc, VContainer *data, qint64 id, qint64 firs
     this->setAcceptHoverEvents(true);
     this->setPen(QPen(Qt::black, widthHairLine/factor));
 
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VToolLine::setDialog(){
+void VToolLine::setDialog()
+{
     dialogLine->setFirstPoint(firstPoint);
     dialogLine->setSecondPoint(secondPoint);
 }
 
 void VToolLine::Create(QSharedPointer<DialogLine> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
-                       VContainer *data){
+                       VContainer *data)
+{
     qint64 firstPoint = dialog->getFirstPoint();
     qint64 secondPoint = dialog->getSecondPoint();
     Create(0, firstPoint, secondPoint, scene, doc, data, Document::FullParse, Tool::FromGui);
@@ -56,23 +60,29 @@ void VToolLine::Create(QSharedPointer<DialogLine> &dialog, VMainGraphicsScene *s
 
 void VToolLine::Create(const qint64 &_id, const qint64 &firstPoint, const qint64 &secondPoint,
                        VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
-                       const Document::Documents &parse, Tool::Sources typeCreation){
+                       const Document::Documents &parse, Tool::Sources typeCreation)
+{
     Q_ASSERT(scene != 0);
     Q_ASSERT(doc != 0);
     Q_ASSERT(data != 0);
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->getNextId();
         data->AddLine(firstPoint, secondPoint);
-    } else {
+    }
+    else
+    {
         data->UpdateId(id);
         data->AddLine(firstPoint, secondPoint);
-        if(parse != Document::FullParse){
+        if (parse != Document::FullParse)
+        {
             doc->UpdateToolData(id, data);
         }
     }
     VDrawTool::AddRecord(id, Tool::LineTool, doc);
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         VToolLine *line = new VToolLine(doc, data, id, firstPoint, secondPoint, typeCreation);
         Q_ASSERT(line != 0);
         scene->addItem(line);
@@ -85,14 +95,18 @@ void VToolLine::Create(const qint64 &_id, const qint64 &firstPoint, const qint64
     }
 }
 
-void VToolLine::FullUpdateFromFile(){
+void VToolLine::FullUpdateFromFile()
+{
     RefreshGeometry();
 }
 
-void VToolLine::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolLine::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrFirstPoint, QString().setNum(dialogLine->getFirstPoint()));
             domElement.setAttribute(AttrSecondPoint, QString().setNum(dialogLine->getSecondPoint()));
             emit FullUpdateTree();
@@ -101,21 +115,27 @@ void VToolLine::FullUpdateFromGui(int result){
     dialogLine.clear();
 }
 
-void VToolLine::ShowTool(qint64 id, Qt::GlobalColor color, bool enable){
+void VToolLine::ShowTool(qint64 id, Qt::GlobalColor color, bool enable)
+{
     ShowItem(this, id, color, enable);
 }
 
-void VToolLine::SetFactor(qreal factor){
+void VToolLine::SetFactor(qreal factor)
+{
     VDrawTool::SetFactor(factor);
     RefreshGeometry();
 }
 
-void VToolLine::ChangedActivDraw(const QString newName){
+void VToolLine::ChangedActivDraw(const QString newName)
+{
     bool selectable = false;
-    if(nameActivDraw == newName){
+    if (nameActivDraw == newName)
+    {
         selectable = true;
         currentColor = Qt::black;
-    } else {
+    }
+    else
+    {
         selectable = false;
         currentColor = Qt::gray;
     }
@@ -124,11 +144,13 @@ void VToolLine::ChangedActivDraw(const QString newName){
     VDrawTool::ChangedActivDraw(newName);
 }
 
-void VToolLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogLine, this, event);
 }
 
-void VToolLine::AddToFile(){
+void VToolLine::AddToFile()
+{
     QDomElement domElement = doc->createElement(TagName);
     AddAttribute(domElement, AttrId, id);
     AddAttribute(domElement, AttrFirstPoint, firstPoint);
@@ -137,24 +159,29 @@ void VToolLine::AddToFile(){
     AddToCalculation(domElement);
 }
 
-void VToolLine::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VToolLine::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthMainLine/factor));
 }
 
-void VToolLine::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VToolLine::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthHairLine/factor));
 }
 
-void VToolLine::RemoveReferens(){
+void VToolLine::RemoveReferens()
+{
     doc->DecrementReferens(firstPoint);
     doc->DecrementReferens(secondPoint);
 }
 
-void VToolLine::RefreshGeometry(){
+void VToolLine::RefreshGeometry()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         firstPoint = domElement.attribute(AttrFirstPoint, "").toLongLong();
         secondPoint = domElement.attribute(AttrSecondPoint, "").toLongLong();
     }
@@ -163,4 +190,3 @@ void VToolLine::RefreshGeometry(){
     this->setLine(QLineF(first.toQPointF(), second.toQPointF()));
     this->setPen(QPen(currentColor, widthHairLine/factor));
 }
-
diff --git a/tools/drawTools/vtoolline.h b/tools/drawTools/vtoolline.h
index c88e6fb21..43469b535 100644
--- a/tools/drawTools/vtoolline.h
+++ b/tools/drawTools/vtoolline.h
@@ -26,7 +26,8 @@
 #include "QGraphicsLineItem"
 #include "dialogs/dialogline.h"
 
-class VToolLine: public VDrawTool, public QGraphicsLineItem{
+class VToolLine: public VDrawTool, public QGraphicsLineItem
+{
     Q_OBJECT
 public:
                  VToolLine(VDomDocument *doc, VContainer *data, qint64 id, qint64 firstPoint,
diff --git a/tools/drawTools/vtoollineintersect.cpp b/tools/drawTools/vtoollineintersect.cpp
index b0eb6696a..f02c897cf 100644
--- a/tools/drawTools/vtoollineintersect.cpp
+++ b/tools/drawTools/vtoollineintersect.cpp
@@ -26,29 +26,31 @@ const QString VToolLineIntersect::ToolType = QStringLiteral("lineIntersect");
 VToolLineIntersect::VToolLineIntersect(VDomDocument *doc, VContainer *data, const qint64 &id,
                                        const qint64 &p1Line1, const qint64 &p2Line1, const qint64 &p1Line2,
                                        const qint64 &p2Line2, Tool::Sources typeCreation,
-                                       QGraphicsItem *parent):
-    VToolPoint(doc, data, id, parent), p1Line1(p1Line1), p2Line1(p2Line1), p1Line2(p1Line2),
-    p2Line2(p2Line2), dialogLineIntersect(QSharedPointer<DialogLineIntersect>()){
+                                       QGraphicsItem *parent)
+    :VToolPoint(doc, data, id, parent), p1Line1(p1Line1), p2Line1(p2Line1), p1Line2(p1Line2),
+    p2Line2(p2Line2), dialogLineIntersect(QSharedPointer<DialogLineIntersect>())
+{
     ignoreFullUpdate = true;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VToolLineIntersect::setDialog(){
-    Q_ASSERT(!dialogLineIntersect.isNull());
-    if(!dialogLineIntersect.isNull()){
-        VPointF p = VAbstractTool::data.GetPoint(id);
-        dialogLineIntersect->setP1Line1(p1Line1);
-        dialogLineIntersect->setP2Line1(p2Line1);
-        dialogLineIntersect->setP1Line2(p1Line2);
-        dialogLineIntersect->setP2Line2(p2Line2);
-        dialogLineIntersect->setPointName(p.name());
-    }
+void VToolLineIntersect::setDialog()
+{
+    Q_ASSERT(dialogLineIntersect.isNull() == false);
+    VPointF p = VAbstractTool::data.GetPoint(id);
+    dialogLineIntersect->setP1Line1(p1Line1);
+    dialogLineIntersect->setP2Line1(p2Line1);
+    dialogLineIntersect->setP1Line2(p1Line2);
+    dialogLineIntersect->setP2Line2(p2Line2);
+    dialogLineIntersect->setPointName(p.name());
 }
 
 void VToolLineIntersect::Create(QSharedPointer<DialogLineIntersect> &dialog, VMainGraphicsScene *scene,
-                                VDomDocument *doc, VContainer *data){
+                                VDomDocument *doc, VContainer *data)
+{
     qint64 p1Line1Id = dialog->getP1Line1();
     qint64 p2Line1Id = dialog->getP2Line1();
     qint64 p1Line2Id = dialog->getP1Line2();
@@ -62,7 +64,8 @@ void VToolLineIntersect::Create(const qint64 _id, const qint64 &p1Line1Id, const
                                 const qint64 &p1Line2Id, const qint64 &p2Line2Id, const QString &pointName,
                                 const qreal &mx, const qreal &my, VMainGraphicsScene *scene,
                                 VDomDocument *doc, VContainer *data, const Document::Documents &parse,
-                                Tool::Sources typeCreation){
+                                Tool::Sources typeCreation)
+{
     VPointF p1Line1 = data->GetPoint(p1Line1Id);
     VPointF p2Line1 = data->GetPoint(p2Line1Id);
     VPointF p1Line2 = data->GetPoint(p1Line2Id);
@@ -72,28 +75,33 @@ void VToolLineIntersect::Create(const qint64 _id, const qint64 &p1Line1Id, const
     QLineF line2(p1Line2.toQPointF(), p2Line2.toQPointF());
     QPointF fPoint;
     QLineF::IntersectType intersect = line1.intersect(line2, &fPoint);
-    if(intersect == QLineF::UnboundedIntersection || intersect == QLineF::BoundedIntersection){
+    if (intersect == QLineF::UnboundedIntersection || intersect == QLineF::BoundedIntersection)
+    {
         qint64 id = _id;
-        if(typeCreation == Tool::FromGui){
+        if (typeCreation == Tool::FromGui)
+        {
             id = data->AddPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
             data->AddLine(p1Line1Id, id);
             data->AddLine(id, p2Line1Id);
             data->AddLine(p1Line2Id, id);
             data->AddLine(id, p2Line2Id);
-        } else {
+        }
+        else
+        {
             data->UpdatePoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
             data->AddLine(p1Line1Id, id);
             data->AddLine(id, p2Line1Id);
             data->AddLine(p1Line2Id, id);
             data->AddLine(id, p2Line2Id);
-            if(parse != Document::FullParse){
+            if (parse != Document::FullParse)
+            {
                 doc->UpdateToolData(id, data);
             }
         }
         VDrawTool::AddRecord(id, Tool::LineIntersectTool, doc);
-        if(parse == Document::FullParse){
-            VToolLineIntersect *point = new VToolLineIntersect(doc, data, id, p1Line1Id,
-                                                               p2Line1Id, p1Line2Id,
+        if (parse == Document::FullParse)
+        {
+            VToolLineIntersect *point = new VToolLineIntersect(doc, data, id, p1Line1Id, p2Line1Id, p1Line2Id,
                                                                p2Line2Id, typeCreation);
             scene->addItem(point);
             connect(point, &VToolLineIntersect::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
@@ -108,9 +116,11 @@ void VToolLineIntersect::Create(const qint64 _id, const qint64 &p1Line1Id, const
     }
 }
 
-void VToolLineIntersect::FullUpdateFromFile(){
+void VToolLineIntersect::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         p1Line1 = domElement.attribute(AttrP1Line1, "").toLongLong();
         p2Line1 = domElement.attribute(AttrP2Line1, "").toLongLong();
         p1Line2 = domElement.attribute(AttrP1Line2, "").toLongLong();
@@ -119,10 +129,13 @@ void VToolLineIntersect::FullUpdateFromFile(){
     RefreshPointGeometry(VAbstractTool::data.GetPoint(id));
 }
 
-void VToolLineIntersect::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolLineIntersect::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogLineIntersect->getPointName());
             domElement.setAttribute(AttrP1Line1, QString().setNum(dialogLineIntersect->getP1Line1()));
             domElement.setAttribute(AttrP2Line1, QString().setNum(dialogLineIntersect->getP2Line1()));
@@ -134,16 +147,19 @@ void VToolLineIntersect::FullUpdateFromGui(int result){
     dialogLineIntersect.clear();
 }
 
-void VToolLineIntersect::SetFactor(qreal factor){
+void VToolLineIntersect::SetFactor(qreal factor)
+{
     VDrawTool::SetFactor(factor);
     RefreshPointGeometry(VAbstractTool::data.GetPoint(id));
 }
 
-void VToolLineIntersect::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolLineIntersect::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogLineIntersect, this, event);
 }
 
-void VToolLineIntersect::AddToFile(){
+void VToolLineIntersect::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -161,7 +177,8 @@ void VToolLineIntersect::AddToFile(){
     AddToCalculation(domElement);
 }
 
-void VToolLineIntersect::RemoveReferens(){
+void VToolLineIntersect::RemoveReferens()
+{
     doc->DecrementReferens(p1Line1);
     doc->DecrementReferens(p2Line1);
     doc->DecrementReferens(p1Line2);
diff --git a/tools/drawTools/vtoollineintersect.h b/tools/drawTools/vtoollineintersect.h
index 2cea55c28..5d9058dbd 100644
--- a/tools/drawTools/vtoollineintersect.h
+++ b/tools/drawTools/vtoollineintersect.h
@@ -25,7 +25,8 @@
 #include "vtoolpoint.h"
 #include "dialogs/dialoglineintersect.h"
 
-class VToolLineIntersect:public VToolPoint{
+class VToolLineIntersect:public VToolPoint
+{
     Q_OBJECT
 public:
                  VToolLineIntersect(VDomDocument *doc, VContainer *data, const qint64 &id, const qint64 &p1Line1,
diff --git a/tools/drawTools/vtoollinepoint.cpp b/tools/drawTools/vtoollinepoint.cpp
index 3c5c11785..4ebfa443b 100644
--- a/tools/drawTools/vtoollinepoint.cpp
+++ b/tools/drawTools/vtoollinepoint.cpp
@@ -23,8 +23,10 @@
 
 VToolLinePoint::VToolLinePoint(VDomDocument *doc, VContainer *data, const qint64 &id,
                                const QString &typeLine, const QString &formula, const qint64 &basePointId,
-                               const qreal &angle, QGraphicsItem *parent):VToolPoint(doc, data, id, parent),
-    typeLine(typeLine), formula(formula), angle(angle), basePointId(basePointId), mainLine(0){
+                               const qreal &angle, QGraphicsItem *parent)
+    :VToolPoint(doc, data, id, parent), typeLine(typeLine), formula(formula), angle(angle), basePointId(basePointId),
+      mainLine(0)
+{
     Q_ASSERT_X(basePointId > 0, Q_FUNC_INFO, "basePointId <= 0");
     //Лінія, що з'єднує дві точки
     QPointF point1 = data->GetPoint(basePointId).toQPointF();
@@ -32,37 +34,49 @@ VToolLinePoint::VToolLinePoint(VDomDocument *doc, VContainer *data, const qint64
     mainLine = new QGraphicsLineItem(QLineF(point1 - point2, QPointF()), this);
     mainLine->setPen(QPen(Qt::black, widthHairLine/factor));
     mainLine->setFlag(QGraphicsItem::ItemStacksBehindParent, true);
-    if(typeLine == TypeLineNone){
+    if (typeLine == TypeLineNone)
+    {
         mainLine->setVisible(false);
-    } else {
+    }
+    else
+    {
         mainLine->setVisible(true);
     }
 }
 
-void VToolLinePoint::ChangedActivDraw(const QString newName){
-    if(nameActivDraw == newName){
+void VToolLinePoint::ChangedActivDraw(const QString newName)
+{
+    if (nameActivDraw == newName)
+    {
         currentColor = Qt::black;
-    } else {
+    }
+    else
+    {
         currentColor = Qt::gray;
     }
     mainLine->setPen(QPen(currentColor, widthHairLine/factor));
     VToolPoint::ChangedActivDraw(newName);
 }
 
-void VToolLinePoint::RefreshGeometry(){
+void VToolLinePoint::RefreshGeometry()
+{
     mainLine->setPen(QPen(currentColor, widthHairLine/factor));
     VToolPoint::RefreshPointGeometry(VDrawTool::data.GetPoint(id));
     QPointF point = VDrawTool::data.GetPoint(id).toQPointF();
     QPointF basePoint = VDrawTool::data.GetPoint(basePointId).toQPointF();
     mainLine->setLine(QLineF(basePoint - point, QPointF()));
-    if(typeLine == TypeLineNone){
+    if (typeLine == TypeLineNone)
+    {
         mainLine->setVisible(false);
-    } else {
+    }
+    else
+    {
         mainLine->setVisible(true);
     }
 }
 
-void VToolLinePoint::SetFactor(qreal factor){
+void VToolLinePoint::SetFactor(qreal factor)
+{
     VDrawTool::SetFactor(factor);
     RefreshGeometry();
 }
diff --git a/tools/drawTools/vtoollinepoint.h b/tools/drawTools/vtoollinepoint.h
index b349fac6c..3a0e0e9f0 100644
--- a/tools/drawTools/vtoollinepoint.h
+++ b/tools/drawTools/vtoollinepoint.h
@@ -24,14 +24,15 @@
 
 #include "vtoolpoint.h"
 
-class VToolLinePoint : public VToolPoint{
+class VToolLinePoint : public VToolPoint
+{
     Q_OBJECT
 public:
                       VToolLinePoint(VDomDocument *doc, VContainer *data, const qint64 &id, const QString &typeLine,
                                      const QString &formula, const qint64 &basePointId, const qreal &angle,
                                      QGraphicsItem * parent = 0);
 public slots:
-    virtual void      ChangedActivDraw(const QString newName); 
+    virtual void      ChangedActivDraw(const QString newName);
     virtual void      SetFactor(qreal factor);
 protected:
     QString           typeLine;
diff --git a/tools/drawTools/vtoolnormal.cpp b/tools/drawTools/vtoolnormal.cpp
index 0dd4fd809..967d7c2c6 100644
--- a/tools/drawTools/vtoolnormal.cpp
+++ b/tools/drawTools/vtoolnormal.cpp
@@ -26,31 +26,33 @@ const QString VToolNormal::ToolType = QStringLiteral("normal");
 
 VToolNormal::VToolNormal(VDomDocument *doc, VContainer *data, const qint64 &id, const QString &typeLine,
                          const QString &formula, const qreal &angle, const qint64 &firstPointId,
-                         const qint64 &secondPointId, Tool::Sources typeCreation, QGraphicsItem *parent):
-    VToolLinePoint(doc, data, id, typeLine, formula, firstPointId, angle, parent),
-    secondPointId(secondPointId), dialogNormal(QSharedPointer<DialogNormal>()){
+                         const qint64 &secondPointId, Tool::Sources typeCreation, QGraphicsItem *parent)
+    :VToolLinePoint(doc, data, id, typeLine, formula, firstPointId, angle, parent),
+    secondPointId(secondPointId), dialogNormal(QSharedPointer<DialogNormal>())
+{
 
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 
 }
 
-void VToolNormal::setDialog(){
-    Q_ASSERT(!dialogNormal.isNull());
-    if(!dialogNormal.isNull()){
-        VPointF p = VAbstractTool::data.GetPoint(id);
-        dialogNormal->setTypeLine(typeLine);
-        dialogNormal->setFormula(formula);
-        dialogNormal->setAngle(angle);
-        dialogNormal->setFirstPointId(basePointId, id);
-        dialogNormal->setSecondPointId(secondPointId, id);
-        dialogNormal->setPointName(p.name());
-    }
+void VToolNormal::setDialog()
+{
+    Q_ASSERT(dialogNormal.isNull() == false);
+    VPointF p = VAbstractTool::data.GetPoint(id);
+    dialogNormal->setTypeLine(typeLine);
+    dialogNormal->setFormula(formula);
+    dialogNormal->setAngle(angle);
+    dialogNormal->setFirstPointId(basePointId, id);
+    dialogNormal->setSecondPointId(secondPointId, id);
+    dialogNormal->setPointName(p.name());
 }
 
 void VToolNormal::Create(QSharedPointer<DialogNormal> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
-                         VContainer *data){
+                         VContainer *data)
+{
     QString formula = dialog->getFormula();
     qint64 firstPointId = dialog->getFirstPointId();
     qint64 secondPointId = dialog->getSecondPointId();
@@ -65,28 +67,35 @@ void VToolNormal::Create(const qint64 _id, const QString &formula, const qint64
                          const qint64 &secondPointId, const QString typeLine, const QString pointName,
                          const qreal angle, const qreal &mx, const qreal &my, VMainGraphicsScene *scene,
                          VDomDocument *doc, VContainer *data, const Document::Documents &parse,
-                         Tool::Sources typeCreation){
+                         Tool::Sources typeCreation)
+{
     VPointF firstPoint = data->GetPoint(firstPointId);
     VPointF secondPoint = data->GetPoint(secondPointId);
     Calculator cal(data);
     QString errorMsg;
     qreal result = cal.eval(formula, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         QPointF fPoint = VToolNormal::FindPoint(firstPoint.toQPointF(), secondPoint.toQPointF(),
                                                 toPixel(result), angle);
         qint64 id = _id;
-        if(typeCreation == Tool::FromGui){
+        if (typeCreation == Tool::FromGui)
+        {
             id = data->AddPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
             data->AddLine(firstPointId, id);
-        } else {
+        }
+        else
+        {
             data->UpdatePoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
             data->AddLine(firstPointId, id);
-            if(parse != Document::FullParse){
+            if (parse != Document::FullParse)
+            {
                 doc->UpdateToolData(id, data);
             }
         }
         VDrawTool::AddRecord(id, Tool::NormalTool, doc);
-        if(parse == Document::FullParse){
+        if (parse == Document::FullParse)
+        {
             VToolNormal *point = new VToolNormal(doc, data, id, typeLine, formula, angle,
                                                  firstPointId, secondPointId, typeCreation);
             scene->addItem(point);
@@ -101,7 +110,8 @@ void VToolNormal::Create(const qint64 _id, const QString &formula, const qint64
 }
 
 QPointF VToolNormal::FindPoint(const QPointF &firstPoint, const QPointF &secondPoint, const qreal &length,
-                               const qreal &angle){
+                               const qreal &angle)
+{
     QLineF line(firstPoint, secondPoint);
     QLineF normal = line.normalVector();
     normal.setAngle(normal.angle()+angle);
@@ -109,9 +119,11 @@ QPointF VToolNormal::FindPoint(const QPointF &firstPoint, const QPointF &secondP
     return normal.p2();
 }
 
-void VToolNormal::FullUpdateFromFile(){
+void VToolNormal::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         typeLine = domElement.attribute(AttrTypeLine, "");
         formula = domElement.attribute(AttrLength, "");
         basePointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
@@ -121,10 +133,13 @@ void VToolNormal::FullUpdateFromFile(){
     RefreshGeometry();
 }
 
-void VToolNormal::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolNormal::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogNormal->getPointName());
             domElement.setAttribute(AttrTypeLine, dialogNormal->getTypeLine());
             domElement.setAttribute(AttrLength, dialogNormal->getFormula());
@@ -137,16 +152,19 @@ void VToolNormal::FullUpdateFromGui(int result){
     dialogNormal.clear();
 }
 
-void VToolNormal::SetFactor(qreal factor){
+void VToolNormal::SetFactor(qreal factor)
+{
     VDrawTool::SetFactor(factor);
     RefreshGeometry();
 }
 
-void VToolNormal::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolNormal::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogNormal, this, event);
 }
 
-void VToolNormal::AddToFile(){
+void VToolNormal::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -165,7 +183,8 @@ void VToolNormal::AddToFile(){
     AddToCalculation(domElement);
 }
 
-void VToolNormal::RemoveReferens(){
+void VToolNormal::RemoveReferens()
+{
     doc->DecrementReferens(secondPointId);
     VToolLinePoint::RemoveReferens();
 }
diff --git a/tools/drawTools/vtoolnormal.h b/tools/drawTools/vtoolnormal.h
index 3370d2c90..2ce571cd7 100644
--- a/tools/drawTools/vtoolnormal.h
+++ b/tools/drawTools/vtoolnormal.h
@@ -25,7 +25,8 @@
 #include "vtoollinepoint.h"
 #include "dialogs/dialognormal.h"
 
-class VToolNormal : public VToolLinePoint{
+class VToolNormal : public VToolLinePoint
+{
     Q_OBJECT
 public:
                    VToolNormal(VDomDocument *doc, VContainer *data, const qint64 &id, const QString &typeLine,
diff --git a/tools/drawTools/vtoolpoint.cpp b/tools/drawTools/vtoolpoint.cpp
index fc94cd91a..cc12a21c6 100644
--- a/tools/drawTools/vtoolpoint.cpp
+++ b/tools/drawTools/vtoolpoint.cpp
@@ -23,9 +23,9 @@
 
 const QString VToolPoint::TagName = QStringLiteral("point");
 
-VToolPoint::VToolPoint(VDomDocument *doc, VContainer *data, qint64 id,
-                       QGraphicsItem *parent):VDrawTool(doc, data, id),
-    QGraphicsEllipseItem(parent), radius(toPixel(2)), namePoint(0), lineName(0){
+VToolPoint::VToolPoint(VDomDocument *doc, VContainer *data, qint64 id, QGraphicsItem *parent):VDrawTool(doc, data, id),
+    QGraphicsEllipseItem(parent), radius(toPixel(2)), namePoint(0), lineName(0)
+{
     namePoint = new VGraphicsSimpleTextItem(this);
     lineName = new QGraphicsLineItem(this);
     connect(namePoint, &VGraphicsSimpleTextItem::NameChangePosition, this,
@@ -36,7 +36,8 @@ VToolPoint::VToolPoint(VDomDocument *doc, VContainer *data, qint64 id,
     RefreshPointGeometry(VAbstractTool::data.GetPoint(id));
 }
 
-void VToolPoint::NameChangePosition(const QPointF pos){
+void VToolPoint::NameChangePosition(const QPointF pos)
+{
     VPointF point = VAbstractTool::data.GetPoint(id);
     QPointF p = pos - this->pos();
     point.setMx(p.x());
@@ -46,21 +47,27 @@ void VToolPoint::NameChangePosition(const QPointF pos){
     VAbstractTool::data.UpdatePoint(id, point);
 }
 
-void VToolPoint::UpdateNamePosition(qreal mx, qreal my){
+void VToolPoint::UpdateNamePosition(qreal mx, qreal my)
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         domElement.setAttribute(AttrMx, QString().setNum(toMM(mx)));
         domElement.setAttribute(AttrMy, QString().setNum(toMM(my)));
         emit toolhaveChange();
     }
 }
 
-void VToolPoint::ChangedActivDraw(const QString newName){
+void VToolPoint::ChangedActivDraw(const QString newName)
+{
     bool selectable = false;
-    if(nameActivDraw == newName){
+    if (nameActivDraw == newName)
+    {
         selectable = true;
         currentColor = Qt::black;
-    } else {
+    }
+    else
+    {
         selectable = false;
         currentColor = Qt::gray;
     }
@@ -76,33 +83,40 @@ void VToolPoint::ChangedActivDraw(const QString newName){
     VDrawTool::ChangedActivDraw(newName);
 }
 
-void VToolPoint::ShowTool(qint64 id, Qt::GlobalColor color, bool enable){
+void VToolPoint::ShowTool(qint64 id, Qt::GlobalColor color, bool enable)
+{
     ShowItem(this, id, color, enable);
 }
 
-void VToolPoint::SetFactor(qreal factor){
+void VToolPoint::SetFactor(qreal factor)
+{
     VDrawTool::SetFactor(factor);
     RefreshPointGeometry(VAbstractTool::data.GetPoint(id));
 }
 
-void VToolPoint::mouseReleaseEvent(QGraphicsSceneMouseEvent *event){
-    if(event->button() == Qt::LeftButton){
+void VToolPoint::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
         emit ChoosedTool(id, Scene::Point);
     }
     QGraphicsItem::mouseReleaseEvent(event);
 }
 
-void VToolPoint::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VToolPoint::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthMainLine/factor));
 }
 
-void VToolPoint::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VToolPoint::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthHairLine/factor));
 }
 
-void VToolPoint::RefreshPointGeometry(const VPointF &point){
+void VToolPoint::RefreshPointGeometry(const VPointF &point)
+{
     this->setPen(QPen(currentColor, widthHairLine/factor));
     QRectF rec = QRectF(0, 0, radius*2/factor, radius*2/factor);
     rec.translate(-rec.center().x(), -rec.center().y());
@@ -120,16 +134,20 @@ void VToolPoint::RefreshPointGeometry(const VPointF &point){
     RefreshLine();
 }
 
-void VToolPoint::RefreshLine(){
+void VToolPoint::RefreshLine()
+{
     QRectF nameRec = namePoint->sceneBoundingRect();
     QPointF p1, p2;
     LineIntersectCircle(QPointF(), radius/factor, QLineF(QPointF(), nameRec.center()- scenePos()), p1, p2);
     QPointF pRec = LineIntersectRect(nameRec, QLineF(scenePos(), nameRec.center()));
     lineName->setLine(QLineF(p1, pRec - scenePos()));
     lineName->setPen(QPen(currentColor, widthHairLine/factor));
-    if(QLineF(p1, pRec - scenePos()).length() <= toPixel(4)){
+    if (QLineF(p1, pRec - scenePos()).length() <= toPixel(4))
+    {
         lineName->setVisible(false);
-    } else {
+    }
+    else
+    {
         lineName->setVisible(true);
     }
 }
diff --git a/tools/drawTools/vtoolpoint.h b/tools/drawTools/vtoolpoint.h
index 924f5c593..ae04e6fb7 100644
--- a/tools/drawTools/vtoolpoint.h
+++ b/tools/drawTools/vtoolpoint.h
@@ -25,7 +25,8 @@
 #include "vdrawtool.h"
 #include "widgets/vgraphicssimpletextitem.h"
 
-class VToolPoint: public VDrawTool, public QGraphicsEllipseItem{
+class VToolPoint: public VDrawTool, public QGraphicsEllipseItem
+{
     Q_OBJECT
 public:
                             VToolPoint(VDomDocument *doc, VContainer *data, qint64 id, QGraphicsItem * parent = 0);
diff --git a/tools/drawTools/vtoolpointofcontact.cpp b/tools/drawTools/vtoolpointofcontact.cpp
index f068aecb2..35ee84e7c 100644
--- a/tools/drawTools/vtoolpointofcontact.cpp
+++ b/tools/drawTools/vtoolpointofcontact.cpp
@@ -29,39 +29,43 @@ VToolPointOfContact::VToolPointOfContact(VDomDocument *doc, VContainer *data, co
                                          const qint64 &firstPointId, const qint64 &secondPointId,
                                          Tool::Sources typeCreation, QGraphicsItem *parent)
     : VToolPoint(doc, data, id, parent), radius(radius), center(center), firstPointId(firstPointId),
-      secondPointId(secondPointId), dialogPointOfContact(QSharedPointer<DialogPointOfContact>()){
-
-    if(typeCreation == Tool::FromGui){
+      secondPointId(secondPointId), dialogPointOfContact(QSharedPointer<DialogPointOfContact>())
+{
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VToolPointOfContact::setDialog(){
-    Q_ASSERT(!dialogPointOfContact.isNull());
-    if(!dialogPointOfContact.isNull()){
-        VPointF p = VAbstractTool::data.GetPoint(id);
-        dialogPointOfContact->setRadius(radius);
-        dialogPointOfContact->setCenter(center, id);
-        dialogPointOfContact->setFirstPoint(firstPointId, id);
-        dialogPointOfContact->setSecondPoint(secondPointId, id);
-        dialogPointOfContact->setPointName(p.name());
-    }
+void VToolPointOfContact::setDialog()
+{
+    Q_ASSERT(dialogPointOfContact.isNull() == false);
+    VPointF p = VAbstractTool::data.GetPoint(id);
+    dialogPointOfContact->setRadius(radius);
+    dialogPointOfContact->setCenter(center, id);
+    dialogPointOfContact->setFirstPoint(firstPointId, id);
+    dialogPointOfContact->setSecondPoint(secondPointId, id);
+    dialogPointOfContact->setPointName(p.name());
 }
 
 QPointF VToolPointOfContact::FindPoint(const qreal &radius, const QPointF &center, const QPointF &firstPoint,
-                                       const QPointF &secondPoint){
+                                       const QPointF &secondPoint)
+{
     QPointF pArc;
     qreal s = 0.0, s_x, s_y, step = 0.01, distans;
-    while( s < 1){
+    while ( s < 1)
+    {
         s_x = secondPoint.x()-(qAbs(secondPoint.x()-firstPoint.x()))*s;
         s_y = secondPoint.y()-(qAbs(secondPoint.y()-firstPoint.y()))*s;
         distans = QLineF(center.x(), center.y(), s_x, s_y).length();
-        if(ceil(distans*10) == ceil(radius*10)){
+        if (ceil(distans*10) == ceil(radius*10))
+        {
             pArc.rx() = s_x;
             pArc.ry() = s_y;
             break;
         }
-        if(distans<radius){
+        if (distans<radius)
+        {
             pArc.rx() = s_x;
             pArc.ry() = s_y;
         }
@@ -71,7 +75,8 @@ QPointF VToolPointOfContact::FindPoint(const qreal &radius, const QPointF &cente
 }
 
 void VToolPointOfContact::Create(QSharedPointer<DialogPointOfContact> &dialog, VMainGraphicsScene *scene,
-                                 VDomDocument *doc, VContainer *data){
+                                 VDomDocument *doc, VContainer *data)
+{
     QString radius = dialog->getRadius();
     qint64 center = dialog->getCenter();
     qint64 firstPointId = dialog->getFirstPoint();
@@ -85,7 +90,8 @@ void VToolPointOfContact::Create(const qint64 _id, const QString &radius, const
                                  const qint64 &firstPointId, const qint64 &secondPointId,
                                  const QString &pointName, const qreal &mx, const qreal &my,
                                  VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
-                                 const Document::Documents &parse, Tool::Sources typeCreation){
+                                 const Document::Documents &parse, Tool::Sources typeCreation)
+{
     VPointF centerP = data->GetPoint(center);
     VPointF firstP = data->GetPoint(firstPointId);
     VPointF secondP = data->GetPoint(secondPointId);
@@ -93,26 +99,32 @@ void VToolPointOfContact::Create(const qint64 _id, const QString &radius, const
     Calculator cal(data);
     QString errorMsg;
     qreal result = cal.eval(radius, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         QPointF fPoint = VToolPointOfContact::FindPoint(toPixel(result), centerP.toQPointF(),
                                                          firstP.toQPointF(), secondP.toQPointF());
         qint64 id =  _id;
-        if(typeCreation == Tool::FromGui){
+        if (typeCreation == Tool::FromGui)
+        {
             id = data->AddPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
             data->AddLine(firstPointId, id);
             data->AddLine(secondPointId, id);
             data->AddLine(center, id);
-        } else {
-            data->UpdatePoint(id,VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
+        }
+        else
+        {
+            data->UpdatePoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
             data->AddLine(firstPointId, id);
             data->AddLine(secondPointId, id);
             data->AddLine(center, id);
-            if(parse != Document::FullParse){
+            if (parse != Document::FullParse)
+            {
                 doc->UpdateToolData(id, data);
             }
         }
         VDrawTool::AddRecord(id, Tool::PointOfContact, doc);
-        if(parse == Document::FullParse){
+        if (parse == Document::FullParse)
+        {
             VToolPointOfContact *point = new VToolPointOfContact(doc, data, id, radius, center,
                                                                  firstPointId, secondPointId, typeCreation);
             scene->addItem(point);
@@ -127,9 +139,11 @@ void VToolPointOfContact::Create(const qint64 _id, const QString &radius, const
     }
 }
 
-void VToolPointOfContact::FullUpdateFromFile(){
+void VToolPointOfContact::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         radius = domElement.attribute(AttrRadius, "");
         center = domElement.attribute(AttrCenter, "").toLongLong();
         firstPointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
@@ -138,10 +152,13 @@ void VToolPointOfContact::FullUpdateFromFile(){
     RefreshPointGeometry(VAbstractTool::data.GetPoint(id));
 }
 
-void VToolPointOfContact::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolPointOfContact::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogPointOfContact->getPointName());
             domElement.setAttribute(AttrRadius, dialogPointOfContact->getRadius());
             domElement.setAttribute(AttrCenter, QString().setNum(dialogPointOfContact->getCenter()));
@@ -153,16 +170,19 @@ void VToolPointOfContact::FullUpdateFromGui(int result){
     dialogPointOfContact.clear();
 }
 
-void VToolPointOfContact::SetFactor(qreal factor){
+void VToolPointOfContact::SetFactor(qreal factor)
+{
     VDrawTool::SetFactor(factor);
     RefreshPointGeometry(VAbstractTool::data.GetPoint(id));
 }
 
-void VToolPointOfContact::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolPointOfContact::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogPointOfContact, this, event);
 }
 
-void VToolPointOfContact::AddToFile(){
+void VToolPointOfContact::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -180,7 +200,8 @@ void VToolPointOfContact::AddToFile(){
     AddToCalculation(domElement);
 }
 
-void VToolPointOfContact::RemoveReferens(){
+void VToolPointOfContact::RemoveReferens()
+{
     doc->DecrementReferens(center);
     doc->DecrementReferens(firstPointId);
     doc->DecrementReferens(secondPointId);
diff --git a/tools/drawTools/vtoolpointofcontact.h b/tools/drawTools/vtoolpointofcontact.h
index 852329aa5..a5f76f046 100644
--- a/tools/drawTools/vtoolpointofcontact.h
+++ b/tools/drawTools/vtoolpointofcontact.h
@@ -25,7 +25,8 @@
 #include "vtoolpoint.h"
 #include "dialogs/dialogpointofcontact.h"
 
-class VToolPointOfContact : public VToolPoint{
+class VToolPointOfContact : public VToolPoint
+{
 public:
                    VToolPointOfContact(VDomDocument *doc, VContainer *data, const qint64 &id,
                                        const QString &radius, const qint64 &center,
diff --git a/tools/drawTools/vtoolpointofintersection.cpp b/tools/drawTools/vtoolpointofintersection.cpp
index ceff574c3..8c23281aa 100644
--- a/tools/drawTools/vtoolpointofintersection.cpp
+++ b/tools/drawTools/vtoolpointofintersection.cpp
@@ -6,15 +6,18 @@ VToolPointOfIntersection::VToolPointOfIntersection(VDomDocument *doc, VContainer
                                                    const qint64 &firstPointId, const qint64 &secondPointId,
                                                    Tool::Sources typeCreation, QGraphicsItem *parent)
     :VToolPoint(doc, data, id, parent), firstPointId(firstPointId), secondPointId(secondPointId),
-      dialogPointOfIntersection(QSharedPointer<DialogPointOfIntersection>()) {
+      dialogPointOfIntersection(QSharedPointer<DialogPointOfIntersection>())
+{
     ignoreFullUpdate = true;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VToolPointOfIntersection::setDialog(){
-    Q_ASSERT(!dialogPointOfIntersection.isNull());
+void VToolPointOfIntersection::setDialog()
+{
+    Q_ASSERT(dialogPointOfIntersection.isNull() == false);
     VPointF p = VAbstractTool::data.GetPoint(id);
     dialogPointOfIntersection->setFirstPointId(firstPointId, id);
     dialogPointOfIntersection->setSecondPointId(secondPointId, id);
@@ -22,7 +25,8 @@ void VToolPointOfIntersection::setDialog(){
 }
 
 void VToolPointOfIntersection::Create(QSharedPointer<DialogPointOfIntersection> &dialog, VMainGraphicsScene *scene,
-                                      VDomDocument *doc, VContainer *data){
+                                      VDomDocument *doc, VContainer *data)
+{
     qint64 firstPointId = dialog->getFirstPointId();
     qint64 secondPointId = dialog->getSecondPointId();
     QString pointName = dialog->getPointName();
@@ -32,22 +36,28 @@ void VToolPointOfIntersection::Create(QSharedPointer<DialogPointOfIntersection>
 void VToolPointOfIntersection::Create(const qint64 _id, const QString &pointName, const qint64 &firstPointId,
                                       const qint64 &secondPointId, const qreal &mx, const qreal &my,
                                       VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
-                                      const Document::Documents &parse, Tool::Sources typeCreation){
+                                      const Document::Documents &parse, Tool::Sources typeCreation)
+{
     VPointF firstPoint = data->GetPoint(firstPointId);
     VPointF secondPoint = data->GetPoint(secondPointId);
 
     QPointF point(firstPoint.x(), secondPoint.y());
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->AddPoint(VPointF(point.x(), point.y(), pointName, mx, my));
-    } else {
+    }
+    else
+    {
         data->UpdatePoint(id, VPointF(point.x(), point.y(), pointName, mx, my));
-        if(parse != Document::FullParse){
+        if (parse != Document::FullParse)
+        {
             doc->UpdateToolData(id, data);
         }
     }
     VDrawTool::AddRecord(id, Tool::Triangle, doc);
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         VToolPointOfIntersection *point = new VToolPointOfIntersection(doc, data, id, firstPointId,
                                                                        secondPointId, typeCreation);
         scene->addItem(point);
@@ -60,19 +70,24 @@ void VToolPointOfIntersection::Create(const qint64 _id, const QString &pointName
     }
 }
 
-void VToolPointOfIntersection::FullUpdateFromFile(){
+void VToolPointOfIntersection::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         firstPointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
         secondPointId = domElement.attribute(AttrSecondPoint, "").toLongLong();
     }
     VToolPoint::RefreshPointGeometry(VDrawTool::data.GetPoint(id));
 }
 
-void VToolPointOfIntersection::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolPointOfIntersection::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogPointOfIntersection->getPointName());
             domElement.setAttribute(AttrFirstPoint, QString().setNum(dialogPointOfIntersection->getFirstPointId()));
             domElement.setAttribute(AttrSecondPoint, QString().setNum(dialogPointOfIntersection->getSecondPointId()));
@@ -82,16 +97,19 @@ void VToolPointOfIntersection::FullUpdateFromGui(int result){
     dialogPointOfIntersection.clear();
 }
 
-void VToolPointOfIntersection::RemoveReferens(){
+void VToolPointOfIntersection::RemoveReferens()
+{
     doc->DecrementReferens(firstPointId);
     doc->DecrementReferens(secondPointId);
 }
 
-void VToolPointOfIntersection::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolPointOfIntersection::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogPointOfIntersection, this, event);
 }
 
-void VToolPointOfIntersection::AddToFile(){
+void VToolPointOfIntersection::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
diff --git a/tools/drawTools/vtoolpointofintersection.h b/tools/drawTools/vtoolpointofintersection.h
index 6aa69cd3c..d65f31ad6 100644
--- a/tools/drawTools/vtoolpointofintersection.h
+++ b/tools/drawTools/vtoolpointofintersection.h
@@ -4,7 +4,8 @@
 #include "vtoolpoint.h"
 #include "dialogs/dialogpointofintersection.h"
 
-class VToolPointOfIntersection : public VToolPoint{
+class VToolPointOfIntersection : public VToolPoint
+{
     Q_OBJECT
 public:
                  VToolPointOfIntersection(VDomDocument *doc, VContainer *data, const qint64 &id,
diff --git a/tools/drawTools/vtoolshoulderpoint.cpp b/tools/drawTools/vtoolshoulderpoint.cpp
index 77b2510e9..894a448f1 100644
--- a/tools/drawTools/vtoolshoulderpoint.cpp
+++ b/tools/drawTools/vtoolshoulderpoint.cpp
@@ -27,51 +27,57 @@ const QString VToolShoulderPoint::ToolType = QStringLiteral("shoulder");
 VToolShoulderPoint::VToolShoulderPoint(VDomDocument *doc, VContainer *data, const qint64 &id,
                                        const QString &typeLine, const QString &formula, const qint64 &p1Line,
                                        const qint64 &p2Line, const qint64 &pShoulder, Tool::Sources typeCreation,
-                                       QGraphicsItem * parent):
-    VToolLinePoint(doc, data, id, typeLine, formula, p1Line, 0, parent), p2Line(p2Line), pShoulder(pShoulder),
-    dialogShoulderPoint(QSharedPointer<DialogShoulderPoint>()){
-
-    if(typeCreation == Tool::FromGui){
+                                       QGraphicsItem * parent)
+    :VToolLinePoint(doc, data, id, typeLine, formula, p1Line, 0, parent), p2Line(p2Line), pShoulder(pShoulder),
+    dialogShoulderPoint(QSharedPointer<DialogShoulderPoint>())
+{
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VToolShoulderPoint::setDialog(){
-    Q_ASSERT(!dialogShoulderPoint.isNull());
-    if(!dialogShoulderPoint.isNull()){
-        VPointF p = VAbstractTool::data.GetPoint(id);
-        dialogShoulderPoint->setTypeLine(typeLine);
-        dialogShoulderPoint->setFormula(formula);
-        dialogShoulderPoint->setP1Line(basePointId, id);
-        dialogShoulderPoint->setP2Line(p2Line, id);
-        dialogShoulderPoint->setPShoulder(pShoulder, id);
-        dialogShoulderPoint->setPointName(p.name());
-    }
+void VToolShoulderPoint::setDialog()
+{
+    Q_ASSERT(dialogShoulderPoint.isNull() == false);
+    VPointF p = VAbstractTool::data.GetPoint(id);
+    dialogShoulderPoint->setTypeLine(typeLine);
+    dialogShoulderPoint->setFormula(formula);
+    dialogShoulderPoint->setP1Line(basePointId, id);
+    dialogShoulderPoint->setP2Line(p2Line, id);
+    dialogShoulderPoint->setPShoulder(pShoulder, id);
+    dialogShoulderPoint->setPointName(p.name());
 }
 
 QPointF VToolShoulderPoint::FindPoint(const QPointF &p1Line, const QPointF &p2Line, const QPointF &pShoulder,
-                                      const qreal &length){
+                                      const qreal &length)
+{
     QLineF line = QLineF(p1Line, p2Line);
     qreal dist = line.length();
-    if(dist>length){
+    if (dist>length)
+    {
         qDebug()<<"A3П2="<<toMM(length)<<"А30П ="<<toMM(dist);
-        throw"Не можу знайти точку плеча. Довжина А3П2 < А3П.";
+        throw "Не можу знайти точку плеча. Довжина А3П2 < А3П.";
     }
-    if(dist==length){
+    if (dist==length)
+    {
         return line.p2();
     }
     qreal step = 0.01;
-    while(1){
+    while (1)
+    {
         line.setLength(line.length()+step);
         QLineF line2 = QLineF(pShoulder, line.p2());
-        if(line2.length()>=length){
+        if (line2.length()>=length)
+        {
             return line.p2();
         }
     }
 }
 
 void VToolShoulderPoint::Create(QSharedPointer<DialogShoulderPoint> &dialog, VMainGraphicsScene *scene,
-                                VDomDocument *doc, VContainer *data){
+                                VDomDocument *doc, VContainer *data)
+{
     QString formula = dialog->getFormula();
     qint64 p1Line = dialog->getP1Line();
     qint64 p2Line = dialog->getP2Line();
@@ -86,7 +92,8 @@ void VToolShoulderPoint::Create(const qint64 _id, const QString &formula, const
                                 const qint64 &p2Line, const qint64 &pShoulder, const QString &typeLine,
                                 const QString &pointName, const qreal &mx, const qreal &my,
                                 VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
-                                const Document::Documents &parse, Tool::Sources typeCreation){
+                                const Document::Documents &parse, Tool::Sources typeCreation)
+{
     VPointF firstPoint = data->GetPoint(p1Line);
     VPointF secondPoint = data->GetPoint(p2Line);
     VPointF shoulderPoint = data->GetPoint(pShoulder);
@@ -94,24 +101,30 @@ void VToolShoulderPoint::Create(const qint64 _id, const QString &formula, const
     Calculator cal(data);
     QString errorMsg;
     qreal result = cal.eval(formula, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         QPointF fPoint = VToolShoulderPoint::FindPoint(firstPoint.toQPointF(), secondPoint.toQPointF(),
                                                        shoulderPoint.toQPointF(), toPixel(result));
         qint64 id =  _id;
-        if(typeCreation == Tool::FromGui){
+        if (typeCreation == Tool::FromGui)
+        {
             id = data->AddPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
             data->AddLine(p1Line, id);
             data->AddLine(p2Line, id);
-        } else {
-            data->UpdatePoint(id,VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
+        }
+        else
+        {
+            data->UpdatePoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
             data->AddLine(p1Line, id);
             data->AddLine(p2Line, id);
-            if(parse != Document::FullParse){
+            if (parse != Document::FullParse)
+            {
                 doc->UpdateToolData(id, data);
             }
         }
         VDrawTool::AddRecord(id, Tool::ShoulderPointTool, doc);
-        if(parse == Document::FullParse){
+        if (parse == Document::FullParse)
+        {
             VToolShoulderPoint *point = new VToolShoulderPoint(doc, data, id, typeLine, formula,
                                                                p1Line, p2Line, pShoulder,
                                                                typeCreation);
@@ -127,9 +140,11 @@ void VToolShoulderPoint::Create(const qint64 _id, const QString &formula, const
     }
 }
 
-void VToolShoulderPoint::FullUpdateFromFile(){
+void VToolShoulderPoint::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         typeLine = domElement.attribute(AttrTypeLine, "");
         formula = domElement.attribute(AttrLength, "");
         basePointId = domElement.attribute(AttrP1Line, "").toLongLong();
@@ -139,10 +154,13 @@ void VToolShoulderPoint::FullUpdateFromFile(){
     RefreshGeometry();
 }
 
-void VToolShoulderPoint::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolShoulderPoint::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogShoulderPoint->getPointName());
             domElement.setAttribute(AttrTypeLine, dialogShoulderPoint->getTypeLine());
             domElement.setAttribute(AttrLength, dialogShoulderPoint->getFormula());
@@ -155,16 +173,19 @@ void VToolShoulderPoint::FullUpdateFromGui(int result){
     dialogShoulderPoint.clear();
 }
 
-void VToolShoulderPoint::SetFactor(qreal factor){
+void VToolShoulderPoint::SetFactor(qreal factor)
+{
     VDrawTool::SetFactor(factor);
     RefreshGeometry();
 }
 
-void VToolShoulderPoint::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolShoulderPoint::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogShoulderPoint, this, event);
 }
 
-void VToolShoulderPoint::AddToFile(){
+void VToolShoulderPoint::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -183,7 +204,8 @@ void VToolShoulderPoint::AddToFile(){
     AddToCalculation(domElement);
 }
 
-void VToolShoulderPoint::RemoveReferens(){
+void VToolShoulderPoint::RemoveReferens()
+{
     doc->DecrementReferens(p2Line);
     doc->DecrementReferens(pShoulder);
     VToolLinePoint::RemoveReferens();
diff --git a/tools/drawTools/vtoolshoulderpoint.h b/tools/drawTools/vtoolshoulderpoint.h
index c56277620..e557fdbb2 100644
--- a/tools/drawTools/vtoolshoulderpoint.h
+++ b/tools/drawTools/vtoolshoulderpoint.h
@@ -25,7 +25,8 @@
 #include "vtoollinepoint.h"
 #include "dialogs/dialogshoulderpoint.h"
 
-class VToolShoulderPoint : public VToolLinePoint{
+class VToolShoulderPoint : public VToolLinePoint
+{
 public:
                    VToolShoulderPoint(VDomDocument *doc, VContainer *data, const qint64 &id, const QString &typeLine,
                                       const QString &formula, const qint64 &p1Line, const qint64 &p2Line,
diff --git a/tools/drawTools/vtoolsinglepoint.cpp b/tools/drawTools/vtoolsinglepoint.cpp
index 79f39759e..043c80a69 100644
--- a/tools/drawTools/vtoolsinglepoint.cpp
+++ b/tools/drawTools/vtoolsinglepoint.cpp
@@ -24,25 +24,27 @@
 const QString VToolSinglePoint::ToolType = QStringLiteral("single");
 
 VToolSinglePoint::VToolSinglePoint (VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources typeCreation,
-                                    QGraphicsItem * parent ):VToolPoint(doc, data, id, parent),
-    dialogSinglePoint(QSharedPointer<DialogSinglePoint>()){
+                                    QGraphicsItem * parent )
+    :VToolPoint(doc, data, id, parent), dialogSinglePoint(QSharedPointer<DialogSinglePoint>())
+{
     ignoreFullUpdate = true;
     this->setFlag(QGraphicsItem::ItemIsMovable, true);
     this->setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VToolSinglePoint::setDialog(){
-    Q_ASSERT(!dialogSinglePoint.isNull());
-    if(!dialogSinglePoint.isNull()){
-        VPointF p = VAbstractTool::data.GetPoint(id);
-        dialogSinglePoint->setData(p.name(), p.toQPointF());
-    }
+void VToolSinglePoint::setDialog()
+{
+    Q_ASSERT(dialogSinglePoint.isNull() == false);
+    VPointF p = VAbstractTool::data.GetPoint(id);
+    dialogSinglePoint->setData(p.name(), p.toQPointF());
 }
 
-void VToolSinglePoint::AddToFile(){
+void VToolSinglePoint::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -57,23 +59,28 @@ void VToolSinglePoint::AddToFile(){
     AddToCalculation(domElement);
 }
 
-QVariant VToolSinglePoint::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value){
-    if (change == ItemPositionChange && scene()) {
+QVariant VToolSinglePoint::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value)
+{
+    if (change == ItemPositionChange && scene())
+    {
         // value - это новое положение.
         QPointF newPos = value.toPointF();
         QRectF rect = scene()->sceneRect();
-        if (!rect.contains(newPos)) {
+        if (rect.contains(newPos) == false)
+        {
             // Сохраняем элемент внутри прямоугольника сцены.
             newPos.setX(qMin(rect.right(), qMax(newPos.x(), rect.left())));
             newPos.setY(qMin(rect.bottom(), qMax(newPos.y(), rect.top())));
             return newPos;
         }
     }
-    if (change == ItemPositionHasChanged && scene()) {
+    if (change == ItemPositionHasChanged && scene())
+    {
         // value - это новое положение.
         QPointF newPos = value.toPointF();
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrX, QString().setNum(toMM(newPos.x())));
             domElement.setAttribute(AttrY, QString().setNum(toMM(newPos.y())));
             //I don't now why but signal does not work.
@@ -83,26 +90,33 @@ QVariant VToolSinglePoint::itemChange(QGraphicsItem::GraphicsItemChange change,
     return QGraphicsItem::itemChange(change, value);
 }
 
-void VToolSinglePoint::decrementReferens(){
-    if(_referens > 1){
+void VToolSinglePoint::decrementReferens()
+{
+    if (_referens > 1)
+    {
         --_referens;
     }
 }
 
-void VToolSinglePoint::contextMenuEvent ( QGraphicsSceneContextMenuEvent * event ){
+void VToolSinglePoint::contextMenuEvent ( QGraphicsSceneContextMenuEvent * event )
+{
     ContextMenu(dialogSinglePoint, this, event, false);
 }
 
-void  VToolSinglePoint::FullUpdateFromFile(){
+void  VToolSinglePoint::FullUpdateFromFile()
+{
     RefreshPointGeometry(VAbstractTool::data.GetPoint(id));
 }
 
-void VToolSinglePoint::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolSinglePoint::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QPointF p = dialogSinglePoint->getPoint();
         QString name = dialogSinglePoint->getName();
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, name);
             domElement.setAttribute(AttrX, QString().setNum(toMM(p.x())));
             domElement.setAttribute(AttrY, QString().setNum(toMM(p.y())));
@@ -113,17 +127,22 @@ void VToolSinglePoint::FullUpdateFromGui(int result){
     dialogSinglePoint.clear();
 }
 
-void VToolSinglePoint::ChangedActivDraw(const QString newName){
-    if(nameActivDraw == newName){
+void VToolSinglePoint::ChangedActivDraw(const QString newName)
+{
+    if (nameActivDraw == newName)
+    {
         this->setFlag(QGraphicsItem::ItemIsSelectable, true);
         VToolPoint::ChangedActivDraw(newName);
-    } else {
+    }
+    else
+    {
         this->setFlag(QGraphicsItem::ItemIsSelectable, false);
         VToolPoint::ChangedActivDraw(newName);
     }
 }
 
-void VToolSinglePoint::SetFactor(qreal factor){
+void VToolSinglePoint::SetFactor(qreal factor)
+{
     VDrawTool::SetFactor(factor);
     RefreshPointGeometry(VAbstractTool::data.GetPoint(id));
 }
diff --git a/tools/drawTools/vtoolsinglepoint.h b/tools/drawTools/vtoolsinglepoint.h
index 65b9365cc..4265f8f83 100644
--- a/tools/drawTools/vtoolsinglepoint.h
+++ b/tools/drawTools/vtoolsinglepoint.h
@@ -25,7 +25,8 @@
 #include "dialogs/dialogsinglepoint.h"
 #include "vtoolpoint.h"
 
-class VToolSinglePoint : public VToolPoint{
+class VToolSinglePoint : public VToolPoint
+{
     Q_OBJECT
 public:
                  VToolSinglePoint (VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources typeCreation,
diff --git a/tools/drawTools/vtoolspline.cpp b/tools/drawTools/vtoolspline.cpp
index 60ed17a35..0c058806b 100644
--- a/tools/drawTools/vtoolspline.cpp
+++ b/tools/drawTools/vtoolspline.cpp
@@ -25,10 +25,11 @@
 const QString VToolSpline::TagName = QStringLiteral("spline");
 const QString VToolSpline::ToolType = QStringLiteral("simple");
 
-VToolSpline::VToolSpline(VDomDocument *doc, VContainer *data, qint64 id,
-                         Tool::Sources typeCreation,
-                         QGraphicsItem *parent):VDrawTool(doc, data, id), QGraphicsPathItem(parent),
-    dialogSpline(QSharedPointer<DialogSpline>()), controlPoints(QVector<VControlPointSpline *>()){
+VToolSpline::VToolSpline(VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources typeCreation,
+                         QGraphicsItem *parent)
+    :VDrawTool(doc, data, id), QGraphicsPathItem(parent), dialogSpline(QSharedPointer<DialogSpline>()),
+      controlPoints(QVector<VControlPointSpline *>())
+{
     ignoreFullUpdate = true;
 
     VSpline spl = data->GetSpline(id);
@@ -56,27 +57,28 @@ VToolSpline::VToolSpline(VDomDocument *doc, VContainer *data, qint64 id,
     connect(this, &VToolSpline::setEnabledPoint, controlPoint2, &VControlPointSpline::setEnabledPoint);
     controlPoints.append(controlPoint2);
 
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VToolSpline::setDialog(){
-    Q_ASSERT(!dialogSpline.isNull());
-    if(!dialogSpline.isNull()){
-        VSpline spl = VAbstractTool::data.GetSpline(id);
-        dialogSpline->setP1(spl.GetP1());
-        dialogSpline->setP4(spl.GetP4());
-        dialogSpline->setAngle1(spl.GetAngle1());
-        dialogSpline->setAngle2(spl.GetAngle2());
-        dialogSpline->setKAsm1(spl.GetKasm1());
-        dialogSpline->setKAsm2(spl.GetKasm2());
-        dialogSpline->setKCurve(spl.GetKcurve());
-    }
+void VToolSpline::setDialog()
+{
+    Q_ASSERT(dialogSpline.isNull() == false);
+    VSpline spl = VAbstractTool::data.GetSpline(id);
+    dialogSpline->setP1(spl.GetP1());
+    dialogSpline->setP4(spl.GetP4());
+    dialogSpline->setAngle1(spl.GetAngle1());
+    dialogSpline->setAngle2(spl.GetAngle2());
+    dialogSpline->setKAsm1(spl.GetKasm1());
+    dialogSpline->setKAsm2(spl.GetKasm2());
+    dialogSpline->setKCurve(spl.GetKcurve());
 }
 
 void VToolSpline::Create(QSharedPointer<DialogSpline> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
-                         VContainer *data){
+                         VContainer *data)
+{
     qint64 p1 = dialog->getP1();
     qint64 p4 = dialog->getP4();
     qreal kAsm1 = dialog->getKAsm1();
@@ -90,22 +92,28 @@ void VToolSpline::Create(QSharedPointer<DialogSpline> &dialog, VMainGraphicsScen
 
 void VToolSpline::Create(const qint64 _id, const qint64 &p1, const qint64 &p4, const qreal &kAsm1,
                          const qreal kAsm2, const qreal &angle1, const qreal &angle2, const qreal &kCurve,
-                         VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data, const Document::Documents &parse,
-                         Tool::Sources typeCreation){
+                         VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data,
+                         const Document::Documents &parse, Tool::Sources typeCreation)
+{
     VSpline spline = VSpline(data->DataPoints(), p1, p4, angle1, angle2, kAsm1, kAsm2, kCurve);
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->AddSpline(spline);
         data->AddLengthSpline(data->GetNameSpline(p1, p4), toMM(spline.GetLength()));
-    } else {
+    }
+    else
+    {
         data->UpdateSpline(id, spline);
         data->AddLengthSpline(data->GetNameSpline(p1, p4), toMM(spline.GetLength()));
-        if(parse != Document::FullParse){
+        if (parse != Document::FullParse)
+        {
             doc->UpdateToolData(id, data);
         }
     }
     VDrawTool::AddRecord(id, Tool::SplineTool, doc);
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         VToolSpline *spl = new VToolSpline(doc, data, id, typeCreation);
         scene->addItem(spl);
         connect(spl, &VToolSpline::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
@@ -117,12 +125,15 @@ void VToolSpline::Create(const qint64 _id, const qint64 &p1, const qint64 &p4, c
     }
 }
 
-void VToolSpline::FullUpdateFromFile(){
+void VToolSpline::FullUpdateFromFile()
+{
     RefreshGeometry();
 }
 
-void VToolSpline::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolSpline::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         VSpline spl = VSpline (VAbstractTool::data.DataPoints(), dialogSpline->getP1(),
                                dialogSpline->getP4(), dialogSpline->getAngle1(), dialogSpline->getAngle2(),
                                dialogSpline->getKAsm1(), dialogSpline->getKAsm2(), dialogSpline->getKCurve());
@@ -141,7 +152,8 @@ void VToolSpline::FullUpdateFromGui(int result){
         spl = VSpline (VAbstractTool::data.DataPoints(), dialogSpline->getP1(),  controlPoints[0]->pos(),
                        controlPoints[1]->pos(), dialogSpline->getP4(), dialogSpline->getKCurve());
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrPoint1, QString().setNum(spl.GetP1()));
             domElement.setAttribute(AttrPoint4, QString().setNum(spl.GetP4()));
             domElement.setAttribute(AttrAngle1, QString().setNum(spl.GetAngle1()));
@@ -156,16 +168,21 @@ void VToolSpline::FullUpdateFromGui(int result){
 }
 
 void VToolSpline::ControlPointChangePosition(const qint32 &indexSpline, SplinePoint::Position position,
-                                              const QPointF pos){
+                                              const QPointF pos)
+{
     Q_UNUSED(indexSpline);
     VSpline spl = VAbstractTool::data.GetSpline(id);
-    if(position == SplinePoint::FirstPoint){
+    if (position == SplinePoint::FirstPoint)
+    {
         spl.ModifiSpl (spl.GetP1(), pos, spl.GetP3(), spl.GetP4(), spl.GetKcurve());
-    } else {
+    }
+    else
+    {
         spl.ModifiSpl (spl.GetP1(), spl.GetP2(), pos, spl.GetP4(), spl.GetKcurve());
     }
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         domElement.setAttribute(AttrAngle1, QString().setNum(spl.GetAngle1()));
         domElement.setAttribute(AttrAngle2, QString().setNum(spl.GetAngle2()));
         domElement.setAttribute(AttrKAsm1, QString().setNum(spl.GetKasm1()));
@@ -175,11 +192,13 @@ void VToolSpline::ControlPointChangePosition(const qint32 &indexSpline, SplinePo
     }
 }
 
-void VToolSpline::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolSpline::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogSpline, this, event);
 }
 
-void VToolSpline::AddToFile(){
+void VToolSpline::AddToFile()
+{
     VSpline spl = VAbstractTool::data.GetSpline(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -196,30 +215,36 @@ void VToolSpline::AddToFile(){
     AddToCalculation(domElement);
 }
 
-void VToolSpline::mouseReleaseEvent(QGraphicsSceneMouseEvent *event){
-    if(event->button() == Qt::LeftButton){
+void VToolSpline::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
         emit ChoosedTool(id, Scene::Spline);
     }
     QGraphicsItem::mouseReleaseEvent(event);
 }
 
-void VToolSpline::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VToolSpline::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthMainLine/factor));
 }
 
-void VToolSpline::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VToolSpline::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthHairLine/factor));
 }
 
-void VToolSpline::RemoveReferens(){
+void VToolSpline::RemoveReferens()
+{
     VSpline spl = VAbstractTool::data.GetSpline(id);
     doc->DecrementReferens(spl.GetP1());
     doc->DecrementReferens(spl.GetP4());
 }
 
-void VToolSpline::RefreshGeometry(){
+void VToolSpline::RefreshGeometry()
+{
     this->setPen(QPen(currentColor, widthHairLine/factor));
     VSpline spl = VAbstractTool::data.GetSpline(id);
     QPainterPath path;
@@ -246,12 +271,16 @@ void VToolSpline::RefreshGeometry(){
 }
 
 
-void VToolSpline::ChangedActivDraw(const QString newName){
+void VToolSpline::ChangedActivDraw(const QString newName)
+{
     bool selectable = false;
-    if(nameActivDraw == newName){
+    if (nameActivDraw == newName)
+    {
         selectable = true;
         currentColor = Qt::black;
-    } else {
+    }
+    else
+    {
         selectable = false;
         currentColor = Qt::gray;
     }
@@ -262,11 +291,13 @@ void VToolSpline::ChangedActivDraw(const QString newName){
     VDrawTool::ChangedActivDraw(newName);
 }
 
-void VToolSpline::ShowTool(qint64 id, Qt::GlobalColor color, bool enable){
+void VToolSpline::ShowTool(qint64 id, Qt::GlobalColor color, bool enable)
+{
     ShowItem(this, id, color, enable);
 }
 
-void VToolSpline::SetFactor(qreal factor){
+void VToolSpline::SetFactor(qreal factor)
+{
     VDrawTool::SetFactor(factor);
     RefreshGeometry();
 }
diff --git a/tools/drawTools/vtoolspline.h b/tools/drawTools/vtoolspline.h
index a298b7ae4..bc5ccb9fa 100644
--- a/tools/drawTools/vtoolspline.h
+++ b/tools/drawTools/vtoolspline.h
@@ -28,7 +28,8 @@
 #include "widgets/vcontrolpointspline.h"
 #include "geometry/vsplinepath.h"
 
-class VToolSpline:public VDrawTool, public QGraphicsPathItem{
+class VToolSpline:public VDrawTool, public QGraphicsPathItem
+{
     Q_OBJECT
 public:
                  VToolSpline (VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources typeCreation,
diff --git a/tools/drawTools/vtoolsplinepath.cpp b/tools/drawTools/vtoolsplinepath.cpp
index 3e8cb0bee..fe793e24c 100644
--- a/tools/drawTools/vtoolsplinepath.cpp
+++ b/tools/drawTools/vtoolsplinepath.cpp
@@ -24,11 +24,11 @@
 const QString VToolSplinePath::TagName = QStringLiteral("spline");
 const QString VToolSplinePath::ToolType = QStringLiteral("path");
 
-VToolSplinePath::VToolSplinePath(VDomDocument *doc, VContainer *data, qint64 id,
-                                 Tool::Sources typeCreation,
-                                 QGraphicsItem *parent):VDrawTool(doc, data, id),
-    QGraphicsPathItem(parent), dialogSplinePath(QSharedPointer<DialogSplinePath>()),
-    controlPoints(QVector<VControlPointSpline *>()){
+VToolSplinePath::VToolSplinePath(VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources typeCreation,
+                                 QGraphicsItem *parent)
+    :VDrawTool(doc, data, id), QGraphicsPathItem(parent), dialogSplinePath(QSharedPointer<DialogSplinePath>()),
+    controlPoints(QVector<VControlPointSpline *>())
+{
     ignoreFullUpdate = true;
     VSplinePath splPath = data->GetSplinePath(id);
     QPainterPath path;
@@ -39,7 +39,8 @@ VToolSplinePath::VToolSplinePath(VDomDocument *doc, VContainer *data, qint64 id,
     this->setFlag(QGraphicsItem::ItemIsSelectable, true);
     this->setAcceptHoverEvents(true);
 
-    for(qint32 i = 1; i<=splPath.Count(); ++i){
+    for (qint32 i = 1; i<=splPath.Count(); ++i)
+    {
         VSpline spl = splPath.GetSpline(i);
         VControlPointSpline *controlPoint = new VControlPointSpline(i, SplinePoint::FirstPoint, spl.GetP2(),
                                                                      spl.GetPointP1().toQPointF(), this);
@@ -57,23 +58,25 @@ VToolSplinePath::VToolSplinePath(VDomDocument *doc, VContainer *data, qint64 id,
         connect(this, &VToolSplinePath::setEnabledPoint, controlPoint, &VControlPointSpline::setEnabledPoint);
         controlPoints.append(controlPoint);
     }
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VToolSplinePath::setDialog(){
-    Q_ASSERT(!dialogSplinePath.isNull());
-    if(!dialogSplinePath.isNull()){
-        VSplinePath splPath = VAbstractTool::data.GetSplinePath(id);
-        dialogSplinePath->SetPath(splPath);
-    }
+void VToolSplinePath::setDialog()
+{
+    Q_ASSERT(dialogSplinePath.isNull() == false);
+    VSplinePath splPath = VAbstractTool::data.GetSplinePath(id);
+    dialogSplinePath->SetPath(splPath);
 }
 
 void VToolSplinePath::Create(QSharedPointer<DialogSplinePath> &dialog, VMainGraphicsScene *scene,
-                             VDomDocument *doc, VContainer *data){
+                             VDomDocument *doc, VContainer *data)
+{
     VSplinePath path = dialog->GetPath();
-    for(qint32 i = 0; i < path.CountPoint(); ++i){
+    for (qint32 i = 0; i < path.CountPoint(); ++i)
+    {
         doc->IncrementReferens(path[i].P());
     }
     Create(0, path, scene, doc, data, Document::FullParse, Tool::FromGui);
@@ -81,20 +84,26 @@ void VToolSplinePath::Create(QSharedPointer<DialogSplinePath> &dialog, VMainGrap
 
 void VToolSplinePath::Create(const qint64 _id, const VSplinePath &path, VMainGraphicsScene *scene,
                              VDomDocument *doc, VContainer *data, const Document::Documents &parse,
-                             Tool::Sources typeCreation){
+                             Tool::Sources typeCreation)
+{
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->AddSplinePath(path);
         data->AddLengthSpline(data->GetNameSplinePath(path), toMM(path.GetLength()));
-    } else {
+    }
+    else
+    {
         data->UpdateSplinePath(id, path);
         data->AddLengthSpline(data->GetNameSplinePath(path), toMM(path.GetLength()));
-        if(parse != Document::FullParse){
+        if (parse != Document::FullParse)
+        {
             doc->UpdateToolData(id, data);
         }
     }
     VDrawTool::AddRecord(id, Tool::SplinePathTool, doc);
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         VToolSplinePath *spl = new VToolSplinePath(doc, data, id, typeCreation);
         scene->addItem(spl);
         connect(spl, &VToolSplinePath::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
@@ -104,14 +113,18 @@ void VToolSplinePath::Create(const qint64 _id, const VSplinePath &path, VMainGra
     }
 }
 
-void VToolSplinePath::FullUpdateFromFile(){
+void VToolSplinePath::FullUpdateFromFile()
+{
     RefreshGeometry();
 }
 
-void VToolSplinePath::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolSplinePath::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         VSplinePath splPath = dialogSplinePath->GetPath();
-        for(qint32 i = 1; i<=splPath.Count(); ++i){
+        for (qint32 i = 1; i<=splPath.Count(); ++i)
+        {
             VSpline spl = splPath.GetSpline(i);
             qint32 j = i*2;
             disconnect(controlPoints[j-2], &VControlPointSpline::ControlPointChangePosition, this,
@@ -131,7 +144,8 @@ void VToolSplinePath::FullUpdateFromGui(int result){
             CorectControlPoints(spl, splPath, i);
 
             QDomElement domElement = doc->elementById(QString().setNum(id));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 domElement.setAttribute(AttrKCurve, QString().setNum(splPath.getKCurve()));
                 UpdatePathPoint(domElement, splPath);
                 emit FullUpdateTree();
@@ -143,26 +157,31 @@ void VToolSplinePath::FullUpdateFromGui(int result){
 }
 
 void VToolSplinePath::ControlPointChangePosition(const qint32 &indexSpline, SplinePoint::Position position,
-                                                 const QPointF pos){
+                                                 const QPointF pos)
+{
     VSplinePath splPath = VAbstractTool::data.GetSplinePath(id);
     VSpline spl = splPath.GetSpline(indexSpline);
-    if(position == SplinePoint::FirstPoint){
+    if (position == SplinePoint::FirstPoint)
+    {
         spl.ModifiSpl (spl.GetP1(), pos, spl.GetP3(), spl.GetP4(), spl.GetKcurve());
-    } else {
+    }
+    else
+    {
         spl.ModifiSpl (spl.GetP1(), spl.GetP2(), pos, spl.GetP4(), spl.GetKcurve());
     }
 
     CorectControlPoints(spl, splPath, indexSpline);
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         domElement.setAttribute(AttrKCurve, QString().setNum(splPath.getKCurve()));
         UpdatePathPoint(domElement, splPath);
         emit FullUpdateTree();
     }
 }
 
-void VToolSplinePath::CorectControlPoints(const VSpline &spl, VSplinePath &splPath,
-                                          const qint32 &indexSpline){
+void VToolSplinePath::CorectControlPoints(const VSpline &spl, VSplinePath &splPath, const qint32 &indexSpline)
+{
     VSplinePoint p = splPath.GetSplinePoint(indexSpline, SplinePoint::FirstPoint);
     p.SetAngle(spl.GetAngle1());
     p.SetKAsm2(spl.GetKasm1());
@@ -174,12 +193,15 @@ void VToolSplinePath::CorectControlPoints(const VSpline &spl, VSplinePath &splPa
     splPath.UpdatePoint(indexSpline, SplinePoint::LastPoint, p);
 }
 
-void VToolSplinePath::UpdatePathPoint(QDomNode& node, VSplinePath &path){
+void VToolSplinePath::UpdatePathPoint(QDomNode& node, VSplinePath &path)
+{
     QDomNodeList nodeList = node.childNodes();
     qint32 num = nodeList.size();
-    for(qint32 i = 0; i < num; ++i){
+    for (qint32 i = 0; i < num; ++i)
+    {
         QDomElement domElement = nodeList.at(i).toElement();
-        if(!domElement.isNull()){
+        if (domElement.isNull() == false)
+        {
             VSplinePoint p = path[i];
             domElement.setAttribute(AttrPSpline, QString().setNum(p.P()));
             domElement.setAttribute(AttrKAsm1, QString().setNum(p.KAsm1()));
@@ -189,12 +211,16 @@ void VToolSplinePath::UpdatePathPoint(QDomNode& node, VSplinePath &path){
     }
 }
 
-void VToolSplinePath::ChangedActivDraw(const QString newName){
+void VToolSplinePath::ChangedActivDraw(const QString newName)
+{
     bool selectable = false;
-    if(nameActivDraw == newName){
+    if (nameActivDraw == newName)
+    {
         selectable = true;
         currentColor = Qt::black;
-    } else {
+    }
+    else
+    {
         selectable = false;
         currentColor = Qt::gray;
     }
@@ -205,20 +231,24 @@ void VToolSplinePath::ChangedActivDraw(const QString newName){
     VDrawTool::ChangedActivDraw(newName);
 }
 
-void VToolSplinePath::ShowTool(qint64 id, Qt::GlobalColor color, bool enable){
+void VToolSplinePath::ShowTool(qint64 id, Qt::GlobalColor color, bool enable)
+{
     ShowItem(this, id, color, enable);
 }
 
-void VToolSplinePath::SetFactor(qreal factor){
+void VToolSplinePath::SetFactor(qreal factor)
+{
     VDrawTool::SetFactor(factor);
     RefreshGeometry();
 }
 
-void VToolSplinePath::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolSplinePath::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogSplinePath, this, event);
 }
 
-void VToolSplinePath::AddToFile(){
+void VToolSplinePath::AddToFile()
+{
     VSplinePath splPath = VAbstractTool::data.GetSplinePath(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -226,14 +256,16 @@ void VToolSplinePath::AddToFile(){
     AddAttribute(domElement, AttrType, ToolType);
     AddAttribute(domElement, AttrKCurve, splPath.getKCurve());
 
-    for(qint32 i = 0; i < splPath.CountPoint(); ++i){
+    for (qint32 i = 0; i < splPath.CountPoint(); ++i)
+    {
         AddPathPoint(domElement, splPath[i]);
     }
 
     AddToCalculation(domElement);
 }
 
-void VToolSplinePath::AddPathPoint(QDomElement &domElement, const VSplinePoint &splPoint){
+void VToolSplinePath::AddPathPoint(QDomElement &domElement, const VSplinePoint &splPoint)
+{
     QDomElement pathPoint = doc->createElement(AttrPathPoint);
 
     AddAttribute(pathPoint, AttrPSpline, splPoint.P());
@@ -244,38 +276,46 @@ void VToolSplinePath::AddPathPoint(QDomElement &domElement, const VSplinePoint &
     domElement.appendChild(pathPoint);
 }
 
-void VToolSplinePath::mouseReleaseEvent(QGraphicsSceneMouseEvent *event){
-    if(event->button() == Qt::LeftButton){
+void VToolSplinePath::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
         emit ChoosedTool(id, Scene::SplinePath);
     }
     QGraphicsItem::mouseReleaseEvent(event);
 }
 
-void VToolSplinePath::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VToolSplinePath::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthMainLine/factor));
 }
 
-void VToolSplinePath::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VToolSplinePath::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthHairLine/factor));
 }
 
-void VToolSplinePath::RemoveReferens(){
+void VToolSplinePath::RemoveReferens()
+{
     VSplinePath splPath = VAbstractTool::data.GetSplinePath(id);
-    for(qint32 i = 0; i < splPath.Count(); ++i){
+    for (qint32 i = 0; i < splPath.Count(); ++i)
+    {
         doc->DecrementReferens(splPath[i].P());
     }
 }
 
-void VToolSplinePath::RefreshGeometry(){
+void VToolSplinePath::RefreshGeometry()
+{
     this->setPen(QPen(currentColor, widthHairLine/factor));
     VSplinePath splPath = VAbstractTool::data.GetSplinePath(id);
     QPainterPath path;
     path.addPath(splPath.GetPath());
     path.setFillRule( Qt::WindingFill );
     this->setPath(path);
-    for(qint32 i = 1; i<=splPath.Count(); ++i){
+    for (qint32 i = 1; i<=splPath.Count(); ++i)
+    {
         VSpline spl = splPath.GetSpline(i);
         QPointF splinePoint = spl.GetPointP1().toQPointF();
         QPointF controlPoint = spl.GetP2();
@@ -296,5 +336,4 @@ void VToolSplinePath::RefreshGeometry(){
         connect(controlPoints[j-1], &VControlPointSpline::ControlPointChangePosition, this,
                 &VToolSplinePath::ControlPointChangePosition);
     }
-
 }
diff --git a/tools/drawTools/vtoolsplinepath.h b/tools/drawTools/vtoolsplinepath.h
index 3bc9974e5..a1c3c51be 100644
--- a/tools/drawTools/vtoolsplinepath.h
+++ b/tools/drawTools/vtoolsplinepath.h
@@ -27,7 +27,8 @@
 #include "dialogs/dialogsplinepath.h"
 #include "widgets/vcontrolpointspline.h"
 
-class VToolSplinePath:public VDrawTool, public QGraphicsPathItem{
+class VToolSplinePath:public VDrawTool, public QGraphicsPathItem
+{
     Q_OBJECT
 public:
                   VToolSplinePath(VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources typeCreation,
diff --git a/tools/drawTools/vtooltriangle.cpp b/tools/drawTools/vtooltriangle.cpp
index 6c9c74b3b..57ea24d23 100644
--- a/tools/drawTools/vtooltriangle.cpp
+++ b/tools/drawTools/vtooltriangle.cpp
@@ -6,15 +6,18 @@ VToolTriangle::VToolTriangle(VDomDocument *doc, VContainer *data, const qint64 &
                              const qint64 &axisP1Id, const qint64 &axisP2Id, const qint64 &firstPointId,
                              const qint64 &secondPointId, Tool::Sources typeCreation, QGraphicsItem *parent)
     :VToolPoint(doc, data, id, parent), axisP1Id(axisP1Id), axisP2Id(axisP2Id), firstPointId(firstPointId),
-      secondPointId(secondPointId), dialogTriangle(QSharedPointer<DialogTriangle>()) {
+      secondPointId(secondPointId), dialogTriangle(QSharedPointer<DialogTriangle>())
+{
     ignoreFullUpdate = true;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VToolTriangle::setDialog(){
-    Q_ASSERT(!dialogTriangle.isNull());
+void VToolTriangle::setDialog()
+{
+    Q_ASSERT(dialogTriangle.isNull() == false);
     VPointF p = VAbstractTool::data.GetPoint(id);
     dialogTriangle->setAxisP1Id(axisP1Id, id);
     dialogTriangle->setAxisP2Id(axisP2Id, id);
@@ -24,7 +27,8 @@ void VToolTriangle::setDialog(){
 }
 
 void VToolTriangle::Create(QSharedPointer<DialogTriangle> &dialog, VMainGraphicsScene *scene,
-                           VDomDocument *doc, VContainer *data){
+                           VDomDocument *doc, VContainer *data)
+{
     qint64 axisP1Id = dialog->getAxisP1Id();
     qint64 axisP2Id = dialog->getAxisP2Id();
     qint64 firstPointId = dialog->getFirstPointId();
@@ -37,7 +41,8 @@ void VToolTriangle::Create(QSharedPointer<DialogTriangle> &dialog, VMainGraphics
 void VToolTriangle::Create(const qint64 _id, const QString &pointName, const qint64 &axisP1Id,
                            const qint64 &axisP2Id, const qint64 &firstPointId, const qint64 &secondPointId,
                            const qreal &mx, const qreal &my, VMainGraphicsScene *scene, VDomDocument *doc,
-                           VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation){
+                           VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation)
+{
     VPointF axisP1 = data->GetPoint(axisP1Id);
     VPointF axisP2 = data->GetPoint(axisP2Id);
     VPointF firstPoint = data->GetPoint(firstPointId);
@@ -46,16 +51,21 @@ void VToolTriangle::Create(const qint64 _id, const QString &pointName, const qin
     QPointF point = FindPoint(axisP1.toQPointF(), axisP2.toQPointF(), firstPoint.toQPointF(),
                               secondPoint.toQPointF());
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->AddPoint(VPointF(point.x(), point.y(), pointName, mx, my));
-    } else {
+    }
+    else
+    {
         data->UpdatePoint(id, VPointF(point.x(), point.y(), pointName, mx, my));
-        if(parse != Document::FullParse){
+        if (parse != Document::FullParse)
+        {
             doc->UpdateToolData(id, data);
         }
     }
     VDrawTool::AddRecord(id, Tool::Triangle, doc);
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         VToolTriangle *point = new VToolTriangle(doc, data, id, axisP1Id, axisP2Id, firstPointId,
                                                  secondPointId, typeCreation);
         scene->addItem(point);
@@ -71,41 +81,50 @@ void VToolTriangle::Create(const qint64 _id, const QString &pointName, const qin
 }
 
 QPointF VToolTriangle::FindPoint(const QPointF axisP1, const QPointF axisP2, const QPointF firstPoint,
-                                 const QPointF secondPoint){
+                                 const QPointF secondPoint)
+{
     qreal c = QLineF(firstPoint, secondPoint).length();
     qreal a = QLineF(axisP2, firstPoint).length();
     qreal b = QLineF(axisP2, secondPoint).length();
-    if(c*c == a*a + b*b){
+    if (c*c == a*a + b*b)
+    {
         QLineF l1(axisP2, firstPoint);
         QLineF l2(axisP2, secondPoint);
-        if(l1.angleTo(l2) == 90 || l2.angleTo(l1) == 90){
+        if (l1.angleTo(l2) == 90 || l2.angleTo(l1) == 90)
+        {
             return axisP2;
         }
     }
 
     QLineF line = QLineF(axisP1, axisP2);
     qreal step = 0.01;
-    while(1){
+    while (1)
+    {
         line.setLength(line.length()+step);
         a = QLineF(line.p2(), firstPoint).length();
         b = QLineF(line.p2(), secondPoint).length();
-        if(static_cast<qint32>(c*c) == static_cast<qint32>(a*a + b*b)){
+        if (static_cast<qint32>(c*c) == static_cast<qint32>(a*a + b*b))
+        {
             QLineF l1(axisP2, firstPoint);
             QLineF l2(axisP2, secondPoint);
-            if(l1.angleTo(l2) == 90 || l2.angleTo(l1) == 90){
+            if (l1.angleTo(l2) == 90 || l2.angleTo(l1) == 90)
+            {
                 return line.p2();
             }
         }
-        if(c*c < a*a + b*b){
+        if (c*c < a*a + b*b)
+        {
             qWarning()<<tr("Can't find point.")<<Q_FUNC_INFO;
             return line.p2();
         }
     }
 }
 
-void VToolTriangle::FullUpdateFromFile(){
+void VToolTriangle::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         axisP1Id = domElement.attribute(AttrAxisP1, "").toLongLong();
         axisP2Id = domElement.attribute(AttrAxisP2, "").toLongLong();
         firstPointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
@@ -114,10 +133,13 @@ void VToolTriangle::FullUpdateFromFile(){
     VToolPoint::RefreshPointGeometry(VDrawTool::data.GetPoint(id));
 }
 
-void VToolTriangle::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolTriangle::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogTriangle->getPointName());
             domElement.setAttribute(AttrAxisP1, QString().setNum(dialogTriangle->getAxisP1Id()));
             domElement.setAttribute(AttrAxisP2, QString().setNum(dialogTriangle->getAxisP2Id()));
@@ -130,18 +152,21 @@ void VToolTriangle::FullUpdateFromGui(int result){
     dialogTriangle.clear();
 }
 
-void VToolTriangle::RemoveReferens(){
+void VToolTriangle::RemoveReferens()
+{
     doc->DecrementReferens(axisP1Id);
     doc->DecrementReferens(axisP2Id);
     doc->DecrementReferens(firstPointId);
     doc->DecrementReferens(secondPointId);
 }
 
-void VToolTriangle::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolTriangle::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogTriangle, this, event);
 }
 
-void VToolTriangle::AddToFile(){
+void VToolTriangle::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
diff --git a/tools/drawTools/vtooltriangle.h b/tools/drawTools/vtooltriangle.h
index 63b07c06a..349ced7fd 100644
--- a/tools/drawTools/vtooltriangle.h
+++ b/tools/drawTools/vtooltriangle.h
@@ -25,7 +25,8 @@
 #include "vtoolpoint.h"
 #include "dialogs/dialogtriangle.h"
 
-class VToolTriangle : public VToolPoint{
+class VToolTriangle : public VToolPoint
+{
     Q_OBJECT
 public:
                    VToolTriangle(VDomDocument *doc, VContainer *data, const qint64 &id, const qint64 &axisP1Id,
diff --git a/tools/modelingTools/vmodelingalongline.cpp b/tools/modelingTools/vmodelingalongline.cpp
index 30da7536d..eda3d393d 100644
--- a/tools/modelingTools/vmodelingalongline.cpp
+++ b/tools/modelingTools/vmodelingalongline.cpp
@@ -27,18 +27,21 @@ const QString VModelingAlongLine::ToolType = QStringLiteral("alongLine");
 VModelingAlongLine::VModelingAlongLine(VDomDocument *doc, VContainer *data, qint64 id,
                                        const QString &formula, const qint64 &firstPointId,
                                        const qint64 &secondPointId, const QString &typeLine,
-                                       Tool::Sources typeCreation, QGraphicsItem *parent):
-    VModelingLinePoint(doc, data, id, typeLine, formula, firstPointId, 0, parent),
-    secondPointId(secondPointId), dialogAlongLine(QSharedPointer<DialogAlongLine>()){
-
-    if(typeCreation == Tool::FromGui){
+                                       Tool::Sources typeCreation, QGraphicsItem *parent)
+    :VModelingLinePoint(doc, data, id, typeLine, formula, firstPointId, 0, parent), secondPointId(secondPointId),
+      dialogAlongLine(QSharedPointer<DialogAlongLine>())
+{
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VModelingAlongLine::FullUpdateFromFile(){
+void VModelingAlongLine::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         typeLine = domElement.attribute(AttrTypeLine, "");
         formula = domElement.attribute(AttrLength, "");
         basePointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
@@ -47,10 +50,13 @@ void VModelingAlongLine::FullUpdateFromFile(){
     RefreshGeometry();
 }
 
-void VModelingAlongLine::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VModelingAlongLine::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogAlongLine->getPointName());
             domElement.setAttribute(AttrTypeLine, dialogAlongLine->getTypeLine());
             domElement.setAttribute(AttrLength, dialogAlongLine->getFormula());
@@ -63,11 +69,13 @@ void VModelingAlongLine::FullUpdateFromGui(int result){
     dialogAlongLine.clear();
 }
 
-void VModelingAlongLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VModelingAlongLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogAlongLine, this, event);
 }
 
-void VModelingAlongLine::AddToFile(){
+void VModelingAlongLine::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetModelingPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -85,25 +93,26 @@ void VModelingAlongLine::AddToFile(){
     AddToModeling(domElement);
 }
 
-void VModelingAlongLine::RemoveReferens(){
+void VModelingAlongLine::RemoveReferens()
+{
     doc->DecrementReferens(secondPointId);
     VModelingLinePoint::RemoveReferens();
 }
 
-void VModelingAlongLine::setDialog(){
-    Q_ASSERT(!dialogAlongLine.isNull());
-    if(!dialogAlongLine.isNull()){
-        VPointF p = VAbstractTool::data.GetModelingPoint(id);
-        dialogAlongLine->setTypeLine(typeLine);
-        dialogAlongLine->setFormula(formula);
-        dialogAlongLine->setFirstPointId(basePointId, id);
-        dialogAlongLine->setSecondPointId(secondPointId, id);
-        dialogAlongLine->setPointName(p.name());
-    }
+void VModelingAlongLine::setDialog()
+{
+    Q_ASSERT(dialogAlongLine.isNull() == false);
+    VPointF p = VAbstractTool::data.GetModelingPoint(id);
+    dialogAlongLine->setTypeLine(typeLine);
+    dialogAlongLine->setFormula(formula);
+    dialogAlongLine->setFirstPointId(basePointId, id);
+    dialogAlongLine->setSecondPointId(secondPointId, id);
+    dialogAlongLine->setPointName(p.name());
 }
 
-VModelingAlongLine *VModelingAlongLine::Create(QSharedPointer<DialogAlongLine> &dialog,
-                                               VDomDocument *doc, VContainer *data){
+VModelingAlongLine *VModelingAlongLine::Create(QSharedPointer<DialogAlongLine> &dialog, VDomDocument *doc,
+                                               VContainer *data)
+{
     QString formula = dialog->getFormula();
     qint64 firstPointId = dialog->getFirstPointId();
     qint64 secondPointId = dialog->getSecondPointId();
@@ -113,12 +122,12 @@ VModelingAlongLine *VModelingAlongLine::Create(QSharedPointer<DialogAlongLine> &
            Document::FullParse, Tool::FromGui);
 }
 
-VModelingAlongLine *VModelingAlongLine::Create(const qint64 _id, const QString &pointName,
-                                               const QString &typeLine, const QString &formula,
-                                               const qint64 &firstPointId, const qint64 &secondPointId,
-                                               const qreal &mx, const qreal &my, VDomDocument *doc,
-                                               VContainer *data, const Document::Documents &parse,
-                                               Tool::Sources typeCreation){
+VModelingAlongLine *VModelingAlongLine::Create(const qint64 _id, const QString &pointName, const QString &typeLine,
+                                               const QString &formula, const qint64 &firstPointId,
+                                               const qint64 &secondPointId, const qreal &mx, const qreal &my,
+                                               VDomDocument *doc, VContainer *data, const Document::Documents &parse,
+                                               Tool::Sources typeCreation)
+{
     VModelingAlongLine *point = 0;
     VPointF firstPoint = data->GetModelingPoint(firstPointId);
     VPointF secondPoint = data->GetModelingPoint(secondPointId);
@@ -126,21 +135,27 @@ VModelingAlongLine *VModelingAlongLine::Create(const qint64 _id, const QString &
     Calculator cal(data);
     QString errorMsg;
     qreal result = cal.eval(formula, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         line.setLength(toPixel(result));
         qint64 id = _id;
-        if(typeCreation == Tool::FromGui){
+        if (typeCreation == Tool::FromGui)
+        {
             id = data->AddModelingPoint(VPointF(line.p2().x(), line.p2().y(), pointName, mx, my));
-        } else {
+        }
+        else
+        {
             data->UpdateModelingPoint(id, VPointF(line.p2().x(), line.p2().y(), pointName, mx, my));
-            if(parse != Document::FullParse){
+            if (parse != Document::FullParse)
+            {
                 doc->UpdateToolData(id, data);
             }
         }
         data->AddLine(firstPointId, id);
         data->AddLine(id, secondPointId);
 
-        if(parse == Document::FullParse){
+        if (parse == Document::FullParse)
+        {
             point = new VModelingAlongLine(doc, data, id, formula, firstPointId, secondPointId, typeLine,
                                            typeCreation);
             doc->AddTool(id, point);
diff --git a/tools/modelingTools/vmodelingalongline.h b/tools/modelingTools/vmodelingalongline.h
index eceb805b3..10806c529 100644
--- a/tools/modelingTools/vmodelingalongline.h
+++ b/tools/modelingTools/vmodelingalongline.h
@@ -25,7 +25,8 @@
 #include "vmodelinglinepoint.h"
 #include "dialogs/dialogalongline.h"
 
-class VModelingAlongLine : public VModelingLinePoint{
+class VModelingAlongLine : public VModelingLinePoint
+{
     Q_OBJECT
 public:
                                VModelingAlongLine(VDomDocument *doc, VContainer *data, qint64 id,
diff --git a/tools/modelingTools/vmodelingarc.cpp b/tools/modelingTools/vmodelingarc.cpp
index 6181db5c7..79cd93d05 100644
--- a/tools/modelingTools/vmodelingarc.cpp
+++ b/tools/modelingTools/vmodelingarc.cpp
@@ -26,30 +26,32 @@ const QString VModelingArc::TagName = QStringLiteral("arc");
 const QString VModelingArc::ToolType = QStringLiteral("simple");
 
 VModelingArc::VModelingArc(VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources typeCreation,
-                           QGraphicsItem *parent):VModelingTool(doc, data, id), QGraphicsPathItem(parent),
-    dialogArc(QSharedPointer<DialogArc>()){
+                           QGraphicsItem *parent)
+    :VModelingTool(doc, data, id), QGraphicsPathItem(parent), dialogArc(QSharedPointer<DialogArc>())
+{
     this->setPen(QPen(baseColor, widthHairLine));
     this->setFlag(QGraphicsItem::ItemIsSelectable, true);
     this->setAcceptHoverEvents(true);
     RefreshGeometry();
 
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VModelingArc::setDialog(){
-    Q_ASSERT(!dialogArc.isNull());
-    if(!dialogArc.isNull()){
-        VArc arc = VAbstractTool::data.GetModelingArc(id);
-        dialogArc->SetCenter(arc.GetCenter());
-        dialogArc->SetRadius(arc.GetFormulaRadius());
-        dialogArc->SetF1(arc.GetFormulaF1());
-        dialogArc->SetF2(arc.GetFormulaF2());
-    }
+void VModelingArc::setDialog()
+{
+    Q_ASSERT(dialogArc.isNull() == false);
+    VArc arc = VAbstractTool::data.GetModelingArc(id);
+    dialogArc->SetCenter(arc.GetCenter());
+    dialogArc->SetRadius(arc.GetFormulaRadius());
+    dialogArc->SetF1(arc.GetFormulaF1());
+    dialogArc->SetF2(arc.GetFormulaF2());
 }
 
-VModelingArc* VModelingArc::Create(QSharedPointer<DialogArc> &dialog, VDomDocument *doc, VContainer *data){
+VModelingArc* VModelingArc::Create(QSharedPointer<DialogArc> &dialog, VDomDocument *doc, VContainer *data)
+{
     qint64 center = dialog->GetCenter();
     QString radius = dialog->GetRadius();
     QString f1 = dialog->GetF1();
@@ -59,41 +61,50 @@ VModelingArc* VModelingArc::Create(QSharedPointer<DialogArc> &dialog, VDomDocume
 
 VModelingArc* VModelingArc::Create(const qint64 _id, const qint64 &center, const QString &radius,
                                    const QString &f1, const QString &f2, VDomDocument *doc,
-                                   VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation){
+                                   VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation)
+{
     VModelingArc *toolArc = 0;
     qreal calcRadius = 0, calcF1 = 0, calcF2 = 0;
 
     Calculator cal(data);
     QString errorMsg;
     qreal result = cal.eval(radius, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         calcRadius = toPixel(result);
     }
 
     errorMsg.clear();
     result = cal.eval(f1, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         calcF1 = result;
     }
 
     errorMsg.clear();
     result = cal.eval(f2, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         calcF2 = result;
     }
 
     VArc arc = VArc(data->DataModelingPoints(), center, calcRadius, radius, calcF1, f1, calcF2, f2 );
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->AddModelingArc(arc);
-    } else {
+    }
+    else
+    {
         data->UpdateModelingArc(id, arc);
-        if(parse != Document::FullParse){
+        if (parse != Document::FullParse)
+        {
             doc->UpdateToolData(id, data);
         }
     }
-    data->AddLengthArc(data->GetNameArc(center,id, Draw::Modeling), toMM(arc.GetLength()));
-    if(parse == Document::FullParse){
+    data->AddLengthArc(data->GetNameArc(center, id, Draw::Modeling), toMM(arc.GetLength()));
+    if (parse == Document::FullParse)
+    {
         toolArc = new VModelingArc(doc, data, id, typeCreation);
         doc->AddTool(id, toolArc);
         doc->IncrementReferens(center);
@@ -101,14 +112,18 @@ VModelingArc* VModelingArc::Create(const qint64 _id, const qint64 &center, const
     return toolArc;
 }
 
-void VModelingArc::FullUpdateFromFile(){
+void VModelingArc::FullUpdateFromFile()
+{
     RefreshGeometry();
 }
 
-void VModelingArc::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VModelingArc::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrCenter, QString().setNum(dialogArc->GetCenter()));
             domElement.setAttribute(AttrRadius, dialogArc->GetRadius());
             domElement.setAttribute(AttrAngle1, dialogArc->GetF1());
@@ -119,11 +134,13 @@ void VModelingArc::FullUpdateFromGui(int result){
     dialogArc.clear();
 }
 
-void VModelingArc::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VModelingArc::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogArc, this, event);
 }
 
-void VModelingArc::AddToFile(){
+void VModelingArc::AddToFile()
+{
     VArc arc = VAbstractTool::data.GetModelingArc(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -137,29 +154,35 @@ void VModelingArc::AddToFile(){
     AddToModeling(domElement);
 }
 
-void VModelingArc::mouseReleaseEvent(QGraphicsSceneMouseEvent *event){
-    if(event->button() == Qt::LeftButton){
+void VModelingArc::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
         emit ChoosedTool(id, Scene::Arc);
     }
     QGraphicsItem::mouseReleaseEvent(event);
 }
 
-void VModelingArc::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VModelingArc::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthMainLine));
 }
 
-void VModelingArc::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VModelingArc::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthHairLine));
 }
 
-void VModelingArc::RemoveReferens(){
+void VModelingArc::RemoveReferens()
+{
     VArc arc = VAbstractTool::data.GetModelingArc(id);
     doc->DecrementReferens(arc.GetCenter());
 }
 
-void VModelingArc::RefreshGeometry(){
+void VModelingArc::RefreshGeometry()
+{
     VArc arc = VAbstractTool::data.GetModelingArc(id);
     QPainterPath path;
     path.addPath(arc.GetPath());
diff --git a/tools/modelingTools/vmodelingarc.h b/tools/modelingTools/vmodelingarc.h
index 18c20f897..5604adf1b 100644
--- a/tools/modelingTools/vmodelingarc.h
+++ b/tools/modelingTools/vmodelingarc.h
@@ -27,7 +27,8 @@
 #include "dialogs/dialogarc.h"
 #include "widgets/vcontrolpointspline.h"
 
-class VModelingArc :public VModelingTool, public QGraphicsPathItem{
+class VModelingArc :public VModelingTool, public QGraphicsPathItem
+{
     Q_OBJECT
 public:
                          VModelingArc(VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources typeCreation,
diff --git a/tools/modelingTools/vmodelingbisector.cpp b/tools/modelingTools/vmodelingbisector.cpp
index fa84f937b..34870255b 100644
--- a/tools/modelingTools/vmodelingbisector.cpp
+++ b/tools/modelingTools/vmodelingbisector.cpp
@@ -28,32 +28,34 @@ const QString VModelingBisector::ToolType = QStringLiteral("bisector");
 VModelingBisector::VModelingBisector(VDomDocument *doc, VContainer *data, const qint64 &id,
                              const QString &typeLine, const QString &formula, const qint64 &firstPointId,
                              const qint64 &secondPointId, const qint64 &thirdPointId, Tool::Sources typeCreation,
-                             QGraphicsItem *parent):
-    VModelingLinePoint(doc, data, id, typeLine, formula, secondPointId, 0, parent), firstPointId(0),
-    thirdPointId(0), dialogBisector(QSharedPointer<DialogBisector>()){
+                             QGraphicsItem *parent)
+    :VModelingLinePoint(doc, data, id, typeLine, formula, secondPointId, 0, parent), firstPointId(0),
+    thirdPointId(0), dialogBisector(QSharedPointer<DialogBisector>())
+{
     this->firstPointId = firstPointId;
     this->thirdPointId = thirdPointId;
 
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VModelingBisector::setDialog(){
-    Q_ASSERT(!dialogBisector.isNull());
-    if(!dialogBisector.isNull()){
-        VPointF p = VAbstractTool::data.GetModelingPoint(id);
-        dialogBisector->setTypeLine(typeLine);
-        dialogBisector->setFormula(formula);
-        dialogBisector->setFirstPointId(firstPointId, id);
-        dialogBisector->setSecondPointId(basePointId, id);
-        dialogBisector->setThirdPointId(thirdPointId, id);
-        dialogBisector->setPointName(p.name());
-    }
+void VModelingBisector::setDialog()
+{
+    Q_ASSERT(dialogBisector.isNull() == false);
+    VPointF p = VAbstractTool::data.GetModelingPoint(id);
+    dialogBisector->setTypeLine(typeLine);
+    dialogBisector->setFormula(formula);
+    dialogBisector->setFirstPointId(firstPointId, id);
+    dialogBisector->setSecondPointId(basePointId, id);
+    dialogBisector->setThirdPointId(thirdPointId, id);
+    dialogBisector->setPointName(p.name());
 }
 
 VModelingBisector *VModelingBisector::Create(QSharedPointer<DialogBisector> &dialog, VDomDocument *doc,
-                                             VContainer *data){
+                                             VContainer *data)
+{
     QString formula = dialog->getFormula();
     qint64 firstPointId = dialog->getFirstPointId();
     qint64 secondPointId = dialog->getSecondPointId();
@@ -69,7 +71,8 @@ VModelingBisector *VModelingBisector::Create(const qint64 _id, const QString &fo
                                              const qint64 &thirdPointId, const QString &typeLine,
                                              const QString &pointName, const qreal &mx, const qreal &my,
                                              VDomDocument *doc, VContainer *data, const Document::Documents &parse,
-                                             Tool::Sources typeCreation){
+                                             Tool::Sources typeCreation)
+{
     VModelingBisector *point = 0;
     VPointF firstPoint = data->GetModelingPoint(firstPointId);
     VPointF secondPoint = data->GetModelingPoint(secondPointId);
@@ -78,20 +81,26 @@ VModelingBisector *VModelingBisector::Create(const qint64 _id, const QString &fo
     Calculator cal(data);
     QString errorMsg;
     qreal result = cal.eval(formula, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         QPointF fPoint = VToolBisector::FindPoint(firstPoint.toQPointF(), secondPoint.toQPointF(),
                                                   thirdPoint.toQPointF(), toPixel(result));
         qint64 id = _id;
-        if(typeCreation == Tool::FromGui){
+        if (typeCreation == Tool::FromGui)
+        {
             id = data->AddModelingPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
-        } else {
+        }
+        else
+        {
             data->UpdateModelingPoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
-            if(parse != Document::FullParse){
+            if (parse != Document::FullParse)
+            {
                 doc->UpdateToolData(id, data);
             }
         }
         data->AddLine(firstPointId, id, Draw::Modeling);
-        if(parse == Document::FullParse){
+        if (parse == Document::FullParse)
+        {
             point = new VModelingBisector(doc, data, id, typeLine, formula, firstPointId, secondPointId,
                                           thirdPointId, typeCreation);
             doc->AddTool(id, point);
@@ -103,9 +112,11 @@ VModelingBisector *VModelingBisector::Create(const qint64 _id, const QString &fo
     return point;
 }
 
-void VModelingBisector::FullUpdateFromFile(){
+void VModelingBisector::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         typeLine = domElement.attribute(AttrTypeLine, "");
         formula = domElement.attribute(AttrLength, "");
         firstPointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
@@ -115,10 +126,13 @@ void VModelingBisector::FullUpdateFromFile(){
     RefreshGeometry();
 }
 
-void VModelingBisector::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VModelingBisector::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogBisector->getPointName());
             domElement.setAttribute(AttrTypeLine, dialogBisector->getTypeLine());
             domElement.setAttribute(AttrLength, dialogBisector->getFormula());
@@ -131,11 +145,13 @@ void VModelingBisector::FullUpdateFromGui(int result){
     dialogBisector.clear();
 }
 
-void VModelingBisector::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VModelingBisector::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogBisector, this, event);
 }
 
-void VModelingBisector::AddToFile(){
+void VModelingBisector::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetModelingPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -154,7 +170,8 @@ void VModelingBisector::AddToFile(){
     AddToModeling(domElement);
 }
 
-void VModelingBisector::RemoveReferens(){
+void VModelingBisector::RemoveReferens()
+{
     doc->DecrementReferens(firstPointId);
     doc->DecrementReferens(thirdPointId);
     VModelingLinePoint::RemoveReferens();
diff --git a/tools/modelingTools/vmodelingbisector.h b/tools/modelingTools/vmodelingbisector.h
index 2a84ac1fc..a80bfdb20 100644
--- a/tools/modelingTools/vmodelingbisector.h
+++ b/tools/modelingTools/vmodelingbisector.h
@@ -25,7 +25,8 @@
 #include "vmodelinglinepoint.h"
 #include "dialogs/dialogbisector.h"
 
-class VModelingBisector : public VModelingLinePoint{
+class VModelingBisector : public VModelingLinePoint
+{
     Q_OBJECT
 public:
                               VModelingBisector(VDomDocument *doc, VContainer *data, const qint64 &id,
diff --git a/tools/modelingTools/vmodelingendline.cpp b/tools/modelingTools/vmodelingendline.cpp
index fa4b51f5f..d5d2349d8 100644
--- a/tools/modelingTools/vmodelingendline.cpp
+++ b/tools/modelingTools/vmodelingendline.cpp
@@ -26,18 +26,19 @@ const QString VModelingEndLine::ToolType = QStringLiteral("endLine");
 
 VModelingEndLine::VModelingEndLine(VDomDocument *doc, VContainer *data, const qint64 &id,
                                    const QString &typeLine, const QString &formula, const qreal &angle,
-                                   const qint64 &basePointId, Tool::Sources typeCreation,
-                                   QGraphicsItem *parent):
-    VModelingLinePoint(doc, data, id, typeLine, formula, basePointId, angle, parent),
-    dialogEndLine(QSharedPointer<DialogEndLine>()){
-
-    if(typeCreation == Tool::FromGui){
+                                   const qint64 &basePointId, Tool::Sources typeCreation, QGraphicsItem *parent)
+    :VModelingLinePoint(doc, data, id, typeLine, formula, basePointId, angle, parent),
+    dialogEndLine(QSharedPointer<DialogEndLine>())
+{
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VModelingEndLine::setDialog(){
-    Q_ASSERT(!dialogEndLine.isNull());
+void VModelingEndLine::setDialog()
+{
+    Q_ASSERT(dialogEndLine.isNull() == false);
     VPointF p = VAbstractTool::data.GetModelingPoint(id);
     dialogEndLine->setTypeLine(typeLine);
     dialogEndLine->setFormula(formula);
@@ -46,8 +47,8 @@ void VModelingEndLine::setDialog(){
     dialogEndLine->setPointName(p.name());
 }
 
-VModelingEndLine *VModelingEndLine::Create(QSharedPointer<DialogEndLine> &dialog, VDomDocument *doc,
-                                           VContainer *data){
+VModelingEndLine *VModelingEndLine::Create(QSharedPointer<DialogEndLine> &dialog, VDomDocument *doc, VContainer *data)
+{
     QString pointName = dialog->getPointName();
     QString typeLine = dialog->getTypeLine();
     QString formula = dialog->getFormula();
@@ -61,27 +62,34 @@ VModelingEndLine *VModelingEndLine::Create(const qint64 _id, const QString &poin
                                            const QString &typeLine, const QString &formula,
                                            const qreal &angle, const qint64 &basePointId, const qreal &mx,
                                            const qreal &my, VDomDocument *doc, VContainer *data,
-                                           const Document::Documents &parse, Tool::Sources typeCreation){
+                                           const Document::Documents &parse, Tool::Sources typeCreation)
+{
     VModelingEndLine *point = 0;
     VPointF basePoint = data->GetModelingPoint(basePointId);
     QLineF line = QLineF(basePoint.toQPointF(), QPointF(basePoint.x()+100, basePoint.y()));
     Calculator cal(data);
     QString errorMsg;
     qreal result = cal.eval(formula, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         line.setLength(toPixel(result));
         line.setAngle(angle);
         qint64 id = _id;
-        if(typeCreation == Tool::FromGui){
+        if (typeCreation == Tool::FromGui)
+        {
             id = data->AddModelingPoint(VPointF(line.p2().x(), line.p2().y(), pointName, mx, my));
-        } else {
+        }
+        else
+        {
             data->UpdateModelingPoint(id, VPointF(line.p2().x(), line.p2().y(), pointName, mx, my));
-            if(parse != Document::FullParse){
+            if (parse != Document::FullParse)
+            {
                 doc->UpdateToolData(id, data);
             }
         }
         data->AddLine(basePointId, id, Draw::Modeling);
-        if(parse == Document::FullParse){
+        if (parse == Document::FullParse)
+        {
             point = new VModelingEndLine(doc, data, id, typeLine, formula, angle, basePointId, typeCreation);
             doc->AddTool(id, point);
             doc->IncrementReferens(basePointId);
@@ -90,9 +98,11 @@ VModelingEndLine *VModelingEndLine::Create(const qint64 _id, const QString &poin
     return point;
 }
 
-void VModelingEndLine::FullUpdateFromFile(){
+void VModelingEndLine::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         typeLine = domElement.attribute(AttrTypeLine, "");
         formula = domElement.attribute(AttrLength, "");
         basePointId = domElement.attribute(AttrBasePoint, "").toLongLong();
@@ -101,14 +111,18 @@ void VModelingEndLine::FullUpdateFromFile(){
     RefreshGeometry();
 }
 
-void VModelingEndLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VModelingEndLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogEndLine, this, event);
 }
 
-void VModelingEndLine::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VModelingEndLine::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogEndLine->getPointName());
             domElement.setAttribute(AttrTypeLine, dialogEndLine->getTypeLine());
             domElement.setAttribute(AttrLength, dialogEndLine->getFormula());
@@ -120,7 +134,8 @@ void VModelingEndLine::FullUpdateFromGui(int result){
     dialogEndLine.clear();
 }
 
-void VModelingEndLine::AddToFile(){
+void VModelingEndLine::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetModelingPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
diff --git a/tools/modelingTools/vmodelingendline.h b/tools/modelingTools/vmodelingendline.h
index edf57b266..7142d2b6c 100644
--- a/tools/modelingTools/vmodelingendline.h
+++ b/tools/modelingTools/vmodelingendline.h
@@ -25,7 +25,8 @@
 #include "vmodelinglinepoint.h"
 #include "dialogs/dialogendline.h"
 
-class VModelingEndLine : public VModelingLinePoint{
+class VModelingEndLine : public VModelingLinePoint
+{
     Q_OBJECT
 public:
                              VModelingEndLine(VDomDocument *doc, VContainer *data, const qint64 &id,
diff --git a/tools/modelingTools/vmodelingheight.cpp b/tools/modelingTools/vmodelingheight.cpp
index b71a69276..50024d09e 100644
--- a/tools/modelingTools/vmodelingheight.cpp
+++ b/tools/modelingTools/vmodelingheight.cpp
@@ -29,15 +29,18 @@ VModelingHeight::VModelingHeight(VDomDocument *doc, VContainer *data, const qint
                                  const qint64 &p2LineId, Tool::Sources typeCreation,
                                  QGraphicsItem * parent)
     :VModelingLinePoint(doc, data, id, typeLine, QString(), basePointId, 0, parent),
-      dialogHeight(QSharedPointer<DialogHeight>()), p1LineId(p1LineId), p2LineId(p2LineId){
+      dialogHeight(QSharedPointer<DialogHeight>()), p1LineId(p1LineId), p2LineId(p2LineId)
+{
     ignoreFullUpdate = true;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VModelingHeight::setDialog(){
-    Q_ASSERT(!dialogHeight.isNull());
+void VModelingHeight::setDialog()
+{
+    Q_ASSERT(dialogHeight.isNull() == false);
     VPointF p = VAbstractTool::data.GetModelingPoint(id);
     dialogHeight->setTypeLine(typeLine);
     dialogHeight->setBasePointId(basePointId, id);
@@ -46,8 +49,8 @@ void VModelingHeight::setDialog(){
     dialogHeight->setPointName(p.name());
 }
 
-VModelingHeight *VModelingHeight::Create(QSharedPointer<DialogHeight> &dialog, VDomDocument *doc,
-                                         VContainer *data){
+VModelingHeight *VModelingHeight::Create(QSharedPointer<DialogHeight> &dialog, VDomDocument *doc, VContainer *data)
+{
     disconnect(doc, &VDomDocument::FullUpdateFromFile, dialog.data(), &DialogHeight::UpdateList);
     QString pointName = dialog->getPointName();
     QString typeLine = dialog->getTypeLine();
@@ -62,7 +65,8 @@ VModelingHeight *VModelingHeight::Create(const qint64 _id, const QString &pointN
                                          const qint64 &basePointId, const qint64 &p1LineId,
                                          const qint64 &p2LineId, const qreal &mx, const qreal &my,
                                          VDomDocument *doc, VContainer *data,
-                                         const Document::Documents &parse, Tool::Sources typeCreation){
+                                         const Document::Documents &parse, Tool::Sources typeCreation)
+{
     VModelingHeight *point = 0;
     VPointF basePoint = data->GetModelingPoint(basePointId);
     VPointF p1Line = data->GetModelingPoint(p1LineId);
@@ -72,16 +76,21 @@ VModelingHeight *VModelingHeight::Create(const qint64 _id, const QString &pointN
                                              basePoint.toQPointF());
     QLineF line = QLineF(basePoint.toQPointF(), pHeight);
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->AddModelingPoint(VPointF(line.p2().x(), line.p2().y(), pointName, mx, my));
-    } else {
+    }
+    else
+    {
         data->UpdateModelingPoint(id, VPointF(line.p2().x(), line.p2().y(), pointName, mx, my));
-        if(parse != Document::FullParse){
+        if (parse != Document::FullParse)
+        {
             doc->UpdateToolData(id, data);
         }
     }
     data->AddLine(basePointId, id, Draw::Modeling);
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         point = new VModelingHeight(doc, data, id, typeLine, basePointId, p1LineId, p2LineId, typeCreation);
         doc->AddTool(id, point);
         doc->IncrementReferens(basePointId);
@@ -91,9 +100,11 @@ VModelingHeight *VModelingHeight::Create(const qint64 _id, const QString &pointN
     return point;
 }
 
-void VModelingHeight::FullUpdateFromFile(){
+void VModelingHeight::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         typeLine = domElement.attribute(AttrTypeLine, "");
         basePointId = domElement.attribute(AttrBasePoint, "").toLongLong();
         p1LineId = domElement.attribute(AttrP1Line, "").toLongLong();
@@ -102,10 +113,13 @@ void VModelingHeight::FullUpdateFromFile(){
     RefreshGeometry();
 }
 
-void VModelingHeight::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VModelingHeight::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogHeight->getPointName());
             domElement.setAttribute(AttrTypeLine, dialogHeight->getTypeLine());
             domElement.setAttribute(AttrBasePoint, QString().setNum(dialogHeight->getBasePointId()));
@@ -117,11 +131,13 @@ void VModelingHeight::FullUpdateFromGui(int result){
     dialogHeight.clear();
 }
 
-void VModelingHeight::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VModelingHeight::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogHeight, this, event);
 }
 
-void VModelingHeight::AddToFile(){
+void VModelingHeight::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetModelingPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
diff --git a/tools/modelingTools/vmodelingheight.h b/tools/modelingTools/vmodelingheight.h
index 7ad09f6e3..073b7bfae 100644
--- a/tools/modelingTools/vmodelingheight.h
+++ b/tools/modelingTools/vmodelingheight.h
@@ -25,7 +25,8 @@
 #include "vmodelinglinepoint.h"
 #include "dialogs/dialogheight.h"
 
-class VModelingHeight : public VModelingLinePoint{
+class VModelingHeight : public VModelingLinePoint
+{
     Q_OBJECT
 public:
                             VModelingHeight(VDomDocument *doc, VContainer *data, const qint64 &id,
diff --git a/tools/modelingTools/vmodelingline.cpp b/tools/modelingTools/vmodelingline.cpp
index 6acd7cdd7..7f077bca1 100644
--- a/tools/modelingTools/vmodelingline.cpp
+++ b/tools/modelingTools/vmodelingline.cpp
@@ -26,7 +26,8 @@ const QString VModelingLine::TagName = QStringLiteral("line");
 VModelingLine::VModelingLine(VDomDocument *doc, VContainer *data, qint64 id, qint64 firstPoint,
                              qint64 secondPoint, Tool::Sources typeCreation, QGraphicsItem *parent):
     VModelingTool(doc, data, id), QGraphicsLineItem(parent), firstPoint(firstPoint),
-    secondPoint(secondPoint), dialogLine(QSharedPointer<DialogLine>()){
+    secondPoint(secondPoint), dialogLine(QSharedPointer<DialogLine>())
+{
     ignoreFullUpdate = true;
     //Лінія
     VPointF first = data->GetModelingPoint(firstPoint);
@@ -36,18 +37,20 @@ VModelingLine::VModelingLine(VDomDocument *doc, VContainer *data, qint64 id, qin
     this->setFlag(QGraphicsItem::ItemIsSelectable, true);
     this->setAcceptHoverEvents(true);
 
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VModelingLine::setDialog(){
+void VModelingLine::setDialog()
+{
     dialogLine->setFirstPoint(firstPoint);
     dialogLine->setSecondPoint(secondPoint);
 }
 
-VModelingLine *VModelingLine::Create(QSharedPointer<DialogLine> &dialog, VDomDocument *doc,
-                                     VContainer *data){
+VModelingLine *VModelingLine::Create(QSharedPointer<DialogLine> &dialog, VDomDocument *doc, VContainer *data)
+{
     qint64 firstPoint = dialog->getFirstPoint();
     qint64 secondPoint = dialog->getSecondPoint();
     return Create(0, firstPoint, secondPoint, doc, data, Document::FullParse, Tool::FromGui);
@@ -55,21 +58,27 @@ VModelingLine *VModelingLine::Create(QSharedPointer<DialogLine> &dialog, VDomDoc
 
 VModelingLine *VModelingLine::Create(const qint64 &_id, const qint64 &firstPoint, const qint64 &secondPoint,
                                      VDomDocument *doc, VContainer *data, const Document::Documents &parse,
-                                     Tool::Sources typeCreation){
+                                     Tool::Sources typeCreation)
+{
     VModelingLine *line = 0;
     Q_ASSERT(doc != 0);
     Q_ASSERT(data != 0);
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->getNextId();
-    } else {
-        if(parse != Document::FullParse){
+    }
+    else
+    {
+        if (parse != Document::FullParse)
+        {
             data->UpdateId(id);
             doc->UpdateToolData(id, data);
         }
     }
     data->AddLine(firstPoint, secondPoint, Draw::Modeling);
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         line = new VModelingLine(doc, data, id, firstPoint, secondPoint, typeCreation);
         doc->AddTool(id, line);
         doc->IncrementReferens(firstPoint);
@@ -78,9 +87,11 @@ VModelingLine *VModelingLine::Create(const qint64 &_id, const qint64 &firstPoint
     return line;
 }
 
-void VModelingLine::FullUpdateFromFile(){
+void VModelingLine::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         firstPoint = domElement.attribute(AttrFirstPoint, "").toLongLong();
         secondPoint = domElement.attribute(AttrSecondPoint, "").toLongLong();
     }
@@ -89,10 +100,13 @@ void VModelingLine::FullUpdateFromFile(){
     this->setLine(QLineF(first.toQPointF(), second.toQPointF()));
 }
 
-void VModelingLine::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VModelingLine::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrFirstPoint, QString().setNum(dialogLine->getFirstPoint()));
             domElement.setAttribute(AttrSecondPoint, QString().setNum(dialogLine->getSecondPoint()));
             emit FullUpdateTree();
@@ -101,11 +115,13 @@ void VModelingLine::FullUpdateFromGui(int result){
     dialogLine.clear();
 }
 
-void VModelingLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VModelingLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogLine, this, event);
 }
 
-void VModelingLine::AddToFile(){
+void VModelingLine::AddToFile()
+{
     QDomElement domElement = doc->createElement(TagName);
     AddAttribute(domElement, AttrId, id);
     AddAttribute(domElement, AttrFirstPoint, firstPoint);
@@ -114,17 +130,20 @@ void VModelingLine::AddToFile(){
     AddToModeling(domElement);
 }
 
-void VModelingLine::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VModelingLine::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthMainLine));
 }
 
-void VModelingLine::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VModelingLine::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthHairLine));
 }
 
-void VModelingLine::RemoveReferens(){
+void VModelingLine::RemoveReferens()
+{
     doc->DecrementReferens(firstPoint);
     doc->DecrementReferens(secondPoint);
 }
diff --git a/tools/modelingTools/vmodelingline.h b/tools/modelingTools/vmodelingline.h
index 8bee26207..f91380eaa 100644
--- a/tools/modelingTools/vmodelingline.h
+++ b/tools/modelingTools/vmodelingline.h
@@ -26,7 +26,8 @@
 #include "QGraphicsLineItem"
 #include "dialogs/dialogline.h"
 
-class VModelingLine: public VModelingTool, public QGraphicsLineItem{
+class VModelingLine: public VModelingTool, public QGraphicsLineItem
+{
     Q_OBJECT
 public:
                           VModelingLine(VDomDocument *doc, VContainer *data, qint64 id, qint64 firstPoint,
diff --git a/tools/modelingTools/vmodelinglineintersect.cpp b/tools/modelingTools/vmodelinglineintersect.cpp
index af78014b6..f73afb5be 100644
--- a/tools/modelingTools/vmodelinglineintersect.cpp
+++ b/tools/modelingTools/vmodelinglineintersect.cpp
@@ -25,29 +25,31 @@ const QString VModelingLineIntersect::ToolType = QStringLiteral("lineIntersect")
 
 VModelingLineIntersect::VModelingLineIntersect(VDomDocument *doc, VContainer *data, const qint64 &id,
                                        const qint64 &p1Line1, const qint64 &p2Line1, const qint64 &p1Line2,
-                                       const qint64 &p2Line2, Tool::Sources typeCreation, QGraphicsItem *parent):
-    VModelingPoint(doc, data, id, parent), p1Line1(p1Line1), p2Line1(p2Line1), p1Line2(p1Line2),
-    p2Line2(p2Line2), dialogLineIntersect(QSharedPointer<DialogLineIntersect>()){
+                                       const qint64 &p2Line2, Tool::Sources typeCreation, QGraphicsItem *parent)
+    :VModelingPoint(doc, data, id, parent), p1Line1(p1Line1), p2Line1(p2Line1), p1Line2(p1Line2),
+    p2Line2(p2Line2), dialogLineIntersect(QSharedPointer<DialogLineIntersect>())
+{
     ignoreFullUpdate = true;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VModelingLineIntersect::setDialog(){
-    Q_ASSERT(!dialogLineIntersect.isNull());
-    if(!dialogLineIntersect.isNull()){
-        VPointF p = VAbstractTool::data.GetModelingPoint(id);
-        dialogLineIntersect->setP1Line1(p1Line1);
-        dialogLineIntersect->setP2Line1(p2Line1);
-        dialogLineIntersect->setP1Line2(p1Line2);
-        dialogLineIntersect->setP2Line2(p2Line2);
-        dialogLineIntersect->setPointName(p.name());
-    }
+void VModelingLineIntersect::setDialog()
+{
+    Q_ASSERT(dialogLineIntersect.isNull() == false);
+    VPointF p = VAbstractTool::data.GetModelingPoint(id);
+    dialogLineIntersect->setP1Line1(p1Line1);
+    dialogLineIntersect->setP2Line1(p2Line1);
+    dialogLineIntersect->setP1Line2(p1Line2);
+    dialogLineIntersect->setP2Line2(p2Line2);
+    dialogLineIntersect->setPointName(p.name());
 }
 
 VModelingLineIntersect *VModelingLineIntersect::Create(QSharedPointer<DialogLineIntersect> &dialog,
-                                                       VDomDocument *doc, VContainer *data){
+                                                       VDomDocument *doc, VContainer *data)
+{
     qint64 p1Line1Id = dialog->getP1Line1();
     qint64 p2Line1Id = dialog->getP2Line1();
     qint64 p1Line2Id = dialog->getP1Line2();
@@ -62,7 +64,8 @@ VModelingLineIntersect *VModelingLineIntersect::Create(const qint64 _id, const q
                                                        const qint64 &p2Line2Id, const QString &pointName,
                                                        const qreal &mx, const qreal &my, VDomDocument *doc,
                                                        VContainer *data, const Document::Documents &parse,
-                                                       Tool::Sources typeCreation){
+                                                       Tool::Sources typeCreation)
+{
     VModelingLineIntersect *point = 0;
     VPointF p1Line1 = data->GetModelingPoint(p1Line1Id);
     VPointF p2Line1 = data->GetModelingPoint(p2Line1Id);
@@ -73,13 +76,18 @@ VModelingLineIntersect *VModelingLineIntersect::Create(const qint64 _id, const q
     QLineF line2(p1Line2.toQPointF(), p2Line2.toQPointF());
     QPointF fPoint;
     QLineF::IntersectType intersect = line1.intersect(line2, &fPoint);
-    if(intersect == QLineF::UnboundedIntersection || intersect == QLineF::BoundedIntersection){
+    if (intersect == QLineF::UnboundedIntersection || intersect == QLineF::BoundedIntersection)
+    {
         qint64 id = _id;
-        if(typeCreation == Tool::FromGui){
+        if (typeCreation == Tool::FromGui)
+        {
             id = data->AddModelingPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
-        } else {
+        }
+        else
+        {
             data->UpdateModelingPoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
-            if(parse != Document::FullParse){
+            if (parse != Document::FullParse)
+            {
                 doc->UpdateToolData(id, data);
             }
         }
@@ -87,7 +95,8 @@ VModelingLineIntersect *VModelingLineIntersect::Create(const qint64 _id, const q
         data->AddLine(id, p2Line1Id, Draw::Modeling);
         data->AddLine(p1Line2Id, id, Draw::Modeling);
         data->AddLine(id, p2Line2Id, Draw::Modeling);
-        if(parse == Document::FullParse){
+        if (parse == Document::FullParse)
+        {
             point = new VModelingLineIntersect(doc, data, id, p1Line1Id, p2Line1Id, p1Line2Id, p2Line2Id,
                                                typeCreation);
             doc->AddTool(id, point);
@@ -100,9 +109,11 @@ VModelingLineIntersect *VModelingLineIntersect::Create(const qint64 _id, const q
     return point;
 }
 
-void VModelingLineIntersect::FullUpdateFromFile(){
+void VModelingLineIntersect::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         p1Line1 = domElement.attribute(AttrP1Line1, "").toLongLong();
         p2Line1 = domElement.attribute(AttrP2Line1, "").toLongLong();
         p1Line2 = domElement.attribute(AttrP1Line2, "").toLongLong();
@@ -111,10 +122,13 @@ void VModelingLineIntersect::FullUpdateFromFile(){
     RefreshPointGeometry(VAbstractTool::data.GetModelingPoint(id));
 }
 
-void VModelingLineIntersect::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VModelingLineIntersect::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogLineIntersect->getPointName());
             domElement.setAttribute(AttrP1Line1, QString().setNum(dialogLineIntersect->getP1Line1()));
             domElement.setAttribute(AttrP2Line1, QString().setNum(dialogLineIntersect->getP2Line1()));
@@ -126,11 +140,13 @@ void VModelingLineIntersect::FullUpdateFromGui(int result){
     dialogLineIntersect.clear();
 }
 
-void VModelingLineIntersect::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VModelingLineIntersect::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogLineIntersect, this, event);
 }
 
-void VModelingLineIntersect::AddToFile(){
+void VModelingLineIntersect::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetModelingPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -148,7 +164,8 @@ void VModelingLineIntersect::AddToFile(){
     AddToModeling(domElement);
 }
 
-void VModelingLineIntersect::RemoveReferens(){
+void VModelingLineIntersect::RemoveReferens()
+{
     doc->DecrementReferens(p1Line1);
     doc->DecrementReferens(p2Line1);
     doc->DecrementReferens(p1Line2);
diff --git a/tools/modelingTools/vmodelinglineintersect.h b/tools/modelingTools/vmodelinglineintersect.h
index 7051104d1..f6b1cc3e0 100644
--- a/tools/modelingTools/vmodelinglineintersect.h
+++ b/tools/modelingTools/vmodelinglineintersect.h
@@ -25,7 +25,8 @@
 #include "vmodelingpoint.h"
 #include "dialogs/dialoglineintersect.h"
 
-class VModelingLineIntersect:public VModelingPoint{
+class VModelingLineIntersect:public VModelingPoint
+{
     Q_OBJECT
 public:
                                    VModelingLineIntersect(VDomDocument *doc, VContainer *data, const qint64 &id,
diff --git a/tools/modelingTools/vmodelinglinepoint.cpp b/tools/modelingTools/vmodelinglinepoint.cpp
index e8c05adb2..55802477a 100644
--- a/tools/modelingTools/vmodelinglinepoint.cpp
+++ b/tools/modelingTools/vmodelinglinepoint.cpp
@@ -23,30 +23,38 @@
 
 VModelingLinePoint::VModelingLinePoint(VDomDocument *doc, VContainer *data, const qint64 &id,
                                const QString &typeLine, const QString &formula, const qint64 &basePointId,
-                               const qreal &angle, QGraphicsItem *parent):
-    VModelingPoint(doc, data, id, parent), typeLine(typeLine), formula(formula), angle(angle),
-    basePointId(basePointId), mainLine(0){
+                               const qreal &angle, QGraphicsItem *parent)
+    :VModelingPoint(doc, data, id, parent), typeLine(typeLine), formula(formula), angle(angle),
+    basePointId(basePointId), mainLine(0)
+{
     //Лінія, що з'єднує дві точки
     QPointF point1 = data->GetModelingPoint(basePointId).toQPointF();
     QPointF point2 = data->GetModelingPoint(id).toQPointF();
     mainLine = new QGraphicsLineItem(QLineF(point1 - point2, QPointF()), this);
     mainLine->setPen(QPen(Qt::black, widthHairLine));
     mainLine->setFlag(QGraphicsItem::ItemStacksBehindParent, true);
-    if(typeLine == TypeLineNone){
+    if (typeLine == TypeLineNone)
+    {
         mainLine->setVisible(false);
-    } else {
+    }
+    else
+    {
         mainLine->setVisible(true);
     }
 }
 
-void VModelingLinePoint::RefreshGeometry(){
+void VModelingLinePoint::RefreshGeometry()
+{
     VModelingPoint::RefreshPointGeometry(VModelingTool::data.GetModelingPoint(id));
     QPointF point = VModelingTool::data.GetModelingPoint(id).toQPointF();
     QPointF basePoint = VModelingTool::data.GetModelingPoint(basePointId).toQPointF();
     mainLine->setLine(QLineF(basePoint - point, QPointF()));
-    if(typeLine == TypeLineNone){
+    if (typeLine == TypeLineNone)
+    {
         mainLine->setVisible(false);
-    } else {
+    }
+    else
+    {
         mainLine->setVisible(true);
     }
 }
diff --git a/tools/modelingTools/vmodelinglinepoint.h b/tools/modelingTools/vmodelinglinepoint.h
index 2fc252b99..be3afec2e 100644
--- a/tools/modelingTools/vmodelinglinepoint.h
+++ b/tools/modelingTools/vmodelinglinepoint.h
@@ -24,7 +24,8 @@
 
 #include "vmodelingpoint.h"
 
-class VModelingLinePoint : public VModelingPoint{
+class VModelingLinePoint : public VModelingPoint
+{
     Q_OBJECT
 public:
                       VModelingLinePoint(VDomDocument *doc, VContainer *data, const qint64 &id, const QString &typeLine,
diff --git a/tools/modelingTools/vmodelingnormal.cpp b/tools/modelingTools/vmodelingnormal.cpp
index c9a9c2cad..57e0da070 100644
--- a/tools/modelingTools/vmodelingnormal.cpp
+++ b/tools/modelingTools/vmodelingnormal.cpp
@@ -25,33 +25,32 @@
 
 const QString VModelingNormal::ToolType = QStringLiteral("normal");
 
-VModelingNormal::VModelingNormal(VDomDocument *doc, VContainer *data, const qint64 &id,
-                         const QString &typeLine,
+VModelingNormal::VModelingNormal(VDomDocument *doc, VContainer *data, const qint64 &id, const QString &typeLine,
                          const QString &formula, const qreal &angle, const qint64 &firstPointId,
-                         const qint64 &secondPointId, Tool::Sources typeCreation, QGraphicsItem *parent):
-    VModelingLinePoint(doc, data, id, typeLine, formula, firstPointId, angle, parent),
-    secondPointId(secondPointId), dialogNormal(QSharedPointer<DialogNormal>()){
-
-    if(typeCreation == Tool::FromGui){
+                         const qint64 &secondPointId, Tool::Sources typeCreation, QGraphicsItem *parent)
+    :VModelingLinePoint(doc, data, id, typeLine, formula, firstPointId, angle, parent),
+    secondPointId(secondPointId), dialogNormal(QSharedPointer<DialogNormal>())
+{
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VModelingNormal::setDialog(){
-    Q_ASSERT(!dialogNormal.isNull());
-    if(!dialogNormal.isNull()){
-        VPointF p = VAbstractTool::data.GetModelingPoint(id);
-        dialogNormal->setTypeLine(typeLine);
-        dialogNormal->setFormula(formula);
-        dialogNormal->setAngle(angle);
-        dialogNormal->setFirstPointId(basePointId, id);
-        dialogNormal->setSecondPointId(secondPointId, id);
-        dialogNormal->setPointName(p.name());
-    }
+void VModelingNormal::setDialog()
+{
+    Q_ASSERT(dialogNormal.isNull() == false);
+    VPointF p = VAbstractTool::data.GetModelingPoint(id);
+    dialogNormal->setTypeLine(typeLine);
+    dialogNormal->setFormula(formula);
+    dialogNormal->setAngle(angle);
+    dialogNormal->setFirstPointId(basePointId, id);
+    dialogNormal->setSecondPointId(secondPointId, id);
+    dialogNormal->setPointName(p.name());
 }
 
-VModelingNormal* VModelingNormal::Create(QSharedPointer<DialogNormal> &dialog, VDomDocument *doc,
-                                         VContainer *data){
+VModelingNormal* VModelingNormal::Create(QSharedPointer<DialogNormal> &dialog, VDomDocument *doc, VContainer *data)
+{
     QString formula = dialog->getFormula();
     qint64 firstPointId = dialog->getFirstPointId();
     qint64 secondPointId = dialog->getSecondPointId();
@@ -62,32 +61,37 @@ VModelingNormal* VModelingNormal::Create(QSharedPointer<DialogNormal> &dialog, V
                   Document::FullParse, Tool::FromGui);
 }
 
-VModelingNormal *VModelingNormal::Create(const qint64 _id, const QString &formula,
-                                         const qint64 &firstPointId, const qint64 &secondPointId,
-                                         const QString typeLine, const QString pointName,
-                                         const qreal angle, const qreal &mx, const qreal &my,
-                                         VDomDocument *doc, VContainer *data, const Document::Documents &parse,
-                                         Tool::Sources typeCreation){
+VModelingNormal *VModelingNormal::Create(const qint64 _id, const QString &formula, const qint64 &firstPointId,
+                                         const qint64 &secondPointId, const QString typeLine, const QString pointName,
+                                         const qreal angle, const qreal &mx, const qreal &my, VDomDocument *doc,
+                                         VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation)
+{
     VModelingNormal *point = 0;
     VPointF firstPoint = data->GetModelingPoint(firstPointId);
     VPointF secondPoint = data->GetModelingPoint(secondPointId);
     Calculator cal(data);
     QString errorMsg;
     qreal result = cal.eval(formula, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         QPointF fPoint = VToolNormal::FindPoint(firstPoint.toQPointF(), secondPoint.toQPointF(),
                                                 toPixel(result), angle);
         qint64 id = _id;
-        if(typeCreation == Tool::FromGui){
+        if (typeCreation == Tool::FromGui)
+        {
             id = data->AddModelingPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
-        } else {
+        }
+        else
+        {
             data->UpdateModelingPoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
-            if(parse != Document::FullParse){
+            if (parse != Document::FullParse)
+            {
                 doc->UpdateToolData(id, data);
             }
         }
         data->AddLine(firstPointId, id, Draw::Modeling);
-        if(parse == Document::FullParse){
+        if (parse == Document::FullParse)
+        {
             point = new VModelingNormal(doc, data, id, typeLine, formula, angle, firstPointId, secondPointId,
                                         typeCreation);
             doc->AddTool(id, point);
@@ -98,9 +102,11 @@ VModelingNormal *VModelingNormal::Create(const qint64 _id, const QString &formul
     return point;
 }
 
-void VModelingNormal::FullUpdateFromFile(){
+void VModelingNormal::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         typeLine = domElement.attribute(AttrTypeLine, "");
         formula = domElement.attribute(AttrLength, "");
         basePointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
@@ -110,10 +116,13 @@ void VModelingNormal::FullUpdateFromFile(){
     RefreshGeometry();
 }
 
-void VModelingNormal::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VModelingNormal::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogNormal->getPointName());
             domElement.setAttribute(AttrTypeLine, dialogNormal->getTypeLine());
             domElement.setAttribute(AttrLength, dialogNormal->getFormula());
@@ -126,11 +135,13 @@ void VModelingNormal::FullUpdateFromGui(int result){
     dialogNormal.clear();
 }
 
-void VModelingNormal::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VModelingNormal::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogNormal, this, event);
 }
 
-void VModelingNormal::AddToFile(){
+void VModelingNormal::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetModelingPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -149,7 +160,8 @@ void VModelingNormal::AddToFile(){
     AddToModeling(domElement);
 }
 
-void VModelingNormal::RemoveReferens(){
+void VModelingNormal::RemoveReferens()
+{
     doc->DecrementReferens(secondPointId);
     VModelingLinePoint::RemoveReferens();
 }
diff --git a/tools/modelingTools/vmodelingnormal.h b/tools/modelingTools/vmodelingnormal.h
index c1ef9c146..91dcaef62 100644
--- a/tools/modelingTools/vmodelingnormal.h
+++ b/tools/modelingTools/vmodelingnormal.h
@@ -25,7 +25,8 @@
 #include "vmodelinglinepoint.h"
 #include "dialogs/dialognormal.h"
 
-class VModelingNormal : public VModelingLinePoint{
+class VModelingNormal : public VModelingLinePoint
+{
     Q_OBJECT
 public:
                             VModelingNormal(VDomDocument *doc, VContainer *data, const qint64 &id,
diff --git a/tools/modelingTools/vmodelingpoint.cpp b/tools/modelingTools/vmodelingpoint.cpp
index 4bb1741fa..50bb89a03 100644
--- a/tools/modelingTools/vmodelingpoint.cpp
+++ b/tools/modelingTools/vmodelingpoint.cpp
@@ -24,9 +24,9 @@
 
 const QString VModelingPoint::TagName = QStringLiteral("point");
 
-VModelingPoint::VModelingPoint(VDomDocument *doc, VContainer *data, qint64 id,
-                       QGraphicsItem *parent):VModelingTool(doc, data, id),
-    QGraphicsEllipseItem(parent), radius(toPixel(1.5)), namePoint(0), lineName(0){
+VModelingPoint::VModelingPoint(VDomDocument *doc, VContainer *data, qint64 id, QGraphicsItem *parent)
+    :VModelingTool(doc, data, id), QGraphicsEllipseItem(parent), radius(toPixel(1.5)), namePoint(0), lineName(0)
+{
     namePoint = new VGraphicsSimpleTextItem(this);
     lineName = new QGraphicsLineItem(this);
     connect(namePoint, &VGraphicsSimpleTextItem::NameChangePosition, this,
@@ -38,7 +38,8 @@ VModelingPoint::VModelingPoint(VDomDocument *doc, VContainer *data, qint64 id,
     RefreshPointGeometry(VAbstractTool::data.GetModelingPoint(id));
 }
 
-void VModelingPoint::NameChangePosition(const QPointF pos){
+void VModelingPoint::NameChangePosition(const QPointF pos)
+{
     VPointF point = VAbstractTool::data.GetModelingPoint(id);
     QPointF p = pos - this->pos();
     point.setMx(p.x());
@@ -48,33 +49,40 @@ void VModelingPoint::NameChangePosition(const QPointF pos){
     VAbstractTool::data.UpdatePoint(id, point);
 }
 
-void VModelingPoint::UpdateNamePosition(qreal mx, qreal my){
+void VModelingPoint::UpdateNamePosition(qreal mx, qreal my)
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         domElement.setAttribute(AttrMx, QString().setNum(toMM(mx)));
         domElement.setAttribute(AttrMy, QString().setNum(toMM(my)));
         emit toolhaveChange();
     }
 }
 
-void VModelingPoint::mouseReleaseEvent(QGraphicsSceneMouseEvent *event){
-    if(event->button() == Qt::LeftButton){
+void VModelingPoint::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
         emit ChoosedTool(id, Scene::Point);
     }
     QGraphicsItem::mouseReleaseEvent(event);
 }
 
-void VModelingPoint::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VModelingPoint::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthMainLine));
 }
 
-void VModelingPoint::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VModelingPoint::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthHairLine));
 }
 
-void VModelingPoint::RefreshPointGeometry(const VPointF &point){
+void VModelingPoint::RefreshPointGeometry(const VPointF &point)
+{
     QRectF rec = QRectF(0, 0, radius*2, radius*2);
     rec.translate(-rec.center().x(), -rec.center().y());
     this->setRect(rec);
@@ -88,15 +96,19 @@ void VModelingPoint::RefreshPointGeometry(const VPointF &point){
     RefreshLine();
 }
 
-void VModelingPoint::RefreshLine(){
+void VModelingPoint::RefreshLine()
+{
     QRectF nameRec = namePoint->sceneBoundingRect();
     QPointF p1, p2;
     LineIntersectCircle(QPointF(), radius, QLineF(QPointF(), nameRec.center()- scenePos()), p1, p2);
     QPointF pRec = LineIntersectRect(nameRec, QLineF(scenePos(), nameRec.center()));
     lineName->setLine(QLineF(p1, pRec - scenePos()));
-    if(QLineF(p1, pRec - scenePos()).length() <= toPixel(4)){
+    if (QLineF(p1, pRec - scenePos()).length() <= toPixel(4))
+    {
         lineName->setVisible(false);
-    } else {
+    }
+    else
+    {
         lineName->setVisible(true);
     }
 }
diff --git a/tools/modelingTools/vmodelingpoint.h b/tools/modelingTools/vmodelingpoint.h
index 03a8abe6c..ff5558185 100644
--- a/tools/modelingTools/vmodelingpoint.h
+++ b/tools/modelingTools/vmodelingpoint.h
@@ -25,7 +25,8 @@
 #include "vmodelingtool.h"
 #include "widgets/vgraphicssimpletextitem.h"
 
-class VModelingPoint: public VModelingTool, public QGraphicsEllipseItem{
+class VModelingPoint: public VModelingTool, public QGraphicsEllipseItem
+{
     Q_OBJECT
 public:
                             VModelingPoint(VDomDocument *doc, VContainer *data, qint64 id, QGraphicsItem * parent = 0);
diff --git a/tools/modelingTools/vmodelingpointofcontact.cpp b/tools/modelingTools/vmodelingpointofcontact.cpp
index 11e9bd5ac..f87a094ad 100644
--- a/tools/modelingTools/vmodelingpointofcontact.cpp
+++ b/tools/modelingTools/vmodelingpointofcontact.cpp
@@ -26,31 +26,32 @@
 const QString VModelingPointOfContact::ToolType = QStringLiteral("pointOfContact");
 
 VModelingPointOfContact::VModelingPointOfContact(VDomDocument *doc, VContainer *data, const qint64 &id,
-                                         const QString &radius, const qint64 &center,
-                                         const qint64 &firstPointId, const qint64 &secondPointId,
-                                         Tool::Sources typeCreation, QGraphicsItem *parent)
+                                                 const QString &radius, const qint64 &center,
+                                                 const qint64 &firstPointId, const qint64 &secondPointId,
+                                                 Tool::Sources typeCreation, QGraphicsItem *parent)
     : VModelingPoint(doc, data, id, parent), radius(radius), center(center), firstPointId(firstPointId),
-      secondPointId(secondPointId), dialogPointOfContact(QSharedPointer<DialogPointOfContact>()){
-
-    if(typeCreation == Tool::FromGui){
+      secondPointId(secondPointId), dialogPointOfContact(QSharedPointer<DialogPointOfContact>())
+{
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VModelingPointOfContact::setDialog(){
-    Q_ASSERT(!dialogPointOfContact.isNull());
-    if(!dialogPointOfContact.isNull()){
-        VPointF p = VAbstractTool::data.GetModelingPoint(id);
-        dialogPointOfContact->setRadius(radius);
-        dialogPointOfContact->setCenter(center, id);
-        dialogPointOfContact->setFirstPoint(firstPointId, id);
-        dialogPointOfContact->setSecondPoint(secondPointId, id);
-        dialogPointOfContact->setPointName(p.name());
-    }
+void VModelingPointOfContact::setDialog()
+{
+    Q_ASSERT(dialogPointOfContact.isNull() == false);
+    VPointF p = VAbstractTool::data.GetModelingPoint(id);
+    dialogPointOfContact->setRadius(radius);
+    dialogPointOfContact->setCenter(center, id);
+    dialogPointOfContact->setFirstPoint(firstPointId, id);
+    dialogPointOfContact->setSecondPoint(secondPointId, id);
+    dialogPointOfContact->setPointName(p.name());
 }
 
 VModelingPointOfContact *VModelingPointOfContact::Create(QSharedPointer<DialogPointOfContact> &dialog,
-                                                         VDomDocument *doc, VContainer *data){
+                                                         VDomDocument *doc, VContainer *data)
+{
     QString radius = dialog->getRadius();
     qint64 center = dialog->getCenter();
     qint64 firstPointId = dialog->getFirstPoint();
@@ -66,7 +67,8 @@ VModelingPointOfContact *VModelingPointOfContact::Create(const qint64 _id, const
                                                          const QString &pointName, const qreal &mx,
                                                          const qreal &my, VDomDocument *doc,
                                                          VContainer *data, const Document::Documents &parse,
-                                                         Tool::Sources typeCreation){
+                                                         Tool::Sources typeCreation)
+{
     VModelingPointOfContact *point = 0;
     VPointF centerP = data->GetModelingPoint(center);
     VPointF firstP = data->GetModelingPoint(firstPointId);
@@ -75,19 +77,25 @@ VModelingPointOfContact *VModelingPointOfContact::Create(const qint64 _id, const
     Calculator cal(data);
     QString errorMsg;
     qreal result = cal.eval(radius, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         QPointF fPoint = VToolPointOfContact::FindPoint(toPixel(result), centerP.toQPointF(),
                                                         firstP.toQPointF(), secondP.toQPointF());
         qint64 id =  _id;
-        if(typeCreation == Tool::FromGui){
+        if (typeCreation == Tool::FromGui)
+        {
             id = data->AddModelingPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
-        } else {
+        }
+        else
+        {
             data->UpdateModelingPoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
-            if(parse != Document::FullParse){
+            if (parse != Document::FullParse)
+            {
                 doc->UpdateToolData(id, data);
             }
         }
-        if(parse == Document::FullParse){
+        if (parse == Document::FullParse)
+        {
             point = new VModelingPointOfContact(doc, data, id, radius, center, firstPointId, secondPointId,
                                                 typeCreation);
             doc->AddTool(id, point);
@@ -99,9 +107,11 @@ VModelingPointOfContact *VModelingPointOfContact::Create(const qint64 _id, const
     return point;
 }
 
-void VModelingPointOfContact::FullUpdateFromFile(){
+void VModelingPointOfContact::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         radius = domElement.attribute(AttrRadius, "");
         center = domElement.attribute(AttrCenter, "").toLongLong();
         firstPointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
@@ -110,10 +120,13 @@ void VModelingPointOfContact::FullUpdateFromFile(){
     RefreshPointGeometry(VAbstractTool::data.GetModelingPoint(id));
 }
 
-void VModelingPointOfContact::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VModelingPointOfContact::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogPointOfContact->getPointName());
             domElement.setAttribute(AttrRadius, dialogPointOfContact->getRadius());
             domElement.setAttribute(AttrCenter, QString().setNum(dialogPointOfContact->getCenter()));
@@ -125,11 +138,13 @@ void VModelingPointOfContact::FullUpdateFromGui(int result){
     dialogPointOfContact.clear();
 }
 
-void VModelingPointOfContact::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VModelingPointOfContact::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogPointOfContact, this, event);
 }
 
-void VModelingPointOfContact::AddToFile(){
+void VModelingPointOfContact::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetModelingPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -147,7 +162,8 @@ void VModelingPointOfContact::AddToFile(){
     AddToModeling(domElement);
 }
 
-void VModelingPointOfContact::RemoveReferens(){
+void VModelingPointOfContact::RemoveReferens()
+{
     doc->DecrementReferens(center);
     doc->DecrementReferens(firstPointId);
     doc->DecrementReferens(secondPointId);
diff --git a/tools/modelingTools/vmodelingpointofcontact.h b/tools/modelingTools/vmodelingpointofcontact.h
index 6eebac9ec..64418b636 100644
--- a/tools/modelingTools/vmodelingpointofcontact.h
+++ b/tools/modelingTools/vmodelingpointofcontact.h
@@ -25,7 +25,8 @@
 #include "vmodelingpoint.h"
 #include "dialogs/dialogpointofcontact.h"
 
-class VModelingPointOfContact : public VModelingPoint{
+class VModelingPointOfContact : public VModelingPoint
+{
     Q_OBJECT
 public:
                                     VModelingPointOfContact(VDomDocument *doc, VContainer *data, const qint64 &id,
diff --git a/tools/modelingTools/vmodelingpointofintersection.cpp b/tools/modelingTools/vmodelingpointofintersection.cpp
index e22e97c7b..15fb326fa 100644
--- a/tools/modelingTools/vmodelingpointofintersection.cpp
+++ b/tools/modelingTools/vmodelingpointofintersection.cpp
@@ -6,15 +6,18 @@ VModelingPointOfIntersection::VModelingPointOfIntersection(VDomDocument *doc, VC
                                                            const qint64 &firstPointId, const qint64 &secondPointId,
                                                            Tool::Sources typeCreation, QGraphicsItem *parent)
     :VModelingPoint(doc, data, id, parent), firstPointId(firstPointId), secondPointId(secondPointId),
-    dialogPointOfIntersection(QSharedPointer<DialogPointOfIntersection>()) {
+    dialogPointOfIntersection(QSharedPointer<DialogPointOfIntersection>())
+{
     ignoreFullUpdate = true;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VModelingPointOfIntersection::setDialog(){
-    Q_ASSERT(!dialogPointOfIntersection.isNull());
+void VModelingPointOfIntersection::setDialog()
+{
+    Q_ASSERT(dialogPointOfIntersection.isNull() == false);
     VPointF p = VAbstractTool::data.GetPoint(id);
     dialogPointOfIntersection->setFirstPointId(firstPointId, id);
     dialogPointOfIntersection->setSecondPointId(secondPointId, id);
@@ -22,7 +25,8 @@ void VModelingPointOfIntersection::setDialog(){
 }
 
 VModelingPointOfIntersection *VModelingPointOfIntersection::Create(QSharedPointer<DialogPointOfIntersection> &dialog,
-                                                                   VDomDocument *doc, VContainer *data){
+                                                                   VDomDocument *doc, VContainer *data)
+{
     qint64 firstPointId = dialog->getFirstPointId();
     qint64 secondPointId = dialog->getSecondPointId();
     QString pointName = dialog->getPointName();
@@ -33,24 +37,29 @@ VModelingPointOfIntersection *VModelingPointOfIntersection::Create(const qint64
                                                                    const qint64 &firstPointId,
                                                                    const qint64 &secondPointId, const qreal &mx,
                                                                    const qreal &my, VDomDocument *doc,
-                                                                   VContainer *data,
-                                                                   const Document::Documents &parse,
-                                                                   Tool::Sources typeCreation){
+                                                                   VContainer *data, const Document::Documents &parse,
+                                                                   Tool::Sources typeCreation)
+{
     VModelingPointOfIntersection *tool = 0;
     VPointF firstPoint = data->GetPoint(firstPointId);
     VPointF secondPoint = data->GetPoint(secondPointId);
 
     QPointF point(firstPoint.x(), secondPoint.y());
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->AddPoint(VPointF(point.x(), point.y(), pointName, mx, my));
-    } else {
+    }
+    else
+    {
         data->UpdatePoint(id, VPointF(point.x(), point.y(), pointName, mx, my));
-        if(parse != Document::FullParse){
+        if (parse != Document::FullParse)
+        {
             doc->UpdateToolData(id, data);
         }
     }
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         tool = new VModelingPointOfIntersection(doc, data, id, firstPointId, secondPointId, typeCreation);
         doc->AddTool(id, tool);
         doc->IncrementReferens(firstPointId);
@@ -59,19 +68,24 @@ VModelingPointOfIntersection *VModelingPointOfIntersection::Create(const qint64
     return tool;
 }
 
-void VModelingPointOfIntersection::FullUpdateFromFile(){
+void VModelingPointOfIntersection::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         firstPointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
         secondPointId = domElement.attribute(AttrSecondPoint, "").toLongLong();
     }
     VModelingPoint::RefreshPointGeometry(VModelingTool::data.GetPoint(id));
 }
 
-void VModelingPointOfIntersection::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VModelingPointOfIntersection::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogPointOfIntersection->getPointName());
             domElement.setAttribute(AttrFirstPoint, QString().setNum(dialogPointOfIntersection->getFirstPointId()));
             domElement.setAttribute(AttrSecondPoint, QString().setNum(dialogPointOfIntersection->getSecondPointId()));
@@ -81,16 +95,19 @@ void VModelingPointOfIntersection::FullUpdateFromGui(int result){
     dialogPointOfIntersection.clear();
 }
 
-void VModelingPointOfIntersection::RemoveReferens(){
+void VModelingPointOfIntersection::RemoveReferens()
+{
     doc->DecrementReferens(firstPointId);
     doc->DecrementReferens(secondPointId);
 }
 
-void VModelingPointOfIntersection::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VModelingPointOfIntersection::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogPointOfIntersection, this, event);
 }
 
-void VModelingPointOfIntersection::AddToFile(){
+void VModelingPointOfIntersection::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
diff --git a/tools/modelingTools/vmodelingpointofintersection.h b/tools/modelingTools/vmodelingpointofintersection.h
index b2c00f4f2..1f11f0b6a 100644
--- a/tools/modelingTools/vmodelingpointofintersection.h
+++ b/tools/modelingTools/vmodelingpointofintersection.h
@@ -4,7 +4,8 @@
 #include "vmodelingpoint.h"
 #include "dialogs/dialogpointofintersection.h"
 
-class VModelingPointOfIntersection : public VModelingPoint{
+class VModelingPointOfIntersection : public VModelingPoint
+{
     Q_OBJECT
 public:
                  VModelingPointOfIntersection(VDomDocument *doc, VContainer *data, const qint64 &id,
diff --git a/tools/modelingTools/vmodelingshoulderpoint.cpp b/tools/modelingTools/vmodelingshoulderpoint.cpp
index d0f32ebfb..ac27b5392 100644
--- a/tools/modelingTools/vmodelingshoulderpoint.cpp
+++ b/tools/modelingTools/vmodelingshoulderpoint.cpp
@@ -28,30 +28,31 @@ const QString VModelingShoulderPoint::ToolType = QStringLiteral("shoulder");
 VModelingShoulderPoint::VModelingShoulderPoint(VDomDocument *doc, VContainer *data, const qint64 &id,
                                        const QString &typeLine, const QString &formula, const qint64 &p1Line,
                                        const qint64 &p2Line, const qint64 &pShoulder, Tool::Sources typeCreation,
-                                       QGraphicsItem * parent):
-    VModelingLinePoint(doc, data, id, typeLine, formula, p1Line, 0, parent), p2Line(p2Line),
-    pShoulder(pShoulder), dialogShoulderPoint(QSharedPointer<DialogShoulderPoint>()){
-
-    if(typeCreation == Tool::FromGui){
+                                       QGraphicsItem * parent)
+    :VModelingLinePoint(doc, data, id, typeLine, formula, p1Line, 0, parent), p2Line(p2Line),
+    pShoulder(pShoulder), dialogShoulderPoint(QSharedPointer<DialogShoulderPoint>())
+{
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VModelingShoulderPoint::setDialog(){
-    Q_ASSERT(!dialogShoulderPoint.isNull());
-    if(!dialogShoulderPoint.isNull()){
-        VPointF p = VAbstractTool::data.GetModelingPoint(id);
-        dialogShoulderPoint->setTypeLine(typeLine);
-        dialogShoulderPoint->setFormula(formula);
-        dialogShoulderPoint->setP1Line(basePointId, id);
-        dialogShoulderPoint->setP2Line(p2Line, id);
-        dialogShoulderPoint->setPShoulder(pShoulder, id);
-        dialogShoulderPoint->setPointName(p.name());
-    }
+void VModelingShoulderPoint::setDialog()
+{
+    Q_ASSERT(dialogShoulderPoint.isNull() == false);
+    VPointF p = VAbstractTool::data.GetModelingPoint(id);
+    dialogShoulderPoint->setTypeLine(typeLine);
+    dialogShoulderPoint->setFormula(formula);
+    dialogShoulderPoint->setP1Line(basePointId, id);
+    dialogShoulderPoint->setP2Line(p2Line, id);
+    dialogShoulderPoint->setPShoulder(pShoulder, id);
+    dialogShoulderPoint->setPointName(p.name());
 }
 
 VModelingShoulderPoint *VModelingShoulderPoint::Create(QSharedPointer<DialogShoulderPoint> &dialog,
-                                                       VDomDocument *doc, VContainer *data){
+                                                       VDomDocument *doc, VContainer *data)
+{
     QString formula = dialog->getFormula();
     qint64 p1Line = dialog->getP1Line();
     qint64 p2Line = dialog->getP2Line();
@@ -68,7 +69,8 @@ VModelingShoulderPoint *VModelingShoulderPoint::Create(const qint64 _id, const Q
                                                        const QString &pointName, const qreal &mx,
                                                        const qreal &my, VDomDocument *doc, VContainer *data,
                                                        const Document::Documents &parse,
-                                                       const Tool::Sources &typeCreation){
+                                                       const Tool::Sources &typeCreation)
+{
     VModelingShoulderPoint *point = 0;
     VPointF firstPoint = data->GetModelingPoint(p1Line);
     VPointF secondPoint = data->GetModelingPoint(p2Line);
@@ -77,21 +79,27 @@ VModelingShoulderPoint *VModelingShoulderPoint::Create(const qint64 _id, const Q
     Calculator cal(data);
     QString errorMsg;
     qreal result = cal.eval(formula, &errorMsg);
-    if(errorMsg.isEmpty()){
+    if (errorMsg.isEmpty())
+    {
         QPointF fPoint = VToolShoulderPoint::FindPoint(firstPoint.toQPointF(), secondPoint.toQPointF(),
                                                        shoulderPoint.toQPointF(), toPixel(result));
         qint64 id =  _id;
-        if(typeCreation == Tool::FromGui){
+        if (typeCreation == Tool::FromGui)
+        {
             id = data->AddModelingPoint(VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
-        } else {
-            data->UpdateModelingPoint(id,VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
-            if(parse != Document::FullParse){
+        }
+        else
+        {
+            data->UpdateModelingPoint(id, VPointF(fPoint.x(), fPoint.y(), pointName, mx, my));
+            if (parse != Document::FullParse)
+            {
                 doc->UpdateToolData(id, data);
             }
         }
         data->AddLine(p1Line, id, Draw::Modeling);
         data->AddLine(p2Line, id, Draw::Modeling);
-        if(parse == Document::FullParse){
+        if (parse == Document::FullParse)
+        {
             point = new VModelingShoulderPoint(doc, data, id, typeLine, formula, p1Line, p2Line, pShoulder,
                                                typeCreation);
             doc->AddTool(id, point);
@@ -103,9 +111,11 @@ VModelingShoulderPoint *VModelingShoulderPoint::Create(const qint64 _id, const Q
     return point;
 }
 
-void VModelingShoulderPoint::FullUpdateFromFile(){
+void VModelingShoulderPoint::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         typeLine = domElement.attribute(AttrTypeLine, "");
         formula = domElement.attribute(AttrLength, "");
         basePointId = domElement.attribute(AttrP1Line, "").toLongLong();
@@ -115,10 +125,13 @@ void VModelingShoulderPoint::FullUpdateFromFile(){
     RefreshGeometry();
 }
 
-void VModelingShoulderPoint::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VModelingShoulderPoint::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogShoulderPoint->getPointName());
             domElement.setAttribute(AttrTypeLine, dialogShoulderPoint->getTypeLine());
             domElement.setAttribute(AttrLength, dialogShoulderPoint->getFormula());
@@ -131,11 +144,13 @@ void VModelingShoulderPoint::FullUpdateFromGui(int result){
     dialogShoulderPoint.clear();
 }
 
-void VModelingShoulderPoint::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VModelingShoulderPoint::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogShoulderPoint, this, event);
 }
 
-void VModelingShoulderPoint::AddToFile(){
+void VModelingShoulderPoint::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetModelingPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -154,7 +169,8 @@ void VModelingShoulderPoint::AddToFile(){
     AddToModeling(domElement);
 }
 
-void VModelingShoulderPoint::RemoveReferens(){
+void VModelingShoulderPoint::RemoveReferens()
+{
     doc->DecrementReferens(p2Line);
     doc->DecrementReferens(pShoulder);
     VModelingLinePoint::RemoveReferens();
diff --git a/tools/modelingTools/vmodelingshoulderpoint.h b/tools/modelingTools/vmodelingshoulderpoint.h
index a9cee71cd..e1d86995e 100644
--- a/tools/modelingTools/vmodelingshoulderpoint.h
+++ b/tools/modelingTools/vmodelingshoulderpoint.h
@@ -25,7 +25,8 @@
 #include "vmodelinglinepoint.h"
 #include "dialogs/dialogshoulderpoint.h"
 
-class VModelingShoulderPoint : public VModelingLinePoint{
+class VModelingShoulderPoint : public VModelingLinePoint
+{
     Q_OBJECT
 public:
                  VModelingShoulderPoint(VDomDocument *doc, VContainer *data, const qint64 &id, const QString &typeLine,
diff --git a/tools/modelingTools/vmodelingspline.cpp b/tools/modelingTools/vmodelingspline.cpp
index 4cd48e3c8..7d3a39e69 100644
--- a/tools/modelingTools/vmodelingspline.cpp
+++ b/tools/modelingTools/vmodelingspline.cpp
@@ -26,8 +26,10 @@ const QString VModelingSpline::TagName = QStringLiteral("spline");
 const QString VModelingSpline::ToolType = QStringLiteral("simple");
 
 VModelingSpline::VModelingSpline(VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources typeCreation,
-                                 QGraphicsItem *parent):VModelingTool(doc, data, id), QGraphicsPathItem(parent),
-    dialogSpline(QSharedPointer<DialogSpline>()), controlPoints(QVector<VControlPointSpline *>()){
+                                 QGraphicsItem *parent)
+    :VModelingTool(doc, data, id), QGraphicsPathItem(parent),
+    dialogSpline(QSharedPointer<DialogSpline>()), controlPoints(QVector<VControlPointSpline *>())
+{
     ignoreFullUpdate = true;
     VSpline spl = data->GetModelingSpline(id);
     QPainterPath path;
@@ -54,27 +56,27 @@ VModelingSpline::VModelingSpline(VDomDocument *doc, VContainer *data, qint64 id,
     connect(this, &VModelingSpline::setEnabledPoint, controlPoint2, &VControlPointSpline::setEnabledPoint);
     controlPoints.append(controlPoint2);
 
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VModelingSpline::setDialog(){
-    Q_ASSERT(!dialogSpline.isNull());
-    if(!dialogSpline.isNull()){
-        VSpline spl = VAbstractTool::data.GetModelingSpline(id);
-        dialogSpline->setP1(spl.GetP1());
-        dialogSpline->setP4(spl.GetP4());
-        dialogSpline->setAngle1(spl.GetAngle1());
-        dialogSpline->setAngle2(spl.GetAngle2());
-        dialogSpline->setKAsm1(spl.GetKasm1());
-        dialogSpline->setKAsm2(spl.GetKasm2());
-        dialogSpline->setKCurve(spl.GetKcurve());
-    }
+void VModelingSpline::setDialog()
+{
+    Q_ASSERT(dialogSpline.isNull() == false);
+    VSpline spl = VAbstractTool::data.GetModelingSpline(id);
+    dialogSpline->setP1(spl.GetP1());
+    dialogSpline->setP4(spl.GetP4());
+    dialogSpline->setAngle1(spl.GetAngle1());
+    dialogSpline->setAngle2(spl.GetAngle2());
+    dialogSpline->setKAsm1(spl.GetKasm1());
+    dialogSpline->setKAsm2(spl.GetKasm2());
+    dialogSpline->setKCurve(spl.GetKcurve());
 }
 
-VModelingSpline *VModelingSpline::Create(QSharedPointer<DialogSpline> &dialog, VDomDocument *doc,
-                         VContainer *data){
+VModelingSpline *VModelingSpline::Create(QSharedPointer<DialogSpline> &dialog, VDomDocument *doc, VContainer *data)
+{
     qint64 p1 = dialog->getP1();
     qint64 p4 = dialog->getP4();
     qreal kAsm1 = dialog->getKAsm1();
@@ -89,20 +91,26 @@ VModelingSpline *VModelingSpline::Create(QSharedPointer<DialogSpline> &dialog, V
 VModelingSpline *VModelingSpline::Create(const qint64 _id, const qint64 &p1, const qint64 &p4,
                                          const qreal &kAsm1, const qreal kAsm2, const qreal &angle1,
                                          const qreal &angle2, const qreal &kCurve, VDomDocument *doc,
-                                         VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation){
+                                         VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation)
+{
     VModelingSpline *spl = 0;
     VSpline spline = VSpline(data->DataModelingPoints(), p1, p4, angle1, angle2, kAsm1, kAsm2, kCurve);
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->AddModelingSpline(spline);
-    } else {
+    }
+    else
+    {
         data->UpdateModelingSpline(id, spline);
-        if(parse != Document::FullParse){
+        if (parse != Document::FullParse)
+        {
             doc->UpdateToolData(id, data);
         }
     }
     data->AddLengthSpline(data->GetNameSpline(p1, p4, Draw::Modeling), toMM(spline.GetLength()));
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         spl = new VModelingSpline(doc, data, id, typeCreation);
         doc->AddTool(id, spl);
         doc->IncrementReferens(p1);
@@ -111,12 +119,15 @@ VModelingSpline *VModelingSpline::Create(const qint64 _id, const qint64 &p1, con
     return spl;
 }
 
-void VModelingSpline::FullUpdateFromFile(){
+void VModelingSpline::FullUpdateFromFile()
+{
     RefreshGeometry();
 }
 
-void VModelingSpline::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VModelingSpline::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         VSpline spl = VSpline (VAbstractTool::data.DataModelingPoints(), dialogSpline->getP1(),
                                dialogSpline->getP4(), dialogSpline->getAngle1(), dialogSpline->getAngle2(),
                                dialogSpline->getKAsm1(), dialogSpline->getKAsm2(), dialogSpline->getKCurve());
@@ -136,7 +147,8 @@ void VModelingSpline::FullUpdateFromGui(int result){
                        controlPoints[0]->pos(), controlPoints[1]->pos(), dialogSpline->getP4(),
                        dialogSpline->getKCurve());
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrPoint1, QString().setNum(spl.GetP1()));
             domElement.setAttribute(AttrPoint4, QString().setNum(spl.GetP4()));
             domElement.setAttribute(AttrAngle1, QString().setNum(spl.GetAngle1()));
@@ -151,16 +163,21 @@ void VModelingSpline::FullUpdateFromGui(int result){
 }
 
 void VModelingSpline::ControlPointChangePosition(const qint32 &indexSpline, SplinePoint::Position position,
-                                                 const QPointF pos){
+                                                 const QPointF pos)
+{
     Q_UNUSED(indexSpline);
     VSpline spl = VAbstractTool::data.GetModelingSpline(id);
-    if(position == SplinePoint::FirstPoint){
+    if (position == SplinePoint::FirstPoint)
+    {
         spl.ModifiSpl (spl.GetP1(), pos, spl.GetP3(), spl.GetP4(), spl.GetKcurve());
-    } else {
+    }
+    else
+    {
         spl.ModifiSpl (spl.GetP1(), spl.GetP2(), pos, spl.GetP4(), spl.GetKcurve());
     }
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         domElement.setAttribute(AttrAngle1, QString().setNum(spl.GetAngle1()));
         domElement.setAttribute(AttrAngle2, QString().setNum(spl.GetAngle2()));
         domElement.setAttribute(AttrKAsm1, QString().setNum(spl.GetKasm1()));
@@ -170,11 +187,13 @@ void VModelingSpline::ControlPointChangePosition(const qint32 &indexSpline, Spli
     }
 }
 
-void VModelingSpline::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VModelingSpline::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogSpline, this, event);
 }
 
-void VModelingSpline::AddToFile(){
+void VModelingSpline::AddToFile()
+{
     VSpline spl = VAbstractTool::data.GetModelingSpline(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -191,30 +210,36 @@ void VModelingSpline::AddToFile(){
     AddToModeling(domElement);
 }
 
-void VModelingSpline::mouseReleaseEvent(QGraphicsSceneMouseEvent *event){
-    if(event->button() == Qt::LeftButton){
+void VModelingSpline::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
         emit ChoosedTool(id, Scene::Spline);
     }
     QGraphicsItem::mouseReleaseEvent(event);
 }
 
-void VModelingSpline::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VModelingSpline::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthMainLine));
 }
 
-void VModelingSpline::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VModelingSpline::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthHairLine));
 }
 
-void VModelingSpline::RemoveReferens(){
+void VModelingSpline::RemoveReferens()
+{
     VSpline spl = VAbstractTool::data.GetModelingSpline(id);
     doc->DecrementReferens(spl.GetP1());
     doc->DecrementReferens(spl.GetP4());
 }
 
-void VModelingSpline::RefreshGeometry(){
+void VModelingSpline::RefreshGeometry()
+{
     VSpline spl = VAbstractTool::data.GetModelingSpline(id);
     QPainterPath path;
     path.addPath(spl.GetPath());
diff --git a/tools/modelingTools/vmodelingspline.h b/tools/modelingTools/vmodelingspline.h
index b4417fb66..66d1bbd1c 100644
--- a/tools/modelingTools/vmodelingspline.h
+++ b/tools/modelingTools/vmodelingspline.h
@@ -28,7 +28,8 @@
 #include "widgets/vcontrolpointspline.h"
 #include "geometry/vsplinepath.h"
 
-class VModelingSpline:public VModelingTool, public QGraphicsPathItem{
+class VModelingSpline:public VModelingTool, public QGraphicsPathItem
+{
     Q_OBJECT
 public:
                             VModelingSpline (VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources typeCreation,
diff --git a/tools/modelingTools/vmodelingsplinepath.cpp b/tools/modelingTools/vmodelingsplinepath.cpp
index 04e1d5c01..3022c060c 100644
--- a/tools/modelingTools/vmodelingsplinepath.cpp
+++ b/tools/modelingTools/vmodelingsplinepath.cpp
@@ -24,11 +24,11 @@
 const QString VModelingSplinePath::TagName = QStringLiteral("spline");
 const QString VModelingSplinePath::ToolType = QStringLiteral("path");
 
-VModelingSplinePath::VModelingSplinePath(VDomDocument *doc, VContainer *data, qint64 id,
-                                 Tool::Sources typeCreation,
-                                 QGraphicsItem *parent):VModelingTool(doc, data, id),
-    QGraphicsPathItem(parent), dialogSplinePath(QSharedPointer<DialogSplinePath>()),
-    controlPoints(QVector<VControlPointSpline *>()){
+VModelingSplinePath::VModelingSplinePath(VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources typeCreation,
+                                 QGraphicsItem *parent)
+    :VModelingTool(doc, data, id), QGraphicsPathItem(parent), dialogSplinePath(QSharedPointer<DialogSplinePath>()),
+    controlPoints(QVector<VControlPointSpline *>())
+{
     ignoreFullUpdate = true;
     VSplinePath splPath = data->GetModelingSplinePath(id);
     QPainterPath path;
@@ -39,7 +39,8 @@ VModelingSplinePath::VModelingSplinePath(VDomDocument *doc, VContainer *data, qi
     this->setFlag(QGraphicsItem::ItemIsSelectable, true);
     this->setAcceptHoverEvents(true);
 
-    for(qint32 i = 1; i<=splPath.Count(); ++i){
+    for (qint32 i = 1; i<=splPath.Count(); ++i)
+    {
         VSpline spl = splPath.GetSpline(i);
         VControlPointSpline *controlPoint = new VControlPointSpline(i, SplinePoint::FirstPoint, spl.GetP2(),
                                                                      spl.GetPointP1().toQPointF(), this);
@@ -57,57 +58,69 @@ VModelingSplinePath::VModelingSplinePath(VDomDocument *doc, VContainer *data, qi
         connect(this, &VModelingSplinePath::setEnabledPoint, controlPoint, &VControlPointSpline::setEnabledPoint);
         controlPoints.append(controlPoint);
     }
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VModelingSplinePath::setDialog(){
-    Q_ASSERT(!dialogSplinePath.isNull());
-    if(!dialogSplinePath.isNull()){
-        VSplinePath splPath = VAbstractTool::data.GetModelingSplinePath(id);
-        dialogSplinePath->SetPath(splPath);
-    }
+void VModelingSplinePath::setDialog()
+{
+    Q_ASSERT(dialogSplinePath.isNull() == false);
+    VSplinePath splPath = VAbstractTool::data.GetModelingSplinePath(id);
+    dialogSplinePath->SetPath(splPath);
 }
 
-VModelingSplinePath *VModelingSplinePath::Create(QSharedPointer<DialogSplinePath> &dialog,
-                             VDomDocument *doc, VContainer *data){
+VModelingSplinePath *VModelingSplinePath::Create(QSharedPointer<DialogSplinePath> &dialog, VDomDocument *doc,
+                                                 VContainer *data)
+{
     VSplinePath path = dialog->GetPath();
-    for(qint32 i = 0; i < path.CountPoint(); ++i){
+    for (qint32 i = 0; i < path.CountPoint(); ++i)
+    {
         doc->IncrementReferens(path[i].P());
     }
     return Create(0, path, doc, data, Document::FullParse, Tool::FromGui);
 }
 
-VModelingSplinePath * VModelingSplinePath::Create(const qint64 _id, const VSplinePath &path,
-                                                  VDomDocument *doc, VContainer *data, const Document::Documents &parse,
-                                                  Tool::Sources typeCreation){
+VModelingSplinePath * VModelingSplinePath::Create(const qint64 _id, const VSplinePath &path, VDomDocument *doc,
+                                                  VContainer *data, const Document::Documents &parse,
+                                                  Tool::Sources typeCreation)
+{
     VModelingSplinePath *spl = 0;
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->AddModelingSplinePath(path);
-    } else {
+    }
+    else
+    {
         data->UpdateModelingSplinePath(id, path);
-        if(parse != Document::FullParse){
+        if (parse != Document::FullParse)
+        {
             doc->UpdateToolData(id, data);
         }
     }
     data->AddLengthSpline(data->GetNameSplinePath(path), toMM(path.GetLength()));
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         spl = new VModelingSplinePath(doc, data, id, typeCreation);
         doc->AddTool(id, spl);
     }
     return spl;
 }
 
-void VModelingSplinePath::FullUpdateFromFile(){
+void VModelingSplinePath::FullUpdateFromFile()
+{
     RefreshGeometry();
 }
 
-void VModelingSplinePath::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VModelingSplinePath::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         VSplinePath splPath = dialogSplinePath->GetPath();
-        for(qint32 i = 1; i<=splPath.Count(); ++i){
+        for (qint32 i = 1; i<=splPath.Count(); ++i)
+        {
             VSpline spl = splPath.GetSpline(i);
             qint32 j = i*2;
             disconnect(controlPoints[j-2], &VControlPointSpline::ControlPointChangePosition, this,
@@ -127,7 +140,8 @@ void VModelingSplinePath::FullUpdateFromGui(int result){
             CorectControlPoints(spl, splPath, i);
 
             QDomElement domElement = doc->elementById(QString().setNum(id));
-            if(domElement.isElement()){
+            if (domElement.isElement())
+            {
                 domElement.setAttribute(AttrKCurve, QString().setNum(splPath.getKCurve()));
                 UpdatePathPoint(domElement, splPath);
                 emit FullUpdateTree();
@@ -139,26 +153,31 @@ void VModelingSplinePath::FullUpdateFromGui(int result){
 }
 
 void VModelingSplinePath::ControlPointChangePosition(const qint32 &indexSpline, SplinePoint::Position position,
-                                                 const QPointF pos){
+                                                 const QPointF pos)
+{
     VSplinePath splPath = VAbstractTool::data.GetModelingSplinePath(id);
     VSpline spl = splPath.GetSpline(indexSpline);
-    if(position == SplinePoint::FirstPoint){
+    if (position == SplinePoint::FirstPoint)
+    {
         spl.ModifiSpl (spl.GetP1(), pos, spl.GetP3(), spl.GetP4(), spl.GetKcurve());
-    } else {
+    }
+    else
+    {
         spl.ModifiSpl (spl.GetP1(), spl.GetP2(), pos, spl.GetP4(), spl.GetKcurve());
     }
 
     CorectControlPoints(spl, splPath, indexSpline);
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         domElement.setAttribute(AttrKCurve, QString().setNum(splPath.getKCurve()));
         UpdatePathPoint(domElement, splPath);
         emit FullUpdateTree();
     }
 }
 
-void VModelingSplinePath::CorectControlPoints(const VSpline &spl, VSplinePath &splPath,
-                                          const qint32 &indexSpline){
+void VModelingSplinePath::CorectControlPoints(const VSpline &spl, VSplinePath &splPath, const qint32 &indexSpline)
+{
     VSplinePoint p = splPath.GetSplinePoint(indexSpline, SplinePoint::FirstPoint);
     p.SetAngle(spl.GetAngle1());
     p.SetKAsm2(spl.GetKasm1());
@@ -170,12 +189,15 @@ void VModelingSplinePath::CorectControlPoints(const VSpline &spl, VSplinePath &s
     splPath.UpdatePoint(indexSpline, SplinePoint::LastPoint, p);
 }
 
-void VModelingSplinePath::UpdatePathPoint(QDomNode& node, VSplinePath &path){
+void VModelingSplinePath::UpdatePathPoint(QDomNode& node, VSplinePath &path)
+{
     QDomNodeList nodeList = node.childNodes();
     qint32 num = nodeList.size();
-    for(qint32 i = 0; i < num; ++i){
+    for (qint32 i = 0; i < num; ++i)
+    {
         QDomElement domElement = nodeList.at(i).toElement();
-        if(!domElement.isNull()){
+        if (domElement.isNull() == false)
+        {
             VSplinePoint p = path[i];
             domElement.setAttribute(AttrPSpline, QString().setNum(p.P()));
             domElement.setAttribute(AttrKAsm1, QString().setNum(p.KAsm1()));
@@ -185,11 +207,13 @@ void VModelingSplinePath::UpdatePathPoint(QDomNode& node, VSplinePath &path){
     }
 }
 
-void VModelingSplinePath::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VModelingSplinePath::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogSplinePath, this, event);
 }
 
-void VModelingSplinePath::AddToFile(){
+void VModelingSplinePath::AddToFile()
+{
     VSplinePath splPath = VAbstractTool::data.GetModelingSplinePath(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -197,14 +221,16 @@ void VModelingSplinePath::AddToFile(){
     AddAttribute(domElement, AttrType, ToolType);
     AddAttribute(domElement, AttrKCurve, splPath.getKCurve());
 
-    for(qint32 i = 0; i < splPath.CountPoint(); ++i){
+    for (qint32 i = 0; i < splPath.CountPoint(); ++i)
+    {
         AddPathPoint(domElement, splPath[i]);
     }
 
     AddToModeling(domElement);
 }
 
-void VModelingSplinePath::AddPathPoint(QDomElement &domElement, const VSplinePoint &splPoint){
+void VModelingSplinePath::AddPathPoint(QDomElement &domElement, const VSplinePoint &splPoint)
+{
     QDomElement pathPoint = doc->createElement(AttrPathPoint);
 
     AddAttribute(pathPoint, AttrPSpline, splPoint.P());
@@ -215,37 +241,45 @@ void VModelingSplinePath::AddPathPoint(QDomElement &domElement, const VSplinePoi
     domElement.appendChild(pathPoint);
 }
 
-void VModelingSplinePath::mouseReleaseEvent(QGraphicsSceneMouseEvent *event){
-    if(event->button() == Qt::LeftButton){
+void VModelingSplinePath::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
         emit ChoosedTool(id, Scene::SplinePath);
     }
     QGraphicsItem::mouseReleaseEvent(event);
 }
 
-void VModelingSplinePath::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VModelingSplinePath::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthMainLine));
 }
 
-void VModelingSplinePath::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VModelingSplinePath::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthHairLine));
 }
 
-void VModelingSplinePath::RemoveReferens(){
+void VModelingSplinePath::RemoveReferens()
+{
     VSplinePath splPath = VAbstractTool::data.GetModelingSplinePath(id);
-    for(qint32 i = 0; i < splPath.Count(); ++i){
+    for (qint32 i = 0; i < splPath.Count(); ++i)
+    {
         doc->DecrementReferens(splPath[i].P());
     }
 }
 
-void VModelingSplinePath::RefreshGeometry(){
+void VModelingSplinePath::RefreshGeometry()
+{
     VSplinePath splPath = VAbstractTool::data.GetModelingSplinePath(id);
     QPainterPath path;
     path.addPath(splPath.GetPath());
     path.setFillRule( Qt::WindingFill );
     this->setPath(path);
-    for(qint32 i = 1; i<=splPath.Count(); ++i){
+    for (qint32 i = 1; i<=splPath.Count(); ++i)
+    {
         VSpline spl = splPath.GetSpline(i);
         QPointF splinePoint = spl.GetPointP1().toQPointF();
         QPointF controlPoint = spl.GetP2();
@@ -266,5 +300,4 @@ void VModelingSplinePath::RefreshGeometry(){
         connect(controlPoints[j-1], &VControlPointSpline::ControlPointChangePosition, this,
                 &VModelingSplinePath::ControlPointChangePosition);
     }
-
 }
diff --git a/tools/modelingTools/vmodelingsplinepath.h b/tools/modelingTools/vmodelingsplinepath.h
index 19f44235f..4071c1c70 100644
--- a/tools/modelingTools/vmodelingsplinepath.h
+++ b/tools/modelingTools/vmodelingsplinepath.h
@@ -27,7 +27,8 @@
 #include "dialogs/dialogsplinepath.h"
 #include "widgets/vcontrolpointspline.h"
 
-class VModelingSplinePath:public VModelingTool, public QGraphicsPathItem{
+class VModelingSplinePath:public VModelingTool, public QGraphicsPathItem
+{
     Q_OBJECT
 public:
                   VModelingSplinePath(VDomDocument *doc, VContainer *data, qint64 id, Tool::Sources typeCreation,
diff --git a/tools/modelingTools/vmodelingtool.cpp b/tools/modelingTools/vmodelingtool.cpp
index fd38f2088..cc0d58cb9 100644
--- a/tools/modelingTools/vmodelingtool.cpp
+++ b/tools/modelingTools/vmodelingtool.cpp
@@ -22,32 +22,42 @@
 #include "vmodelingtool.h"
 #include <QDebug>
 
-VModelingTool::VModelingTool(VDomDocument *doc, VContainer *data, qint64 id, QObject *parent):
-VAbstractTool(doc, data, id, parent), ignoreContextMenuEvent(false), ignoreFullUpdate(false) {
+VModelingTool::VModelingTool(VDomDocument *doc, VContainer *data, qint64 id, QObject *parent)
+    :VAbstractTool(doc, data, id, parent), ignoreContextMenuEvent(false), ignoreFullUpdate(false)
+{
     _referens = 0;
 }
 
-void VModelingTool::AddToModeling(const QDomElement &domElement){
+void VModelingTool::AddToModeling(const QDomElement &domElement)
+{
     QDomElement modelingElement;
     bool ok = doc->GetActivModelingElement(modelingElement);
-    if(ok){
+    if (ok)
+    {
         modelingElement.appendChild(domElement);
-    } else {
+    }
+    else
+    {
         qCritical()<<"Can't find tag Modeling"<< Q_FUNC_INFO;
     }
     emit toolhaveChange();
 }
 
-void VModelingTool::decrementReferens(){
-    if(_referens > 0){
+void VModelingTool::decrementReferens()
+{
+    if (_referens > 0)
+    {
         --_referens;
     }
-    if(_referens <= 0){
+    if (_referens <= 0)
+    {
         RemoveReferens();
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             QDomNode element = domElement.parentNode();
-            if(!element.isNull()){
+            if (element.isNull() == false)
+            {
                 element.removeChild(domElement);
             }
         }
diff --git a/tools/modelingTools/vmodelingtool.h b/tools/modelingTools/vmodelingtool.h
index 014ff996d..e40edaacd 100644
--- a/tools/modelingTools/vmodelingtool.h
+++ b/tools/modelingTools/vmodelingtool.h
@@ -25,7 +25,8 @@
 #include "../vabstracttool.h"
 #include <QMenu>
 
-class VModelingTool: public VAbstractTool{
+class VModelingTool: public VAbstractTool
+{
     Q_OBJECT
 public:
                  VModelingTool(VDomDocument *doc, VContainer *data, qint64 id, QObject *parent = 0);
@@ -41,27 +42,35 @@ protected:
     virtual void decrementReferens();
     template <typename Dialog, typename Tool>
     void ContextMenu(QSharedPointer<Dialog> &dialog, Tool *tool, QGraphicsSceneContextMenuEvent *event,
-                     bool showRemove = true){
-        if(!ignoreContextMenuEvent){
+                     bool showRemove = true)
+    {
+        if (ignoreContextMenuEvent == false)
+        {
             QMenu menu;
             QAction *actionOption = menu.addAction(tr("Option"));
             QAction *actionRemove = 0;
-            if(showRemove){
+            if (showRemove)
+            {
                actionRemove = menu.addAction(tr("Delete"));
-               if(_referens > 1){
+               if (_referens > 1)
+               {
                    actionRemove->setEnabled(false);
-               } else {
+               }
+               else
+               {
                    actionRemove->setEnabled(true);
                }
             }
             QAction *selectedAction = menu.exec(event->screenPos());
-            if(selectedAction == actionOption){
+            if (selectedAction == actionOption)
+            {
                 dialog = QSharedPointer<Dialog>(new Dialog(getData()));
 
                 connect(qobject_cast< VMainGraphicsScene * >(tool->scene()),
                         &VMainGraphicsScene::ChoosedObject, dialog.data(), &Dialog::ChoosedObject);
                 connect(dialog.data(), &Dialog::DialogClosed, tool, &Tool::FullUpdateFromGui);
-                if(!ignoreFullUpdate){
+                if (ignoreFullUpdate == false)
+                {
                     connect(doc, &VDomDocument::FullUpdateFromFile, dialog.data(), &Dialog::UpdateList);
                 }
 
@@ -69,16 +78,20 @@ protected:
 
                dialog->show();
             }
-            if(showRemove){
-                if(selectedAction == actionRemove){
+            if (showRemove)
+            {
+                if (selectedAction == actionRemove)
+                {
                     //deincrement referens
                     RemoveReferens();
                     //remove form xml file
                     QDomElement domElement = doc->elementById(QString().setNum(id));
-                    if(domElement.isElement()){
+                    if (domElement.isElement())
+                    {
                         QDomElement element;
                         bool ok = doc->GetActivCalculationElement(element);
-                        if(ok){
+                        if (ok)
+                        {
                             element.removeChild(domElement);
                             //update xml file
                             emit FullUpdateTree();
diff --git a/tools/modelingTools/vmodelingtriangle.cpp b/tools/modelingTools/vmodelingtriangle.cpp
index 2e068ab85..d22de1f75 100644
--- a/tools/modelingTools/vmodelingtriangle.cpp
+++ b/tools/modelingTools/vmodelingtriangle.cpp
@@ -28,14 +28,17 @@ VModelingTriangle::VModelingTriangle(VDomDocument *doc, VContainer *data, const
                                      const qint64 &axisP2Id, const qint64 &firstPointId, const qint64 &secondPointId,
                                      Tool::Sources typeCreation, QGraphicsItem *parent)
     :VModelingPoint(doc, data, id, parent), axisP1Id(axisP1Id), axisP2Id(axisP2Id), firstPointId(firstPointId),
-      secondPointId(secondPointId), dialogTriangle(QSharedPointer<DialogTriangle>()) {
-    if(typeCreation == Tool::FromGui){
+      secondPointId(secondPointId), dialogTriangle(QSharedPointer<DialogTriangle>())
+{
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VModelingTriangle::setDialog(){
-    Q_ASSERT(!dialogTriangle.isNull());
+void VModelingTriangle::setDialog()
+{
+    Q_ASSERT(dialogTriangle.isNull() == false);
     VPointF p = VAbstractTool::data.GetPoint(id);
     dialogTriangle->setAxisP1Id(axisP1Id, id);
     dialogTriangle->setAxisP2Id(axisP2Id, id);
@@ -45,7 +48,8 @@ void VModelingTriangle::setDialog(){
 }
 
 VModelingTriangle *VModelingTriangle::Create(QSharedPointer<DialogTriangle> &dialog, VDomDocument *doc,
-                                             VContainer *data){
+                                             VContainer *data)
+{
     qint64 axisP1Id = dialog->getAxisP1Id();
     qint64 axisP2Id = dialog->getAxisP2Id();
     qint64 firstPointId = dialog->getFirstPointId();
@@ -59,7 +63,8 @@ VModelingTriangle *VModelingTriangle::Create(const qint64 _id, const QString &po
                                              const qint64 &axisP2Id, const qint64 &firstPointId,
                                              const qint64 &secondPointId, const qreal &mx, const qreal &my,
                                              VDomDocument *doc, VContainer *data, const Document::Documents &parse,
-                                             Tool::Sources typeCreation){
+                                             Tool::Sources typeCreation)
+{
     VModelingTriangle *tool = 0;
     VPointF axisP1 = data->GetPoint(axisP1Id);
     VPointF axisP2 = data->GetPoint(axisP2Id);
@@ -69,15 +74,20 @@ VModelingTriangle *VModelingTriangle::Create(const qint64 _id, const QString &po
     QPointF point = VToolTriangle::FindPoint(axisP1.toQPointF(), axisP2.toQPointF(), firstPoint.toQPointF(),
                                              secondPoint.toQPointF());
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->AddPoint(VPointF(point.x(), point.y(), pointName, mx, my));
-    } else {
+    }
+    else
+    {
         data->UpdatePoint(id, VPointF(point.x(), point.y(), pointName, mx, my));
-        if(parse != Document::FullParse){
+        if (parse != Document::FullParse)
+        {
             doc->UpdateToolData(id, data);
         }
     }
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         tool = new VModelingTriangle(doc, data, id, axisP1Id, axisP2Id, firstPointId, secondPointId, typeCreation);
         doc->AddTool(id, tool);
         doc->IncrementReferens(axisP1Id);
@@ -88,9 +98,11 @@ VModelingTriangle *VModelingTriangle::Create(const qint64 _id, const QString &po
     return tool;
 }
 
-void VModelingTriangle::FullUpdateFromFile(){
+void VModelingTriangle::FullUpdateFromFile()
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         axisP1Id = domElement.attribute(AttrAxisP1, "").toLongLong();
         axisP2Id = domElement.attribute(AttrAxisP2, "").toLongLong();
         firstPointId = domElement.attribute(AttrFirstPoint, "").toLongLong();
@@ -99,10 +111,13 @@ void VModelingTriangle::FullUpdateFromFile(){
     VModelingPoint::RefreshPointGeometry(VModelingTool::data.GetPoint(id));
 }
 
-void VModelingTriangle::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VModelingTriangle::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrName, dialogTriangle->getPointName());
             domElement.setAttribute(AttrAxisP1, QString().setNum(dialogTriangle->getAxisP1Id()));
             domElement.setAttribute(AttrAxisP2, QString().setNum(dialogTriangle->getAxisP2Id()));
@@ -115,18 +130,21 @@ void VModelingTriangle::FullUpdateFromGui(int result){
     dialogTriangle.clear();
 }
 
-void VModelingTriangle::RemoveReferens(){
+void VModelingTriangle::RemoveReferens()
+{
     doc->DecrementReferens(axisP1Id);
     doc->DecrementReferens(axisP2Id);
     doc->DecrementReferens(firstPointId);
     doc->DecrementReferens(secondPointId);
 }
 
-void VModelingTriangle::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VModelingTriangle::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     ContextMenu(dialogTriangle, this, event);
 }
 
-void VModelingTriangle::AddToFile(){
+void VModelingTriangle::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
diff --git a/tools/modelingTools/vmodelingtriangle.h b/tools/modelingTools/vmodelingtriangle.h
index 069544bd7..cc1007291 100644
--- a/tools/modelingTools/vmodelingtriangle.h
+++ b/tools/modelingTools/vmodelingtriangle.h
@@ -26,7 +26,8 @@
 #include "../drawTools/vtooltriangle.h"
 #include "dialogs/dialogtriangle.h"
 
-class VModelingTriangle : public VModelingPoint{
+class VModelingTriangle : public VModelingPoint
+{
     Q_OBJECT
 public:
                  VModelingTriangle(VDomDocument *doc, VContainer *data, const qint64 &id, const qint64 &axisP1Id,
diff --git a/tools/nodeDetails/vabstractnode.cpp b/tools/nodeDetails/vabstractnode.cpp
index 2e671ea9d..ab9c6473f 100644
--- a/tools/nodeDetails/vabstractnode.cpp
+++ b/tools/nodeDetails/vabstractnode.cpp
@@ -28,32 +28,42 @@ const QString VAbstractNode::TypeObjectCalculation = QStringLiteral("Calculation
 const QString VAbstractNode::TypeObjectModeling = QStringLiteral("Modeling");
 
 VAbstractNode::VAbstractNode(VDomDocument *doc, VContainer *data, qint64 id, qint64 idNode, Draw::Draws typeobject,
-                             QObject *parent) : VAbstractTool(doc, data, id, parent), idNode(idNode),
-    typeobject(typeobject){
+                             QObject *parent)
+    : VAbstractTool(doc, data, id, parent), idNode(idNode), typeobject(typeobject)
+{
     _referens = 0;
 }
 
-void VAbstractNode::AddToModeling(const QDomElement &domElement){
+void VAbstractNode::AddToModeling(const QDomElement &domElement)
+{
     QDomElement modelingElement;
     bool ok = doc->GetActivModelingElement(modelingElement);
-    if(ok){
+    if (ok)
+    {
         modelingElement.appendChild(domElement);
-    } else {
+    }
+    else
+    {
         qCritical()<<tr("Can't find tag Modeling")<< Q_FUNC_INFO;
     }
     emit toolhaveChange();
 }
 
-void VAbstractNode::decrementReferens(){
-    if(_referens > 0){
+void VAbstractNode::decrementReferens()
+{
+    if (_referens > 0)
+    {
         --_referens;
     }
-    if(_referens <= 0){
+    if (_referens <= 0)
+    {
         doc->DecrementReferens(idNode);
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             QDomNode element = domElement.parentNode();
-            if(!element.isNull()){
+            if (element.isNull() == false)
+            {
                 element.removeChild(domElement);
             }
         }
diff --git a/tools/nodeDetails/vabstractnode.h b/tools/nodeDetails/vabstractnode.h
index 5a931f103..a7553b878 100644
--- a/tools/nodeDetails/vabstractnode.h
+++ b/tools/nodeDetails/vabstractnode.h
@@ -24,7 +24,8 @@
 
 #include "../vabstracttool.h"
 
-class VAbstractNode : public VAbstractTool{
+class VAbstractNode : public VAbstractTool
+{
     Q_OBJECT
 public:
                  VAbstractNode(VDomDocument *doc, VContainer *data, qint64 id, qint64 idNode,
diff --git a/tools/nodeDetails/vnodearc.cpp b/tools/nodeDetails/vnodearc.cpp
index 1e4d3c5c1..7f8a1cdef 100644
--- a/tools/nodeDetails/vnodearc.cpp
+++ b/tools/nodeDetails/vnodearc.cpp
@@ -25,67 +25,83 @@ const QString VNodeArc::TagName = QStringLiteral("arc");
 const QString VNodeArc::ToolType = QStringLiteral("modeling");
 
 VNodeArc::VNodeArc(VDomDocument *doc, VContainer *data, qint64 id, qint64 idArc, Draw::Draws typeobject,
-                           Tool::Sources typeCreation, QGraphicsItem * parent) :
-    VAbstractNode(doc, data, id, idArc, typeobject), QGraphicsPathItem(parent){
+                   Tool::Sources typeCreation, QGraphicsItem * parent)
+    :VAbstractNode(doc, data, id, idArc, typeobject), QGraphicsPathItem(parent)
+{
     RefreshGeometry();
     this->setPen(QPen(baseColor, widthHairLine));
     this->setFlag(QGraphicsItem::ItemIsSelectable, true);
     this->setAcceptHoverEvents(true);
 
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VNodeArc::Create(VDomDocument *doc, VContainer *data, qint64 id, qint64 idArc,
-                      Draw::Draws typeobject, const Document::Documents &parse, Tool::Sources typeCreation){
-    if(parse == Document::FullParse){
+void VNodeArc::Create(VDomDocument *doc, VContainer *data, qint64 id, qint64 idArc, Draw::Draws typeobject,
+                      const Document::Documents &parse, Tool::Sources typeCreation)
+{
+    if (parse == Document::FullParse)
+    {
         VNodeArc *arc = new VNodeArc(doc, data, id, idArc, typeobject, typeCreation);
         Q_ASSERT(arc != 0);
         doc->AddTool(id, arc);
         doc->IncrementReferens(idArc);
-    } else {
+    }
+    else
+    {
         doc->UpdateToolData(id, data);
     }
 }
 
-void VNodeArc::FullUpdateFromFile(){
+void VNodeArc::FullUpdateFromFile()
+{
     RefreshGeometry();
 }
 
-void VNodeArc::AddToFile(){
+void VNodeArc::AddToFile()
+{
     QDomElement domElement = doc->createElement(TagName);
 
     AddAttribute(domElement, AttrId, id);
     AddAttribute(domElement, AttrType, ToolType);
     AddAttribute(domElement, AttrIdObject, idNode);
-    if(typeobject == Draw::Calculation){
+    if (typeobject == Draw::Calculation)
+    {
         AddAttribute(domElement, AttrTypeObject, TypeObjectCalculation);
-    } else {
+    }
+    else
+    {
         AddAttribute(domElement, AttrTypeObject, ToolType );
     }
 
     AddToModeling(domElement);
 }
 
-void VNodeArc::mouseReleaseEvent(QGraphicsSceneMouseEvent *event){
-    if(event->button() == Qt::LeftButton){
+void VNodeArc::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
         emit ChoosedTool(id, Scene::Arc);
     }
     QGraphicsItem::mouseReleaseEvent(event);
 }
 
-void VNodeArc::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VNodeArc::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthMainLine));
 }
 
-void VNodeArc::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VNodeArc::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthHairLine));
 }
 
-void VNodeArc::RefreshGeometry(){
+void VNodeArc::RefreshGeometry()
+{
     VArc arc = VAbstractTool::data.GetModelingArc(id);
     QPainterPath path;
     path.addPath(arc.GetPath());
diff --git a/tools/nodeDetails/vnodearc.h b/tools/nodeDetails/vnodearc.h
index e206e2c6a..9b07ffba9 100644
--- a/tools/nodeDetails/vnodearc.h
+++ b/tools/nodeDetails/vnodearc.h
@@ -25,7 +25,8 @@
 #include "vabstractnode.h"
 #include <QGraphicsPathItem>
 
-class VNodeArc :public VAbstractNode, public QGraphicsPathItem{
+class VNodeArc :public VAbstractNode, public QGraphicsPathItem
+{
     Q_OBJECT
 public:
                  VNodeArc(VDomDocument *doc, VContainer *data, qint64 id, qint64 idArc, Draw::Draws typeobject,
diff --git a/tools/nodeDetails/vnodepoint.cpp b/tools/nodeDetails/vnodepoint.cpp
index c5b1056f8..a42370749 100644
--- a/tools/nodeDetails/vnodepoint.cpp
+++ b/tools/nodeDetails/vnodepoint.cpp
@@ -24,10 +24,11 @@
 const QString VNodePoint::TagName = QStringLiteral("point");
 const QString VNodePoint::ToolType = QStringLiteral("modeling");
 
-VNodePoint::VNodePoint(VDomDocument *doc, VContainer *data, qint64 id, qint64 idPoint,
-                       Draw::Draws typeobject, Tool::Sources typeCreation, QGraphicsItem *parent)
-    :VAbstractNode(doc, data, id, idPoint, typeobject), QGraphicsEllipseItem(parent),
-     radius(toPixel(1.5)), namePoint(0), lineName(0){
+VNodePoint::VNodePoint(VDomDocument *doc, VContainer *data, qint64 id, qint64 idPoint, Draw::Draws typeobject,
+                       Tool::Sources typeCreation, QGraphicsItem *parent)
+    :VAbstractNode(doc, data, id, idPoint, typeobject), QGraphicsEllipseItem(parent), radius(toPixel(1.5)),
+      namePoint(0), lineName(0)
+{
     namePoint = new VGraphicsSimpleTextItem(this);
     lineName = new QGraphicsLineItem(this);
     connect(namePoint, &VGraphicsSimpleTextItem::NameChangePosition, this,
@@ -37,37 +38,47 @@ VNodePoint::VNodePoint(VDomDocument *doc, VContainer *data, qint64 id, qint64 id
     this->setFlag(QGraphicsItem::ItemIsSelectable, true);
     this->setAcceptHoverEvents(true);
     RefreshPointGeometry(VAbstractTool::data.GetModelingPoint(id));
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
-void VNodePoint::Create(VDomDocument *doc, VContainer *data, qint64 id, qint64 idPoint,
-                        Draw::Draws typeobject, const Document::Documents &parse, Tool::Sources typeCreation){
-    if(parse == Document::FullParse){
+void VNodePoint::Create(VDomDocument *doc, VContainer *data, qint64 id, qint64 idPoint, Draw::Draws typeobject,
+                        const Document::Documents &parse, Tool::Sources typeCreation)
+{
+    if (parse == Document::FullParse)
+    {
         VNodePoint *point = new VNodePoint(doc, data, id, idPoint, typeobject, typeCreation);
         Q_ASSERT(point != 0);
         doc->AddTool(id, point);
         doc->IncrementReferens(idPoint);
-    } else {
+    }
+    else
+    {
         doc->UpdateToolData(id, data);
     }
 }
 
-void VNodePoint::FullUpdateFromFile(){
+void VNodePoint::FullUpdateFromFile()
+{
     RefreshPointGeometry(VAbstractTool::data.GetModelingPoint(id));
 }
 
-void VNodePoint::AddToFile(){
+void VNodePoint::AddToFile()
+{
     VPointF point = VAbstractTool::data.GetModelingPoint(id);
     QDomElement domElement = doc->createElement(TagName);
 
     AddAttribute(domElement, AttrId, id);
     AddAttribute(domElement, AttrType, ToolType);
     AddAttribute(domElement, AttrIdObject, idNode);
-    if(typeobject == Draw::Calculation){
+    if (typeobject == Draw::Calculation)
+    {
         AddAttribute(domElement, AttrTypeObject, TypeObjectCalculation);
-    } else {
+    }
+    else
+    {
         AddAttribute(domElement, AttrTypeObject, TypeObjectModeling);
     }
     AddAttribute(domElement, AttrMx, toMM(point.mx()));
@@ -76,25 +87,30 @@ void VNodePoint::AddToFile(){
     AddToModeling(domElement);
 }
 
-void VNodePoint::mouseReleaseEvent(QGraphicsSceneMouseEvent *event){
-    if(event->button() == Qt::LeftButton){
+void VNodePoint::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
         emit ChoosedTool(id, Scene::Point);
     }
     QGraphicsItem::mouseReleaseEvent(event);
 }
 
-void VNodePoint::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VNodePoint::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthMainLine));
 }
 
-void VNodePoint::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VNodePoint::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthHairLine));
 }
 
 
-void VNodePoint::NameChangePosition(const QPointF pos){
+void VNodePoint::NameChangePosition(const QPointF pos)
+{
     VPointF point = VAbstractTool::data.GetModelingPoint(id);
     QPointF p = pos - this->pos();
     point.setMx(p.x());
@@ -104,16 +120,19 @@ void VNodePoint::NameChangePosition(const QPointF pos){
     VAbstractTool::data.UpdatePoint(id, point);
 }
 
-void VNodePoint::UpdateNamePosition(qreal mx, qreal my){
+void VNodePoint::UpdateNamePosition(qreal mx, qreal my)
+{
     QDomElement domElement = doc->elementById(QString().setNum(id));
-    if(domElement.isElement()){
+    if (domElement.isElement())
+    {
         domElement.setAttribute(AttrMx, QString().setNum(toMM(mx)));
         domElement.setAttribute(AttrMy, QString().setNum(toMM(my)));
         emit toolhaveChange();
     }
 }
 
-void VNodePoint::RefreshPointGeometry(const VPointF &point){
+void VNodePoint::RefreshPointGeometry(const VPointF &point)
+{
     QRectF rec = QRectF(0, 0, radius*2, radius*2);
     rec.translate(-rec.center().x(), -rec.center().y());
     this->setRect(rec);
@@ -128,15 +147,19 @@ void VNodePoint::RefreshPointGeometry(const VPointF &point){
     RefreshLine();
 }
 
-void VNodePoint::RefreshLine(){
+void VNodePoint::RefreshLine()
+{
     QRectF nameRec = namePoint->sceneBoundingRect();
     QPointF p1, p2;
     LineIntersectCircle(QPointF(), radius, QLineF(QPointF(), nameRec.center()- scenePos()), p1, p2);
     QPointF pRec = LineIntersectRect(nameRec, QLineF(scenePos(), nameRec.center()));
     lineName->setLine(QLineF(p1, pRec - scenePos()));
-    if(QLineF(p1, pRec - scenePos()).length() <= toPixel(4)){
+    if (QLineF(p1, pRec - scenePos()).length() <= toPixel(4))
+    {
         lineName->setVisible(false);
-    } else {
+    }
+    else
+    {
         lineName->setVisible(true);
     }
 }
diff --git a/tools/nodeDetails/vnodepoint.h b/tools/nodeDetails/vnodepoint.h
index e1a6d75e0..e90393e7d 100644
--- a/tools/nodeDetails/vnodepoint.h
+++ b/tools/nodeDetails/vnodepoint.h
@@ -25,7 +25,8 @@
 #include "vabstractnode.h"
 #include "widgets/vgraphicssimpletextitem.h"
 
-class VNodePoint: public VAbstractNode, public QGraphicsEllipseItem{
+class VNodePoint: public VAbstractNode, public QGraphicsEllipseItem
+{
     Q_OBJECT
 public:
                  VNodePoint(VDomDocument *doc, VContainer *data, qint64 id, qint64 idPoint, Draw::Draws typeobject,
diff --git a/tools/nodeDetails/vnodespline.cpp b/tools/nodeDetails/vnodespline.cpp
index cf6092c73..b315878ae 100644
--- a/tools/nodeDetails/vnodespline.cpp
+++ b/tools/nodeDetails/vnodespline.cpp
@@ -24,70 +24,86 @@
 const QString VNodeSpline::TagName = QStringLiteral("spline");
 const QString VNodeSpline::ToolType = QStringLiteral("modelingSpline");
 
-VNodeSpline::VNodeSpline(VDomDocument *doc, VContainer *data, qint64 id, qint64 idSpline,
-                                 Draw::Draws typeobject, Tool::Sources typeCreation, QGraphicsItem * parent) :
-    VAbstractNode(doc, data, id, idSpline, typeobject), QGraphicsPathItem(parent){
+VNodeSpline::VNodeSpline(VDomDocument *doc, VContainer *data, qint64 id, qint64 idSpline, Draw::Draws typeobject,
+                         Tool::Sources typeCreation, QGraphicsItem * parent)
+    :VAbstractNode(doc, data, id, idSpline, typeobject), QGraphicsPathItem(parent)
+{
     RefreshGeometry();
     this->setPen(QPen(baseColor, widthHairLine));
     this->setFlag(QGraphicsItem::ItemIsSelectable, true);
     this->setAcceptHoverEvents(true);
 
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
 VNodeSpline *VNodeSpline::Create(VDomDocument *doc, VContainer *data, qint64 id, qint64 idSpline,
                                  Draw::Draws typeobject, const Document::Documents &parse,
-                                 Tool::Sources typeCreation){
+                                 Tool::Sources typeCreation)
+{
     VNodeSpline *spl = 0;
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         spl = new VNodeSpline(doc, data, id, idSpline, typeobject, typeCreation);
         doc->AddTool(id, spl);
         doc->IncrementReferens(idSpline);
-    } else {
+    }
+    else
+    {
         doc->UpdateToolData(id, data);
     }
     return spl;
 }
 
-void VNodeSpline::FullUpdateFromFile(){
+void VNodeSpline::FullUpdateFromFile()
+{
     RefreshGeometry();
 }
 
-void VNodeSpline::AddToFile(){
+void VNodeSpline::AddToFile()
+{
     QDomElement domElement = doc->createElement(TagName);
 
     AddAttribute(domElement, AttrId, id);
     AddAttribute(domElement, AttrType, ToolType);
     AddAttribute(domElement, AttrIdObject, idNode);
-    if(typeobject == Draw::Calculation){
+    if (typeobject == Draw::Calculation)
+    {
         AddAttribute(domElement, AttrTypeObject, TypeObjectCalculation);
-    } else {
+    }
+    else
+    {
         AddAttribute(domElement, AttrTypeObject, TypeObjectModeling);
     }
 
     AddToModeling(domElement);
 }
 
-void VNodeSpline::mouseReleaseEvent(QGraphicsSceneMouseEvent *event){
-    if(event->button() == Qt::LeftButton){
+void VNodeSpline::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
         emit ChoosedTool(id, Scene::Spline);
     }
     QGraphicsItem::mouseReleaseEvent(event);
 }
 
-void VNodeSpline::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VNodeSpline::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthMainLine));
 }
 
-void VNodeSpline::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VNodeSpline::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthHairLine));
 }
 
-void VNodeSpline::RefreshGeometry(){
+void VNodeSpline::RefreshGeometry()
+{
     VSpline spl = VAbstractTool::data.GetModelingSpline(id);
     QPainterPath path;
     path.addPath(spl.GetPath());
diff --git a/tools/nodeDetails/vnodespline.h b/tools/nodeDetails/vnodespline.h
index 3e1d381bc..6af937ab7 100644
--- a/tools/nodeDetails/vnodespline.h
+++ b/tools/nodeDetails/vnodespline.h
@@ -25,7 +25,8 @@
 #include "vabstractnode.h"
 #include <QGraphicsPathItem>
 
-class VNodeSpline:public VAbstractNode, public QGraphicsPathItem{
+class VNodeSpline:public VAbstractNode, public QGraphicsPathItem
+{
     Q_OBJECT
 public:
                   VNodeSpline(VDomDocument *doc, VContainer *data, qint64 id, qint64 idSpline, Draw::Draws typeobject,
diff --git a/tools/nodeDetails/vnodesplinepath.cpp b/tools/nodeDetails/vnodesplinepath.cpp
index 07ac92b53..2f226afb3 100644
--- a/tools/nodeDetails/vnodesplinepath.cpp
+++ b/tools/nodeDetails/vnodesplinepath.cpp
@@ -25,73 +25,88 @@ const QString VNodeSplinePath::TagName = QStringLiteral("spline");
 const QString VNodeSplinePath::ToolType = QStringLiteral("modelingPath");
 
 VNodeSplinePath::VNodeSplinePath(VDomDocument *doc, VContainer *data, qint64 id, qint64 idSpline,
-                                         Draw::Draws typeobject, Tool::Sources typeCreation,
-                                         QGraphicsItem * parent) :
-    VAbstractNode(doc, data, id, idSpline, typeobject), QGraphicsPathItem(parent){
+                                         Draw::Draws typeobject, Tool::Sources typeCreation, QGraphicsItem * parent)
+    :VAbstractNode(doc, data, id, idSpline, typeobject), QGraphicsPathItem(parent)
+{
     RefreshGeometry();
     this->setPen(QPen(baseColor, widthHairLine));
     this->setFlag(QGraphicsItem::ItemIsSelectable, true);
     this->setAcceptHoverEvents(true);
 
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         AddToFile();
     }
 }
 
 void VNodeSplinePath::Create(VDomDocument *doc, VContainer *data, qint64 id, qint64 idSpline,
-                             Draw::Draws typeobject, const Document::Documents &parse,
-                             Tool::Sources typeCreation){
-    if(parse == Document::FullParse){
+                             Draw::Draws typeobject, const Document::Documents &parse, Tool::Sources typeCreation)
+{
+    if (parse == Document::FullParse)
+    {
         VNodeSplinePath *splPath = new VNodeSplinePath(doc, data, id, idSpline, typeobject, typeCreation);
         Q_ASSERT(splPath != 0);
         doc->AddTool(id, splPath);
         VSplinePath path = data->GetModelingSplinePath(id);
         const QVector<VSplinePoint> *points = path.GetPoint();
-        for(qint32 i = 0; i<points->size(); ++i){
+        for (qint32 i = 0; i<points->size(); ++i)
+        {
             doc->IncrementReferens(points->at(i).P());
         }
-    } else {
+    }
+    else
+    {
         doc->UpdateToolData(id, data);
     }
 }
 
-void VNodeSplinePath::FullUpdateFromFile(){
+void VNodeSplinePath::FullUpdateFromFile()
+{
     RefreshGeometry();
 }
 
-void VNodeSplinePath::AddToFile(){
+void VNodeSplinePath::AddToFile()
+{
     QDomElement domElement = doc->createElement(TagName);
 
     AddAttribute(domElement, AttrId, id);
     AddAttribute(domElement, AttrType, ToolType);
     AddAttribute(domElement, AttrIdObject, idNode);
-    if(typeobject == Draw::Calculation){
+    if (typeobject == Draw::Calculation)
+    {
         AddAttribute(domElement, AttrTypeObject, TypeObjectCalculation);
-    } else {
+    }
+    else
+    {
         AddAttribute(domElement, AttrTypeObject, TypeObjectModeling);
     }
 
     AddToModeling(domElement);
 }
 
-void VNodeSplinePath::mouseReleaseEvent(QGraphicsSceneMouseEvent *event){
-    if(event->button() == Qt::LeftButton){
+void VNodeSplinePath::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
         emit ChoosedTool(id, Scene::SplinePath);
     }
     QGraphicsItem::mouseReleaseEvent(event);
 }
 
-void VNodeSplinePath::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VNodeSplinePath::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthMainLine));
 }
 
-void VNodeSplinePath::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VNodeSplinePath::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(currentColor, widthHairLine));
 }
 
-void VNodeSplinePath::RefreshGeometry(){
+void VNodeSplinePath::RefreshGeometry()
+{
     VSplinePath splPath = VAbstractTool::data.GetModelingSplinePath(id);
     QPainterPath path;
     path.addPath(splPath.GetPath());
diff --git a/tools/nodeDetails/vnodesplinepath.h b/tools/nodeDetails/vnodesplinepath.h
index 5e623b65c..6ee6ee980 100644
--- a/tools/nodeDetails/vnodesplinepath.h
+++ b/tools/nodeDetails/vnodesplinepath.h
@@ -25,7 +25,8 @@
 #include "vabstractnode.h"
 #include <QGraphicsPathItem>
 
-class VNodeSplinePath : public VAbstractNode, public QGraphicsPathItem{
+class VNodeSplinePath : public VAbstractNode, public QGraphicsPathItem
+{
     Q_OBJECT
 public:
                  VNodeSplinePath(VDomDocument *doc, VContainer *data, qint64 id, qint64 idSpline,
diff --git a/tools/vabstracttool.cpp b/tools/vabstracttool.cpp
index 634a3a73f..df6bcb14e 100644
--- a/tools/vabstracttool.cpp
+++ b/tools/vabstracttool.cpp
@@ -58,40 +58,45 @@ const QString VAbstractTool::AttrAxisP2      = QStringLiteral("axisP2");
 const QString VAbstractTool::TypeLineNone    = QStringLiteral("none");
 const QString VAbstractTool::TypeLineLine    = QStringLiteral("hair");
 
-VAbstractTool::VAbstractTool(VDomDocument *doc, VContainer *data, qint64 id, QObject *parent):
-    VDataTool(data, parent), doc(doc), id(id), baseColor(Qt::black), currentColor(Qt::black){
-
+VAbstractTool::VAbstractTool(VDomDocument *doc, VContainer *data, qint64 id, QObject *parent)
+    :VDataTool(data, parent), doc(doc), id(id), baseColor(Qt::black), currentColor(Qt::black)
+{
     connect(this, &VAbstractTool::toolhaveChange, this->doc, &VDomDocument::haveLiteChange);
     connect(this->doc, &VDomDocument::FullUpdateFromFile, this, &VAbstractTool::FullUpdateFromFile);
     connect(this, &VAbstractTool::FullUpdateTree, this->doc, &VDomDocument::FullUpdateTree);
 }
 
-QPointF VAbstractTool::LineIntersectRect(QRectF rec, QLineF line){
+QPointF VAbstractTool::LineIntersectRect(QRectF rec, QLineF line)
+{
     qreal x1, y1, x2, y2;
     rec.getCoords(&x1, &y1, &x2, &y2);
     QPointF point;
-    QLineF::IntersectType type = line.intersect(QLineF(QPointF(x1,y1), QPointF(x1,y2)),&point);
-    if ( type == QLineF::BoundedIntersection ){
+    QLineF::IntersectType type = line.intersect(QLineF(QPointF(x1, y1), QPointF(x1, y2)), &point);
+    if ( type == QLineF::BoundedIntersection )
+    {
         return point;
     }
-    type = line.intersect(QLineF(QPointF(x1,y1), QPointF(x2,y1)),&point);
-    if ( type == QLineF::BoundedIntersection ){
+    type = line.intersect(QLineF(QPointF(x1, y1), QPointF(x2, y1)), &point);
+    if ( type == QLineF::BoundedIntersection )
+    {
         return point;
     }
-    type = line.intersect(QLineF(QPointF(x1,y2), QPointF(x2,y2)),&point);
-    if ( type == QLineF::BoundedIntersection ){
+    type = line.intersect(QLineF(QPointF(x1, y2), QPointF(x2, y2)), &point);
+    if ( type == QLineF::BoundedIntersection )
+    {
         return point;
     }
-    type = line.intersect(QLineF(QPointF(x2,y1), QPointF(x2,y2)),&point);
-    if ( type == QLineF::BoundedIntersection ){
+    type = line.intersect(QLineF(QPointF(x2, y1), QPointF(x2, y2)), &point);
+    if ( type == QLineF::BoundedIntersection )
+    {
         return point;
     }
     Q_ASSERT_X(type != QLineF::BoundedIntersection, Q_FUNC_INFO, "There is no point of intersection.");
     return point;
 }
 
-qint32 VAbstractTool::LineIntersectCircle(QPointF center, qreal radius, QLineF line, QPointF &p1,
-                                          QPointF &p2){
+qint32 VAbstractTool::LineIntersectCircle(QPointF center, qreal radius, QLineF line, QPointF &p1, QPointF &p2)
+{
     const qreal eps = 1e-8;
     //коефіцієнти для рівняння відрізку
     qreal a = 0, b = 0, c = 0;
@@ -101,12 +106,18 @@ qint32 VAbstractTool::LineIntersectCircle(QPointF center, qreal radius, QLineF l
     // сколько всего решений?
     qint32 flag = 0;
     qreal d = QLineF (center, p).length();
-    if (qAbs (d - radius) <= eps){
+    if (qAbs (d - radius) <= eps)
+    {
         flag = 1;
-    } else {
-        if (radius > d){
+    }
+    else
+    {
+        if (radius > d)
+        {
             flag = 2;
-        } else {
+        }
+        else
+        {
             return 0;
         }
     }
@@ -119,17 +130,22 @@ qint32 VAbstractTool::LineIntersectCircle(QPointF center, qreal radius, QLineF l
     return flag;
 }
 
-QPointF VAbstractTool::ClosestPoint(QLineF line, QPointF p){
+QPointF VAbstractTool::ClosestPoint(QLineF line, QPointF p)
+{
     QLineF lineP2pointFrom = QLineF(line.p2(), p);
     qreal angle = 180-line.angleTo(lineP2pointFrom)-90;
     QLineF pointFromlineP2 = QLineF(p, line.p2());
     pointFromlineP2.setAngle(pointFromlineP2.angle()+angle);
     QPointF point;
-    QLineF::IntersectType type = pointFromlineP2.intersect(line,&point);
-    if ( type == QLineF::BoundedIntersection ){
+    QLineF::IntersectType type = pointFromlineP2.intersect(line, &point);
+    if ( type == QLineF::BoundedIntersection )
+    {
         return point;
-    } else{
-        if ( type == QLineF::NoIntersection || type == QLineF::UnboundedIntersection ){
+    }
+    else
+    {
+        if ( type == QLineF::NoIntersection || type == QLineF::UnboundedIntersection )
+        {
             Q_ASSERT_X(type != QLineF::BoundedIntersection, Q_FUNC_INFO, "Немає точки перетину.");
             return point;
         }
@@ -137,19 +153,24 @@ QPointF VAbstractTool::ClosestPoint(QLineF line, QPointF p){
     return point;
 }
 
-QPointF VAbstractTool::addVector(QPointF p, QPointF p1, QPointF p2, qreal k){
+QPointF VAbstractTool::addVector(QPointF p, QPointF p1, QPointF p2, qreal k)
+{
     return QPointF (p.x() + (p2.x() - p1.x()) * k, p.y() + (p2.y() - p1.y()) * k);
 }
 
-void VAbstractTool::RemoveAllChild(QDomElement &domElement){
-    if ( domElement.hasChildNodes() ){
-        while ( domElement.childNodes().length() >= 1 ){
+void VAbstractTool::RemoveAllChild(QDomElement &domElement)
+{
+    if ( domElement.hasChildNodes() )
+    {
+        while ( domElement.childNodes().length() >= 1 )
+        {
             domElement.removeChild( domElement.firstChild() );
         }
     }
 }
 
-void VAbstractTool::LineCoefficients(const QLineF &line, qreal *a, qreal *b, qreal *c){
+void VAbstractTool::LineCoefficients(const QLineF &line, qreal *a, qreal *b, qreal *c)
+{
     //коефіцієнти для рівняння відрізку
     *a = line.p2().y() - line.p1().y();
     *b = line.p1().x() - line.p2().x();
diff --git a/tools/vabstracttool.h b/tools/vabstracttool.h
index 511e43f31..a5a398d56 100644
--- a/tools/vabstracttool.h
+++ b/tools/vabstracttool.h
@@ -25,7 +25,8 @@
 #include "vdatatool.h"
 #include <xml/vdomdocument.h>
 
-class VAbstractTool: public VDataTool{
+class VAbstractTool: public VDataTool
+{
     Q_OBJECT
 public:
                             VAbstractTool(VDomDocument *doc, VContainer *data, qint64 id, QObject *parent = 0);
@@ -89,7 +90,8 @@ protected:
     virtual void            RemoveReferens(){}
     void                    RemoveAllChild(QDomElement &domElement);
     template <typename T>
-    void AddAttribute(QDomElement &domElement, const QString &name, const T &value){
+    void AddAttribute(QDomElement &domElement, const QString &name, const T &value)
+    {
         QDomAttr domAttr = doc->createAttribute(name);
         domAttr.setValue(QString().setNum(value));
         domElement.setAttributeNode(domAttr);
@@ -99,7 +101,8 @@ private:
 };
 
 template <>
-inline void VAbstractTool::AddAttribute<QString>(QDomElement &domElement, const QString &name, const QString &value){
+inline void VAbstractTool::AddAttribute<QString>(QDomElement &domElement, const QString &name, const QString &value)
+{
     QDomAttr domAttr = doc->createAttribute(name);
     domAttr.setValue(value);
     domElement.setAttributeNode(domAttr);
diff --git a/tools/vdatatool.cpp b/tools/vdatatool.cpp
index 60dba8c40..d5f3ebefd 100644
--- a/tools/vdatatool.cpp
+++ b/tools/vdatatool.cpp
@@ -21,14 +21,17 @@
 
 #include "vdatatool.h"
 
-VDataTool &VDataTool::operator =(const VDataTool &tool){
+VDataTool &VDataTool::operator =(const VDataTool &tool)
+{
    data = tool.getData();
    _referens = tool.referens();
    return *this;
 }
 
-void VDataTool::decrementReferens(){
-    if(_referens > 0){
+void VDataTool::decrementReferens()
+{
+    if (_referens > 0)
+    {
         --_referens;
     }
 }
diff --git a/tools/vdatatool.h b/tools/vdatatool.h
index f0519762f..9b8dda925 100644
--- a/tools/vdatatool.h
+++ b/tools/vdatatool.h
@@ -25,10 +25,11 @@
 #include <container/vcontainer.h>
 
 //We need QObject class because we use qobject_cast.
-class VDataTool : public QObject{
+class VDataTool : public QObject
+{
     Q_OBJECT
 public:
-    explicit              VDataTool(VContainer *data, QObject *parent = 0): QObject(parent), data(*data), _referens(1){}
+                          VDataTool(VContainer *data, QObject *parent = 0): QObject(parent), data(*data), _referens(1){}
     virtual               ~VDataTool(){}
     VDataTool             &operator= (const VDataTool &tool);
     inline VContainer     getData() const { return data; }
diff --git a/tools/vtooldetail.cpp b/tools/vtooldetail.cpp
index de0d48269..d51e0fc57 100644
--- a/tools/vtooldetail.cpp
+++ b/tools/vtooldetail.cpp
@@ -35,68 +35,72 @@ const QString VToolDetail::NodeTypeContour  = QStringLiteral("Contour");
 const QString VToolDetail::NodeTypeModeling = QStringLiteral("Modeling");
 
 VToolDetail::VToolDetail(VDomDocument *doc, VContainer *data, const qint64 &id, Tool::Sources typeCreation,
-                         VMainGraphicsScene *scene, QGraphicsItem *parent) :VAbstractTool(doc, data, id),
-    QGraphicsPathItem(parent), dialogDetail(QSharedPointer<DialogDetail>()), sceneDetails(scene){
+                         VMainGraphicsScene *scene, QGraphicsItem *parent)
+    :VAbstractTool(doc, data, id), QGraphicsPathItem(parent), dialogDetail(QSharedPointer<DialogDetail>()),
+      sceneDetails(scene)
+{
     VDetail detail = data->GetDetail(id);
-    for(qint32 i = 0; i< detail.CountNode(); ++i){
-        switch(detail[i].getTypeTool()){
-        case(Tool::NodePoint):
-            InitTool<VNodePoint>(scene, detail[i]);
-            break;
-        case(Tool::NodeArc):
-            InitTool<VNodeArc>(scene, detail[i]);
-            break;
-        case(Tool::NodeSpline):
-            InitTool<VNodeSpline>(scene, detail[i]);
-            break;
-        case(Tool::NodeSplinePath):
-            InitTool<VNodeSplinePath>(scene, detail[i]);
-            break;
-        case(Tool::AlongLineTool):
-            InitTool<VModelingAlongLine>(scene, detail[i]);
-            break;
-        case(Tool::ArcTool):
-            InitTool<VModelingArc>(scene, detail[i]);
-            break;
-        case(Tool::BisectorTool):
-            InitTool<VModelingBisector>(scene, detail[i]);
-            break;
-        case(Tool::EndLineTool):
-            InitTool<VModelingEndLine>(scene, detail[i]);
-            break;
-        case(Tool::LineIntersectTool):
-            InitTool<VModelingLineIntersect>(scene, detail[i]);
-            break;
-        case(Tool::LineTool):
-            InitTool<VModelingLine>(scene, detail[i]);
-            break;
-        case(Tool::NormalTool):
-            InitTool<VModelingNormal>(scene, detail[i]);
-            break;
-        case(Tool::PointOfContact):
-            InitTool<VModelingPointOfContact>(scene, detail[i]);
-            break;
-        case(Tool::ShoulderPointTool):
-            InitTool<VModelingShoulderPoint>(scene, detail[i]);
-            break;
-        case(Tool::SplinePathTool):
-            InitTool<VModelingSplinePath>(scene, detail[i]);
-            break;
-        case(Tool::SplineTool):
-            InitTool<VModelingSpline>(scene, detail[i]);
-            break;
-        case(Tool::Height):
-            InitTool<VModelingHeight>(scene, detail[i]);
-            break;
-        case(Tool::Triangle):
-            InitTool<VModelingTriangle>(scene, detail[i]);
-            break;
-        case(Tool::PointOfIntersection):
-            InitTool<VModelingPointOfIntersection>(scene, detail[i]);
-            break;
-        default:
-            qWarning()<<"Get wrong tool type. Ignore.";
-            break;
+    for (qint32 i = 0; i< detail.CountNode(); ++i)
+    {
+        switch (detail[i].getTypeTool())
+        {
+            case (Tool::NodePoint):
+                InitTool<VNodePoint>(scene, detail[i]);
+                break;
+            case (Tool::NodeArc):
+                InitTool<VNodeArc>(scene, detail[i]);
+                break;
+            case (Tool::NodeSpline):
+                InitTool<VNodeSpline>(scene, detail[i]);
+                break;
+            case (Tool::NodeSplinePath):
+                InitTool<VNodeSplinePath>(scene, detail[i]);
+                break;
+            case (Tool::AlongLineTool):
+                InitTool<VModelingAlongLine>(scene, detail[i]);
+                break;
+            case (Tool::ArcTool):
+                InitTool<VModelingArc>(scene, detail[i]);
+                break;
+            case (Tool::BisectorTool):
+                InitTool<VModelingBisector>(scene, detail[i]);
+                break;
+            case (Tool::EndLineTool):
+                InitTool<VModelingEndLine>(scene, detail[i]);
+                break;
+            case (Tool::LineIntersectTool):
+                InitTool<VModelingLineIntersect>(scene, detail[i]);
+                break;
+            case (Tool::LineTool):
+                InitTool<VModelingLine>(scene, detail[i]);
+                break;
+            case (Tool::NormalTool):
+                InitTool<VModelingNormal>(scene, detail[i]);
+                break;
+            case (Tool::PointOfContact):
+                InitTool<VModelingPointOfContact>(scene, detail[i]);
+                break;
+            case (Tool::ShoulderPointTool):
+                InitTool<VModelingShoulderPoint>(scene, detail[i]);
+                break;
+            case (Tool::SplinePathTool):
+                InitTool<VModelingSplinePath>(scene, detail[i]);
+                break;
+            case (Tool::SplineTool):
+                InitTool<VModelingSpline>(scene, detail[i]);
+                break;
+            case (Tool::Height):
+                InitTool<VModelingHeight>(scene, detail[i]);
+                break;
+            case (Tool::Triangle):
+                InitTool<VModelingTriangle>(scene, detail[i]);
+                break;
+            case (Tool::PointOfIntersection):
+                InitTool<VModelingPointOfIntersection>(scene, detail[i]);
+                break;
+            default:
+                qWarning()<<"Get wrong tool type. Ignore.";
+                break;
         }
         doc->IncrementReferens(detail[i].getId());
     }
@@ -105,75 +109,96 @@ VToolDetail::VToolDetail(VDomDocument *doc, VContainer *data, const qint64 &id,
     RefreshGeometry();
     this->setPos(detail.getMx(), detail.getMy());
     this->setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
        AddToFile();
     }
 }
 
-void VToolDetail::setDialog(){
-    Q_ASSERT(!dialogDetail.isNull());
+void VToolDetail::setDialog()
+{
+    Q_ASSERT(dialogDetail.isNull() == false);
     VDetail detail = VAbstractTool::data.GetDetail(id);
     dialogDetail->setDetails(detail);
 }
 
-void VToolDetail::Create(QSharedPointer<DialogDetail> &dialog, VMainGraphicsScene *scene,
-                         VDomDocument *doc, VContainer *data){
+void VToolDetail::Create(QSharedPointer<DialogDetail> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
+                         VContainer *data)
+{
     VDetail detail = dialog->getDetails();
     VDetail det;
-    for(qint32 i = 0; i< detail.CountNode(); ++i){
+    for (qint32 i = 0; i< detail.CountNode(); ++i)
+    {
         qint64 id = 0;
-        switch(detail[i].getTypeTool()){
-        case(Tool::NodePoint):{
-            VPointF point;
-            if(detail[i].getMode() == Draw::Calculation){
-                point = data->GetPoint(detail[i].getId());
-            } else {
-                point = data->GetModelingPoint(detail[i].getId());
+        switch (detail[i].getTypeTool())
+        {
+            case (Tool::NodePoint):
+            {
+                VPointF point;
+                if (detail[i].getMode() == Draw::Calculation)
+                {
+                    point = data->GetPoint(detail[i].getId());
+                }
+                else
+                {
+                    point = data->GetModelingPoint(detail[i].getId());
+                }
+                id = data->AddModelingPoint(point);
+                VNodePoint::Create(doc, data, id, detail[i].getId(), detail[i].getMode(),
+                                   Document::FullParse, Tool::FromGui);
             }
-            id = data->AddModelingPoint(point);
-            VNodePoint::Create(doc, data, id, detail[i].getId(), detail[i].getMode(),
-                               Document::FullParse, Tool::FromGui);
-        }
             break;
-        case(Tool::NodeArc):{
-            VArc arc;
-            if(detail[i].getMode() == Draw::Calculation){
-                arc = data->GetArc(detail[i].getId());
-            } else {
-                arc = data->GetModelingArc(detail[i].getId());
+            case (Tool::NodeArc):
+            {
+                VArc arc;
+                if (detail[i].getMode() == Draw::Calculation)
+                {
+                    arc = data->GetArc(detail[i].getId());
+                }
+                else
+                {
+                    arc = data->GetModelingArc(detail[i].getId());
+                }
+                id = data->AddModelingArc(arc);
+                VNodeArc::Create(doc, data, id, detail[i].getId(), detail[i].getMode(),
+                                 Document::FullParse, Tool::FromGui);
             }
-            id = data->AddModelingArc(arc);
-            VNodeArc::Create(doc, data, id, detail[i].getId(), detail[i].getMode(),
-                             Document::FullParse, Tool::FromGui);
-        }
             break;
-        case(Tool::NodeSpline):{
-            VSpline spline;
-            if(detail[i].getMode() == Draw::Calculation){
-                spline = data->GetSpline(detail[i].getId());
-            } else {
-                spline = data->GetModelingSpline(detail[i].getId());
-            }
-            id = data->AddModelingSpline(spline);
-            VNodeSpline::Create(doc, data, id, detail[i].getId(), detail[i].getMode(),
-                                Document::FullParse, Tool::FromGui);
-        }
-            break;
-        case(Tool::NodeSplinePath):{
-            VSplinePath splinePath;
-            if(detail[i].getMode() == Draw::Calculation){
-                splinePath = data->GetSplinePath(detail[i].getId());
-            } else {
-                splinePath = data->GetModelingSplinePath(detail[i].getId());
-            }
-            id = data->AddModelingSplinePath(splinePath);
-            VNodeSplinePath::Create(doc, data, id, detail[i].getId(), detail[i].getMode(),
+            case (Tool::NodeSpline):
+            {
+                VSpline spline;
+                if (detail[i].getMode() == Draw::Calculation)
+                {
+                    spline = data->GetSpline(detail[i].getId());
+                }
+                else
+                {
+                    spline = data->GetModelingSpline(detail[i].getId());
+                }
+                id = data->AddModelingSpline(spline);
+                VNodeSpline::Create(doc, data, id, detail[i].getId(), detail[i].getMode(),
                                     Document::FullParse, Tool::FromGui);
-        }
+            }
             break;
-        default:
-            qWarning()<<"May be wrong tool type!!! Ignoring."<<Q_FUNC_INFO;
+            case (Tool::NodeSplinePath):
+            {
+                VSplinePath splinePath;
+                if (detail[i].getMode() == Draw::Calculation)
+                {
+                    splinePath = data->GetSplinePath(detail[i].getId());
+                }
+                else
+                {
+                    splinePath = data->GetModelingSplinePath(detail[i].getId());
+                }
+                id = data->AddModelingSplinePath(splinePath);
+                VNodeSplinePath::Create(doc, data, id, detail[i].getId(), detail[i].getMode(),
+                                        Document::FullParse, Tool::FromGui);
+            }
             break;
+            default:
+                qWarning()<<"May be wrong tool type!!! Ignoring."<<Q_FUNC_INFO;
+                break;
         }
         VNodeDetail node(id, detail[i].getTypeTool(), Draw::Modeling, NodeDetail::Contour);
         det.append(node);
@@ -183,17 +208,23 @@ void VToolDetail::Create(QSharedPointer<DialogDetail> &dialog, VMainGraphicsScen
 }
 
 void VToolDetail::Create(const qint64 _id, VDetail &newDetail, VMainGraphicsScene *scene, VDomDocument *doc,
-                         VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation){
+                         VContainer *data, const Document::Documents &parse, Tool::Sources typeCreation)
+{
     qint64 id = _id;
-    if(typeCreation == Tool::FromGui){
+    if (typeCreation == Tool::FromGui)
+    {
         id = data->AddDetail(newDetail);
-    } else {
+    }
+    else
+    {
         data->UpdateDetail(id, newDetail);
-        if(parse != Document::FullParse){
+        if (parse != Document::FullParse)
+        {
             doc->UpdateToolData(id, data);
         }
     }
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         VToolDetail *detail = new VToolDetail(doc, data, id, typeCreation, scene);
         scene->addItem(detail);
         connect(detail, &VToolDetail::ChoosedTool, scene, &VMainGraphicsScene::ChoosedItem);
@@ -203,21 +234,26 @@ void VToolDetail::Create(const qint64 _id, VDetail &newDetail, VMainGraphicsScen
     }
 }
 
-void VToolDetail::FullUpdateFromFile(){
+void VToolDetail::FullUpdateFromFile()
+{
     RefreshGeometry();
 }
 
-void VToolDetail::FullUpdateFromGui(int result){
-    if(result == QDialog::Accepted){
+void VToolDetail::FullUpdateFromGui(int result)
+{
+    if (result == QDialog::Accepted)
+    {
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             VDetail det = dialogDetail->getDetails();
             domElement.setAttribute(AttrName, det.getName());
             domElement.setAttribute(AttrSupplement, QString().setNum(det.getSupplement()));
             domElement.setAttribute(AttrClosed, QString().setNum(det.getClosed()));
             domElement.setAttribute(AttrWidth, QString().setNum(det.getWidth()));
             RemoveAllChild(domElement);
-            for(qint32 i = 0; i < det.CountNode(); ++i){
+            for (qint32 i = 0; i < det.CountNode(); ++i)
+            {
                AddNode(domElement, det[i]);
             }
             emit FullUpdateTree();
@@ -226,7 +262,8 @@ void VToolDetail::FullUpdateFromGui(int result){
     dialogDetail.clear();
 }
 
-void VToolDetail::AddToFile(){
+void VToolDetail::AddToFile()
+{
     VDetail detail = VAbstractTool::data.GetDetail(id);
     QDomElement domElement = doc->createElement(TagName);
 
@@ -238,24 +275,29 @@ void VToolDetail::AddToFile(){
     AddAttribute(domElement, AttrClosed, detail.getClosed());
     AddAttribute(domElement, AttrWidth, detail.getWidth());
 
-    for(qint32 i = 0; i < detail.CountNode(); ++i){
+    for (qint32 i = 0; i < detail.CountNode(); ++i)
+    {
        AddNode(domElement, detail[i]);
     }
 
     QDomElement element;
     bool ok = doc->GetActivDetailsElement(element);
-    if(ok){
+    if (ok)
+    {
         element.appendChild(domElement);
     }
 }
 
-QVariant VToolDetail::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value){
-    if (change == ItemPositionHasChanged && scene()) {
+QVariant VToolDetail::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value)
+{
+    if (change == ItemPositionHasChanged && scene())
+    {
         // value - это новое положение.
         QPointF newPos = value.toPointF();
         //qDebug()<<newPos;
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             domElement.setAttribute(AttrMx, QString().setNum(toMM(newPos.x())));
             domElement.setAttribute(AttrMy, QString().setNum(toMM(newPos.y())));
             //I don't now why but signal does not work.
@@ -265,24 +307,31 @@ QVariant VToolDetail::itemChange(QGraphicsItem::GraphicsItemChange change, const
     return QGraphicsItem::itemChange(change, value);
 }
 
-void VToolDetail::mouseReleaseEvent(QGraphicsSceneMouseEvent *event){
-    if(event->button() == Qt::LeftButton){
+void VToolDetail::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
         emit ChoosedTool(id, Scene::Detail);
     }
     QGraphicsItem::mouseReleaseEvent(event);
 }
 
-void VToolDetail::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
+void VToolDetail::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
     QMenu menu;
     QAction *actionOption = menu.addAction(tr("Options"));
     QAction *actionRemove = menu.addAction(tr("Delete"));
-    if(_referens > 1){
+    if (_referens > 1)
+    {
         actionRemove->setEnabled(false);
-    } else {
+    }
+    else
+    {
         actionRemove->setEnabled(true);
     }
     QAction *selectedAction = menu.exec(event->screenPos());
-    if(selectedAction == actionOption){
+    if (selectedAction == actionOption)
+    {
         dialogDetail = QSharedPointer<DialogDetail>(new DialogDetail(getData(), Draw::Modeling));
         connect(qobject_cast< VMainGraphicsScene * >(this->scene()), &VMainGraphicsScene::ChoosedObject,
                 dialogDetail.data(), &DialogDetail::ChoosedObject);
@@ -290,12 +339,15 @@ void VToolDetail::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
         setDialog();
         dialogDetail->show();
     }
-    if(selectedAction == actionRemove){
+    if (selectedAction == actionRemove)
+    {
         //remove form xml file
         QDomElement domElement = doc->elementById(QString().setNum(id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             QDomNode element = domElement.parentNode();
-            if(!element.isNull()){
+            if (element.isNull() == false)
+            {
                 //deincrement referens
                 RemoveReferens();
                 element.removeChild(domElement);
@@ -303,102 +355,115 @@ void VToolDetail::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){
                 emit FullUpdateTree();
                 //remove form scene
                 emit RemoveTool(this);
-            } else {
+            }
+            else
+            {
                 qWarning()<<"parentNode isNull"<<Q_FUNC_INFO;
             }
-        } else {
+        }
+        else
+        {
             qWarning()<<"Can't get element by id = "<<id<<Q_FUNC_INFO;
         }
     }
 }
 
-void VToolDetail::RemoveReferens(){
+void VToolDetail::RemoveReferens()
+{
     VDetail detail = VAbstractTool::data.GetDetail(id);
-    for(qint32 i = 0; i< detail.CountNode(); ++i){
+    for (qint32 i = 0; i< detail.CountNode(); ++i)
+    {
         doc->DecrementReferens(detail[i].getId());
     }
 }
 
-void VToolDetail::AddNode(QDomElement &domElement, VNodeDetail &node){
+void VToolDetail::AddNode(QDomElement &domElement, VNodeDetail &node)
+{
     QDomElement nod = doc->createElement(TagNode);
 
     AddAttribute(nod, AttrIdObject, node.getId());
     AddAttribute(nod, AttrMx, toMM(node.getMx()));
     AddAttribute(nod, AttrMy, toMM(node.getMy()));
-    if(node.getTypeNode() == NodeDetail::Contour){
+    if (node.getTypeNode() == NodeDetail::Contour)
+    {
         AddAttribute(nod, AttrNodeType, NodeTypeContour);
-    } else {
+    }
+    else
+    {
         AddAttribute(nod, AttrNodeType, NodeTypeModeling);
     }
-    switch(node.getTypeTool()){
-    case(Tool::AlongLineTool):
-        AddAttribute(nod, AttrType, QStringLiteral("AlongLineTool"));
-        break;
-    case(Tool::ArcTool):
-        AddAttribute(nod, AttrType, QStringLiteral("ArcTool"));
-        break;
-    case(Tool::BisectorTool):
-        AddAttribute(nod, AttrType, QStringLiteral("BisectorTool"));
-        break;
-    case(Tool::EndLineTool):
-        AddAttribute(nod, AttrType, QStringLiteral("EndLineTool"));
-        break;
-    case(Tool::LineIntersectTool):
-        AddAttribute(nod, AttrType, QStringLiteral("LineIntersectTool"));
-        break;
-    case(Tool::LineTool):
-        AddAttribute(nod, AttrType, QStringLiteral("LineTool"));
-        break;
-    case(Tool::NodeArc):
-        AddAttribute(nod, AttrType, QStringLiteral("NodeArc"));
-        break;
-    case(Tool::NodePoint):
-        AddAttribute(nod, AttrType, QStringLiteral("NodePoint"));
-        break;
-    case(Tool::NodeSpline):
-        AddAttribute(nod, AttrType, QStringLiteral("NodeSpline"));
-        break;
-    case(Tool::NodeSplinePath):
-        AddAttribute(nod, AttrType, QStringLiteral("NodeSplinePath"));
-        break;
-    case(Tool::NormalTool):
-        AddAttribute(nod, AttrType, QStringLiteral("NormalTool"));
-        break;
-    case(Tool::PointOfContact):
-        AddAttribute(nod, AttrType, QStringLiteral("PointOfContact"));
-        break;
-    case(Tool::ShoulderPointTool):
-        AddAttribute(nod, AttrType, QStringLiteral("ShoulderPointTool"));
-        break;
-    case(Tool::SplinePathTool):
-        AddAttribute(nod, AttrType, QStringLiteral("SplinePathTool"));
-        break;
-    case(Tool::SplineTool):
-        AddAttribute(nod, AttrType, QStringLiteral("SplineTool"));
-        break;
-    case(Tool::Height):
-        AddAttribute(nod, AttrType, QStringLiteral("Height"));
-        break;
-    case(Tool::Triangle):
-        AddAttribute(nod, AttrType, QStringLiteral("Triangle"));
-        break;
-    case(Tool::PointOfIntersection):
-        AddAttribute(nod, AttrType, QStringLiteral("PointOfIntersection"));
-        break;
-    default:
-        qWarning()<<"May be wrong tool type!!! Ignoring."<<Q_FUNC_INFO;
-        break;
+    switch (node.getTypeTool())
+    {
+        case (Tool::AlongLineTool):
+            AddAttribute(nod, AttrType, QStringLiteral("AlongLineTool"));
+            break;
+        case (Tool::ArcTool):
+            AddAttribute(nod, AttrType, QStringLiteral("ArcTool"));
+            break;
+        case (Tool::BisectorTool):
+            AddAttribute(nod, AttrType, QStringLiteral("BisectorTool"));
+            break;
+        case (Tool::EndLineTool):
+            AddAttribute(nod, AttrType, QStringLiteral("EndLineTool"));
+            break;
+        case (Tool::LineIntersectTool):
+            AddAttribute(nod, AttrType, QStringLiteral("LineIntersectTool"));
+            break;
+        case (Tool::LineTool):
+            AddAttribute(nod, AttrType, QStringLiteral("LineTool"));
+            break;
+        case (Tool::NodeArc):
+            AddAttribute(nod, AttrType, QStringLiteral("NodeArc"));
+            break;
+        case (Tool::NodePoint):
+            AddAttribute(nod, AttrType, QStringLiteral("NodePoint"));
+            break;
+        case (Tool::NodeSpline):
+            AddAttribute(nod, AttrType, QStringLiteral("NodeSpline"));
+            break;
+        case (Tool::NodeSplinePath):
+            AddAttribute(nod, AttrType, QStringLiteral("NodeSplinePath"));
+            break;
+        case (Tool::NormalTool):
+            AddAttribute(nod, AttrType, QStringLiteral("NormalTool"));
+            break;
+        case (Tool::PointOfContact):
+            AddAttribute(nod, AttrType, QStringLiteral("PointOfContact"));
+            break;
+        case (Tool::ShoulderPointTool):
+            AddAttribute(nod, AttrType, QStringLiteral("ShoulderPointTool"));
+            break;
+        case (Tool::SplinePathTool):
+            AddAttribute(nod, AttrType, QStringLiteral("SplinePathTool"));
+            break;
+        case (Tool::SplineTool):
+            AddAttribute(nod, AttrType, QStringLiteral("SplineTool"));
+            break;
+        case (Tool::Height):
+            AddAttribute(nod, AttrType, QStringLiteral("Height"));
+            break;
+        case (Tool::Triangle):
+            AddAttribute(nod, AttrType, QStringLiteral("Triangle"));
+            break;
+        case (Tool::PointOfIntersection):
+            AddAttribute(nod, AttrType, QStringLiteral("PointOfIntersection"));
+            break;
+        default:
+            qWarning()<<"May be wrong tool type!!! Ignoring."<<Q_FUNC_INFO;
+            break;
     }
     domElement.appendChild(nod);
 }
 
-void VToolDetail::RefreshGeometry(){
+void VToolDetail::RefreshGeometry()
+{
     QPainterPath path = VAbstractTool::data.ContourPath(id);
     this->setPath(path);
 }
 
 template <typename Tool>
-void VToolDetail::InitTool(VMainGraphicsScene *scene, const VNodeDetail &node){
+void VToolDetail::InitTool(VMainGraphicsScene *scene, const VNodeDetail &node)
+{
     QHash<qint64, VDataTool*>* tools = doc->getTools();
     Q_ASSERT(tools != 0);
     Tool *tool = qobject_cast<Tool*>(tools->value(node.getId()));
diff --git a/tools/vtooldetail.h b/tools/vtooldetail.h
index 4a877e8e6..a5da79b37 100644
--- a/tools/vtooldetail.h
+++ b/tools/vtooldetail.h
@@ -26,7 +26,8 @@
 #include <QGraphicsPathItem>
 #include "dialogs/dialogdetail.h"
 
-class VToolDetail: public VAbstractTool, public QGraphicsPathItem{
+class VToolDetail: public VAbstractTool, public QGraphicsPathItem
+{
     Q_OBJECT
 public:
                                    VToolDetail(VDomDocument *doc, VContainer *data, const qint64 &id,
@@ -39,7 +40,8 @@ public:
                                           VDomDocument *doc, VContainer *data, const Document::Documents &parse,
                                           Tool::Sources typeCreation);
     template <typename T>
-    void AddTool(T *tool, const qint64 &id, Tool::Tools typeTool){
+    void AddTool(T *tool, const qint64 &id, Tool::Tools typeTool)
+    {
         tool->setParentItem(this);
         connect(tool, &T::ChoosedTool, sceneDetails, &VMainGraphicsScene::ChoosedItem);
         VNodeDetail node(id, typeTool, Draw::Modeling, NodeDetail::Modeling);
@@ -47,7 +49,8 @@ public:
         det.append(node);
         VAbstractTool::data.UpdateDetail(this->id, det);
         QDomElement domElement = doc->elementById(QString().setNum(this->id));
-        if(domElement.isElement()){
+        if (domElement.isElement())
+        {
             AddNode(domElement, node);
         }
     }
diff --git a/version.h b/version.h
index f988bb497..5a80c3c59 100644
--- a/version.h
+++ b/version.h
@@ -8,5 +8,6 @@ extern const int MINOR_VERSION = 2;
 extern const int DEBUG_VERSION = 0;
 
 extern const QString APP_VERSION(QStringLiteral("%1.%2.%3").arg(MAJOR_VERSION).arg(MINOR_VERSION).arg(DEBUG_VERSION));
-extern const QString WARRANTY(QT_TR_NOOP("The program is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE."));
+extern const QString WARRANTY(QT_TR_NOOP("The program is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE "
+                                         "WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE."));
 #endif // VERSION_H
diff --git a/widgets/doubledelegate.cpp b/widgets/doubledelegate.cpp
index 612f38b5a..480e68f0e 100644
--- a/widgets/doubledelegate.cpp
+++ b/widgets/doubledelegate.cpp
@@ -48,7 +48,8 @@
 #include "doubledelegate.h"
 
 QWidget *DoubleSpinBoxDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option,
-                                             const QModelIndex &index ) const{
+                                             const QModelIndex &index ) const
+{
     Q_UNUSED(option);
     Q_UNUSED(index);
     QDoubleSpinBox *editor = new QDoubleSpinBox(parent);
@@ -57,14 +58,16 @@ QWidget *DoubleSpinBoxDelegate::createEditor(QWidget *parent, const QStyleOption
     return editor;
 }
 
-void DoubleSpinBoxDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const{
+void DoubleSpinBoxDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
+{
     qreal value = index.model()->data(index, Qt::EditRole).toDouble();
 
     QDoubleSpinBox *spinBox = static_cast<QDoubleSpinBox*>(editor);
     spinBox->setValue(value);
 }
 
-void DoubleSpinBoxDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const{
+void DoubleSpinBoxDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
+{
     QDoubleSpinBox *spinBox = static_cast<QDoubleSpinBox*>(editor);
     spinBox->interpretText();
     qreal value = spinBox->value();
@@ -73,7 +76,8 @@ void DoubleSpinBoxDelegate::setModelData(QWidget *editor, QAbstractItemModel *mo
 }
 
 void DoubleSpinBoxDelegate::updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option,
-                                                 const QModelIndex &index) const{
+                                                 const QModelIndex &index) const
+{
     Q_UNUSED(index)
     editor->setGeometry(option.rect);
- }
+}
diff --git a/widgets/doubledelegate.h b/widgets/doubledelegate.h
index a4c7a536e..948b91851 100644
--- a/widgets/doubledelegate.h
+++ b/widgets/doubledelegate.h
@@ -43,7 +43,8 @@
 
 #include <QItemDelegate>
 
-class DoubleSpinBoxDelegate : public QItemDelegate{
+class DoubleSpinBoxDelegate : public QItemDelegate
+{
     Q_OBJECT
 public:
             DoubleSpinBoxDelegate(QObject *parent = 0): QItemDelegate(parent){}
diff --git a/widgets/vapplication.cpp b/widgets/vapplication.cpp
index e53617b6f..efabe6acb 100644
--- a/widgets/vapplication.cpp
+++ b/widgets/vapplication.cpp
@@ -27,11 +27,14 @@
 #include "exception/vexceptionwrongparameterid.h"
 
 // reimplemented from QApplication so we can throw exceptions in slots
-bool VApplication::notify(QObject *receiver, QEvent *event){
-    try {
+bool VApplication::notify(QObject *receiver, QEvent *event)
+{
+    try
+    {
       return QApplication::notify(receiver, event);
     }
-    catch(const VExceptionObjectError &e){
+    catch (const VExceptionObjectError &e)
+    {
         QMessageBox msgBox;
         msgBox.setWindowTitle(tr("Error!"));
         msgBox.setText(tr("Error parsing file. Program will be terminated."));
@@ -43,7 +46,8 @@ bool VApplication::notify(QObject *receiver, QEvent *event){
         msgBox.exec();
         abort();
     }
-    catch(const VExceptionBadId &e){
+    catch (const VExceptionBadId &e)
+    {
         QMessageBox msgBox;
         msgBox.setWindowTitle(tr("Error!"));
         msgBox.setText(tr("Error bad id. Program will be terminated."));
@@ -54,7 +58,8 @@ bool VApplication::notify(QObject *receiver, QEvent *event){
         msgBox.exec();
         abort();
     }
-    catch(const VExceptionConversionError &e){
+    catch (const VExceptionConversionError &e)
+    {
         QMessageBox msgBox;
         msgBox.setWindowTitle(tr("Error!"));
         msgBox.setText(tr("Error can't convert value. Program will be terminated."));
@@ -65,7 +70,8 @@ bool VApplication::notify(QObject *receiver, QEvent *event){
         msgBox.exec();
         abort();
     }
-    catch(const VExceptionEmptyParameter &e){
+    catch (const VExceptionEmptyParameter &e)
+    {
         QMessageBox msgBox;
         msgBox.setWindowTitle(tr("Error!"));
         msgBox.setText(tr("Error empty parameter. Program will be terminated."));
@@ -77,7 +83,8 @@ bool VApplication::notify(QObject *receiver, QEvent *event){
         msgBox.exec();
         abort();
     }
-    catch(const VExceptionWrongParameterId &e){
+    catch (const VExceptionWrongParameterId &e)
+    {
         QMessageBox msgBox;
         msgBox.setWindowTitle(tr("Error!"));
         msgBox.setText(tr("Error wrong id. Program will be terminated."));
@@ -89,7 +96,8 @@ bool VApplication::notify(QObject *receiver, QEvent *event){
         msgBox.exec();
         abort();
     }
-    catch(const VException &e){
+    catch (const VException &e)
+    {
         QMessageBox msgBox;
         msgBox.setWindowTitle(tr("Error!"));
         msgBox.setText(tr("Something wrong!!"));
@@ -99,7 +107,8 @@ bool VApplication::notify(QObject *receiver, QEvent *event){
         msgBox.setIcon(QMessageBox::Critical);
         msgBox.exec();
     }
-    catch(std::exception& e) {
+    catch (std::exception& e)
+    {
       qCritical() << "Exception thrown:" << e.what();
     }
     return false;
diff --git a/widgets/vapplication.h b/widgets/vapplication.h
index 3192cb658..145c5cac8 100644
--- a/widgets/vapplication.h
+++ b/widgets/vapplication.h
@@ -3,7 +3,8 @@
 
 #include <QApplication>
 
-class VApplication : public QApplication{
+class VApplication : public QApplication
+{
     Q_OBJECT
 public:
     VApplication(int &argc, char ** argv): QApplication(argc, argv){}
diff --git a/widgets/vcontrolpointspline.cpp b/widgets/vcontrolpointspline.cpp
index 4e3e378b9..5b25e4d86 100644
--- a/widgets/vcontrolpointspline.cpp
+++ b/widgets/vcontrolpointspline.cpp
@@ -23,8 +23,9 @@
 
 VControlPointSpline::VControlPointSpline(const qint32 &indexSpline, SplinePoint::Position position,
                                          const QPointF &controlPoint, const QPointF &splinePoint,
-                                         QGraphicsItem *parent):QGraphicsEllipseItem(parent),
-    radius(toPixel(1.5)), controlLine(0), indexSpline(indexSpline), position(position){
+                                         QGraphicsItem *parent)
+    :QGraphicsEllipseItem(parent), radius(toPixel(1.5)), controlLine(0), indexSpline(indexSpline), position(position)
+{
     //create circle
     QRectF rec = QRectF(0, 0, radius*2, radius*2);
     rec.translate(-rec.center().x(), -rec.center().y());
@@ -45,18 +46,22 @@ VControlPointSpline::VControlPointSpline(const qint32 &indexSpline, SplinePoint:
     controlLine->setFlag(QGraphicsItem::ItemStacksBehindParent, true);
 }
 
-void VControlPointSpline::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VControlPointSpline::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(Qt::black, widthMainLine));
 }
 
-void VControlPointSpline::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VControlPointSpline::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setPen(QPen(Qt::black, widthHairLine));
 }
 
-QVariant VControlPointSpline::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value){
-    if (change == ItemPositionChange && scene()) {
+QVariant VControlPointSpline::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value)
+{
+    if (change == ItemPositionChange && scene())
+    {
         // value - new position.
         QPointF newPos = value.toPointF();
         emit ControlPointChangePosition(indexSpline, position, newPos);
@@ -65,7 +70,8 @@ QVariant VControlPointSpline::itemChange(QGraphicsItem::GraphicsItemChange chang
 }
 
 qint32 VControlPointSpline::LineIntersectCircle(QPointF center, qreal radius, QLineF line, QPointF &p1,
-                                                QPointF &p2) const{
+                                                QPointF &p2) const
+{
     const qreal eps = 1e-8;
     //коефіцієнти для рівняння відрізку
     qreal a = line.p2().y() - line.p1().y();
@@ -77,12 +83,18 @@ qint32 VControlPointSpline::LineIntersectCircle(QPointF center, qreal radius, QL
     // сколько всего решений?
     qint32 flag = 0;
     qreal d = QLineF (center, p).length();
-    if (qAbs (d - radius) <= eps){
+    if (qAbs (d - radius) <= eps)
+    {
         flag = 1;
-    } else {
-        if (radius > d){
+    }
+    else
+    {
+        if (radius > d)
+        {
             flag = 2;
-        } else {
+        }
+        else
+        {
             return 0;
         }
     }
@@ -95,17 +107,22 @@ qint32 VControlPointSpline::LineIntersectCircle(QPointF center, qreal radius, QL
     return flag;
 }
 
-QPointF VControlPointSpline::ClosestPoint(QLineF line, QPointF p) const{
+QPointF VControlPointSpline::ClosestPoint(QLineF line, QPointF p) const
+{
     QLineF lineP2pointFrom = QLineF(line.p2(), p);
     qreal angle = 180-line.angleTo(lineP2pointFrom)-90;
     QLineF pointFromlineP2 = QLineF(p, line.p2());
     pointFromlineP2.setAngle(pointFromlineP2.angle()+angle);
     QPointF point;
-    QLineF::IntersectType type = pointFromlineP2.intersect(line,&point);
-    if ( type == QLineF::BoundedIntersection ){
+    QLineF::IntersectType type = pointFromlineP2.intersect(line, &point);
+    if ( type == QLineF::BoundedIntersection )
+    {
         return point;
-    } else{
-        if ( type == QLineF::NoIntersection || type == QLineF::UnboundedIntersection ){
+    }
+    else
+    {
+        if ( type == QLineF::NoIntersection || type == QLineF::UnboundedIntersection )
+        {
             Q_ASSERT_X(type != QLineF::BoundedIntersection, Q_FUNC_INFO, "Немає точки перетину.");
             return point;
         }
@@ -113,26 +130,33 @@ QPointF VControlPointSpline::ClosestPoint(QLineF line, QPointF p) const{
     return point;
 }
 
-QPointF VControlPointSpline::addVector(QPointF p, QPointF p1, QPointF p2, qreal k) const{
+QPointF VControlPointSpline::addVector(QPointF p, QPointF p1, QPointF p2, qreal k) const
+{
     return QPointF (p.x() + (p2.x() - p1.x()) * k, p.y() + (p2.y() - p1.y()) * k);
 }
 
 void VControlPointSpline::RefreshLine(const qint32 &indexSpline, SplinePoint::Position pos,
-                                      const QPointF &controlPoint, const QPointF &splinePoint){
-    if(this->indexSpline == indexSpline && this->position == pos){
+                                      const QPointF &controlPoint, const QPointF &splinePoint)
+{
+    if (this->indexSpline == indexSpline && this->position == pos)
+    {
         QPointF p1, p2;
         LineIntersectCircle(QPointF(), radius, QLineF( QPointF(), splinePoint-controlPoint), p1, p2);
         controlLine->setLine(QLineF(splinePoint-controlPoint, p1));
     }
 }
 
-void VControlPointSpline::setEnabledPoint(bool enable){
-    if(enable == true){
+void VControlPointSpline::setEnabledPoint(bool enable)
+{
+    if (enable == true)
+    {
         this->setPen(QPen(Qt::black, widthHairLine));
         this->setFlag(QGraphicsItem::ItemIsSelectable, true);
         this->setFlag(QGraphicsItem::ItemIsMovable, true);
         this->setAcceptHoverEvents(true);
-    } else {
+    }
+    else
+    {
         this->setPen(QPen(Qt::gray, widthHairLine));
         this->setFlag(QGraphicsItem::ItemIsSelectable, false);
         this->setFlag(QGraphicsItem::ItemIsMovable, false);
diff --git a/widgets/vcontrolpointspline.h b/widgets/vcontrolpointspline.h
index 9ed7e1cbb..56f51ef93 100644
--- a/widgets/vcontrolpointspline.h
+++ b/widgets/vcontrolpointspline.h
@@ -26,7 +26,8 @@
 #include <QObject>
 #include "geometry/vsplinepath.h"
 
-class VControlPointSpline : public QObject, public QGraphicsEllipseItem{
+class VControlPointSpline : public QObject, public QGraphicsEllipseItem
+{
     Q_OBJECT
 public:
                       VControlPointSpline(const qint32 &indexSpline, SplinePoint::Position position,
diff --git a/widgets/vgraphicssimpletextitem.cpp b/widgets/vgraphicssimpletextitem.cpp
index 52a74973e..55fa10187 100644
--- a/widgets/vgraphicssimpletextitem.cpp
+++ b/widgets/vgraphicssimpletextitem.cpp
@@ -21,8 +21,9 @@
 
 #include "vgraphicssimpletextitem.h"
 
-VGraphicsSimpleTextItem::VGraphicsSimpleTextItem(QGraphicsItem * parent):QGraphicsSimpleTextItem(parent),
-    fontSize(0){
+VGraphicsSimpleTextItem::VGraphicsSimpleTextItem(QGraphicsItem * parent)
+    :QGraphicsSimpleTextItem(parent), fontSize(0)
+{
     this->setFlag(QGraphicsItem::ItemIsMovable, true);
     this->setFlag(QGraphicsItem::ItemIsSelectable, true);
     this->setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
@@ -34,27 +35,32 @@ VGraphicsSimpleTextItem::VGraphicsSimpleTextItem(QGraphicsItem * parent):QGraphi
 }
 
 VGraphicsSimpleTextItem::VGraphicsSimpleTextItem( const QString & text, QGraphicsItem * parent )
-    :QGraphicsSimpleTextItem(text, parent), fontSize(0){
+    :QGraphicsSimpleTextItem(text, parent), fontSize(0)
+{
     this->setFlag(QGraphicsItem::ItemIsMovable, true);
     this->setFlag(QGraphicsItem::ItemIsSelectable, true);
     this->setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
     this->setAcceptHoverEvents(true);
 }
 
-QVariant VGraphicsSimpleTextItem::itemChange(GraphicsItemChange change, const QVariant &value){
-     if (change == ItemPositionChange && scene()) {
+QVariant VGraphicsSimpleTextItem::itemChange(GraphicsItemChange change, const QVariant &value)
+{
+     if (change == ItemPositionChange && scene())
+     {
          QPointF newPos = value.toPointF() + this->parentItem()->pos();
          emit NameChangePosition(newPos);
      }
      return QGraphicsItem::itemChange(change, value);
 }
 
-void VGraphicsSimpleTextItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event){
+void VGraphicsSimpleTextItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setBrush(Qt::green);
 }
 
-void VGraphicsSimpleTextItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event){
+void VGraphicsSimpleTextItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
     Q_UNUSED(event);
     this->setBrush(Qt::black);
 }
diff --git a/widgets/vgraphicssimpletextitem.h b/widgets/vgraphicssimpletextitem.h
index 61bcd9471..dacf920ce 100644
--- a/widgets/vgraphicssimpletextitem.h
+++ b/widgets/vgraphicssimpletextitem.h
@@ -24,7 +24,8 @@
 
 #include <QGraphicsSimpleTextItem>
 
-class VGraphicsSimpleTextItem : public QObject, public QGraphicsSimpleTextItem{
+class VGraphicsSimpleTextItem : public QObject, public QGraphicsSimpleTextItem
+{
     Q_OBJECT
 public:
                  VGraphicsSimpleTextItem(QGraphicsItem * parent = 0);
diff --git a/widgets/vitem.cpp b/widgets/vitem.cpp
index d9b508003..963a693da 100644
--- a/widgets/vitem.cpp
+++ b/widgets/vitem.cpp
@@ -21,29 +21,37 @@
 
 #include "vitem.h"
 
-VItem::VItem (const QPainterPath & path, int numInList, QGraphicsItem * parent ):
-    QGraphicsPathItem ( path, parent ), numInOutList(numInList){
+VItem::VItem (const QPainterPath & path, int numInList, QGraphicsItem * parent )
+    :QGraphicsPathItem ( path, parent ), numInOutList(numInList)
+{
 }
 
-void VItem::checkItemChange(){
+void VItem::checkItemChange()
+{
     QRectF rect = parentItem()->sceneBoundingRect();
     QRectF myrect = sceneBoundingRect();
-    if( rect.contains( myrect )==true ){
+    if ( rect.contains( myrect )==true )
+    {
         qDebug()<<"Не виходить за рамки листа";
         setPen(QPen(Qt::black, widthMainLine));
         emit itemOut( numInOutList, false );
-    } else {
+    }
+    else
+    {
         qDebug()<<"Виходить за рамки листа";
         setPen(QPen(Qt::red, widthMainLine));
         emit itemOut( numInOutList, true );
     }
     QList<QGraphicsItem *> list = QGraphicsItem::collidingItems ();
-    if( list.size() - 2 > 0 ){
+    if ( list.size() - 2 > 0 )
+    {
         list.append( this );
         setPen(QPen(Qt::red, widthMainLine));
         qDebug()<<"Деталь перетинається з іншими деталями "<<numInOutList;
         emit itemColliding( list, 1 );//Деталь перетинається з іншими деталями.
-    } else {
+    }
+    else
+    {
         QList<QGraphicsItem *> itemList;
         itemList.append( this );
         qDebug()<<"Деталь більше не перетинається з іншими деталями "<<numInOutList;
@@ -52,18 +60,22 @@ void VItem::checkItemChange(){
     //qDebug()<<"list="<<list.size();
 }
 
-QVariant VItem::itemChange( GraphicsItemChange change, const QVariant &value ){
-    if ( change == QGraphicsItem::ItemPositionHasChanged && scene() ) {
+QVariant VItem::itemChange( GraphicsItemChange change, const QVariant &value )
+{
+    if ( change == QGraphicsItem::ItemPositionHasChanged && scene() )
+    {
         checkItemChange();
         return QGraphicsPathItem::itemChange( change, value );
     }
-    if ( change == QGraphicsItem::ItemParentHasChanged && scene() ) {
+    if ( change == QGraphicsItem::ItemParentHasChanged && scene() )
+    {
         checkItemChange();
         return QGraphicsPathItem::itemChange( change, value );
     }
     return QGraphicsPathItem::itemChange( change, value );
 }
 
-void VItem::LengthChanged(){
+void VItem::LengthChanged()
+{
     checkItemChange();
 }
diff --git a/widgets/vitem.h b/widgets/vitem.h
index ccf47413f..cff2136c8 100644
--- a/widgets/vitem.h
+++ b/widgets/vitem.h
@@ -28,7 +28,8 @@
 /**
  * @brief VItem клас, що реалізує деталь на сцені.
  */
-class VItem : public QObject, public QGraphicsPathItem{
+class VItem : public QObject, public QGraphicsPathItem
+{
     Q_OBJECT
 public:
     /**
diff --git a/widgets/vmaingraphicsscene.cpp b/widgets/vmaingraphicsscene.cpp
index dc3010ca0..91fc1d32f 100644
--- a/widgets/vmaingraphicsscene.cpp
+++ b/widgets/vmaingraphicsscene.cpp
@@ -21,28 +21,31 @@
 
 #include "vmaingraphicsscene.h"
 
-VMainGraphicsScene::VMainGraphicsScene():QGraphicsScene(), horScrollBar(0), verScrollBar(0), scaleFactor(1){
-}
+VMainGraphicsScene::VMainGraphicsScene()
+    :QGraphicsScene(), horScrollBar(0), verScrollBar(0), scaleFactor(1){}
 
-VMainGraphicsScene::VMainGraphicsScene(const QRectF & sceneRect, QObject * parent):
-    QGraphicsScene ( sceneRect, parent ), horScrollBar(0), verScrollBar(0), scaleFactor(1){
-}
+VMainGraphicsScene::VMainGraphicsScene(const QRectF & sceneRect, QObject * parent)
+    :QGraphicsScene ( sceneRect, parent ), horScrollBar(0), verScrollBar(0), scaleFactor(1){}
 
-void VMainGraphicsScene::mouseMoveEvent(QGraphicsSceneMouseEvent* event){
+void VMainGraphicsScene::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
+{
     emit mouseMove(event->scenePos());
     QGraphicsScene::mouseMoveEvent(event);
 }
 
-void VMainGraphicsScene::mousePressEvent(QGraphicsSceneMouseEvent *event){
+void VMainGraphicsScene::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
     emit mousePress(event->scenePos());
     QGraphicsScene::mousePressEvent(event);
 }
 
-void VMainGraphicsScene::ChoosedItem(qint64 id, Scene::Scenes type){
+void VMainGraphicsScene::ChoosedItem(qint64 id, Scene::Scenes type)
+{
     emit ChoosedObject(id, type);
 }
 
-void VMainGraphicsScene::SetFactor(qreal factor){
+void VMainGraphicsScene::SetFactor(qreal factor)
+{
     scaleFactor=scaleFactor*factor;
     emit NewFactor(scaleFactor);
 }
diff --git a/widgets/vmaingraphicsscene.h b/widgets/vmaingraphicsscene.h
index 63522396e..0f3cb116d 100644
--- a/widgets/vmaingraphicsscene.h
+++ b/widgets/vmaingraphicsscene.h
@@ -24,7 +24,8 @@
 
 #include <QGraphicsScene>
 
-class VMainGraphicsScene : public QGraphicsScene{
+class VMainGraphicsScene : public QGraphicsScene
+{
     Q_OBJECT
 public:
                   VMainGraphicsScene();
diff --git a/widgets/vmaingraphicsview.cpp b/widgets/vmaingraphicsview.cpp
index acfca1764..9aab81ce1 100644
--- a/widgets/vmaingraphicsview.cpp
+++ b/widgets/vmaingraphicsview.cpp
@@ -21,18 +21,21 @@
 
 #include "vmaingraphicsview.h"
 
-VMainGraphicsView::VMainGraphicsView(QWidget *parent) :
-    QGraphicsView(parent), _numScheduledScalings(0){
+VMainGraphicsView::VMainGraphicsView(QWidget *parent)
+    :QGraphicsView(parent), _numScheduledScalings(0)
+{
     this->setResizeAnchor(QGraphicsView::AnchorUnderMouse);
     this->setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
     this->setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
 }
 
-void VMainGraphicsView::wheelEvent(QWheelEvent *event){
+void VMainGraphicsView::wheelEvent(QWheelEvent *event)
+{
     int numDegrees = event->delta() / 8;
     int numSteps = numDegrees / 15;  // see QWheelEvent documentation
     _numScheduledScalings += numSteps;
-    if (_numScheduledScalings * numSteps < 0){  // if user moved the wheel in another direction, we reset
+    if (_numScheduledScalings * numSteps < 0)
+    {  // if user moved the wheel in another direction, we reset
         _numScheduledScalings = numSteps;       // previously scheduled scalings
     }
 
@@ -44,49 +47,65 @@ void VMainGraphicsView::wheelEvent(QWheelEvent *event){
     anim->start();
 }
 
-void VMainGraphicsView::scalingTime(qreal x){
+void VMainGraphicsView::scalingTime(qreal x)
+{
     Q_UNUSED(x);
     qreal factor = 1.0 + qreal(_numScheduledScalings) / 300.0;
-    if (QApplication::keyboardModifiers() == Qt::ControlModifier){// If you press CTRL this code will execute
+    if (QApplication::keyboardModifiers() == Qt::ControlModifier)
+    {// If you press CTRL this code will execute
         scale(factor, factor);
         emit NewFactor(factor);
-    } else {
-        if(_numScheduledScalings < 0){
+    }
+    else
+    {
+        if (_numScheduledScalings < 0)
+        {
             verticalScrollBar()->setValue(qRound(verticalScrollBar()->value() + factor*3.5));
             emit NewFactor(factor);
-        } else {
-            if(verticalScrollBar()->value() > 0){
+        }
+        else
+        {
+            if (verticalScrollBar()->value() > 0)
+            {
                 verticalScrollBar()->setValue(qRound(verticalScrollBar()->value() - factor*3.5));
                 emit NewFactor(factor);
             }
         }
-    }   
+    }
 }
 
-void VMainGraphicsView::animFinished(){
-    if (_numScheduledScalings > 0){
+void VMainGraphicsView::animFinished()
+{
+    if (_numScheduledScalings > 0)
+    {
         _numScheduledScalings--;
-    } else {
+    }
+    else
+    {
         _numScheduledScalings++;
     }
     sender()->~QObject();
 }
 
-void VMainGraphicsView::mousePressEvent(QMouseEvent *mousePress){
-    if(mousePress->button() & Qt::LeftButton){
-        switch(QGuiApplication::keyboardModifiers()){
-        case Qt::ControlModifier:
-            QGraphicsView::setDragMode(QGraphicsView::ScrollHandDrag);
-            QGraphicsView::mousePressEvent(mousePress);
-            break;
-        default:
-            QGraphicsView::mousePressEvent(mousePress);
-            break;
+void VMainGraphicsView::mousePressEvent(QMouseEvent *mousePress)
+{
+    if (mousePress->button() & Qt::LeftButton)
+    {
+        switch (QGuiApplication::keyboardModifiers())
+        {
+            case Qt::ControlModifier:
+                QGraphicsView::setDragMode(QGraphicsView::ScrollHandDrag);
+                QGraphicsView::mousePressEvent(mousePress);
+                break;
+            default:
+                QGraphicsView::mousePressEvent(mousePress);
+                break;
         }
     }
 }
 
-void VMainGraphicsView::mouseReleaseEvent(QMouseEvent *event){
+void VMainGraphicsView::mouseReleaseEvent(QMouseEvent *event)
+{
     QGraphicsView::mouseReleaseEvent ( event );
     QGraphicsView::setDragMode( QGraphicsView::RubberBandDrag );
 }
diff --git a/widgets/vmaingraphicsview.h b/widgets/vmaingraphicsview.h
index d0035c7de..f4ad052ef 100644
--- a/widgets/vmaingraphicsview.h
+++ b/widgets/vmaingraphicsview.h
@@ -24,7 +24,8 @@
 
 #include <QGraphicsView>
 
-class VMainGraphicsView : public QGraphicsView{
+class VMainGraphicsView : public QGraphicsView
+{
     Q_OBJECT
 public:
     explicit VMainGraphicsView(QWidget *parent = 0);
diff --git a/widgets/vtablegraphicsview.cpp b/widgets/vtablegraphicsview.cpp
index 609bb1ec3..c6716255e 100644
--- a/widgets/vtablegraphicsview.cpp
+++ b/widgets/vtablegraphicsview.cpp
@@ -21,27 +21,35 @@
 
 #include "vtablegraphicsview.h"
 
-VTableGraphicsView::VTableGraphicsView(QGraphicsScene* pScene, QWidget *parent) :
-    QGraphicsView(pScene, parent){
+VTableGraphicsView::VTableGraphicsView(QGraphicsScene* pScene, QWidget *parent)
+    :QGraphicsView(pScene, parent)
+{
     QGraphicsView::setResizeAnchor(QGraphicsView::AnchorUnderMouse);
     connect(pScene, &QGraphicsScene::selectionChanged, this, &VTableGraphicsView::selectionChanged);
 }
 
-void VTableGraphicsView::selectionChanged(){
+void VTableGraphicsView::selectionChanged()
+{
     QList<QGraphicsItem *> listSelectedItems = scene()->selectedItems();
-    if( listSelectedItems.isEmpty() == true ){
+    if ( listSelectedItems.isEmpty() == true )
+    {
         qDebug() << tr("detail don't find");
         emit itemChect(true);
-    } else {
+    }
+    else
+    {
         qDebug() << tr("detail find");
         emit itemChect(false);
     }
 }
 
-void VTableGraphicsView::MirrorItem(){
+void VTableGraphicsView::MirrorItem()
+{
     QList<QGraphicsItem *> list = scene()->selectedItems();
-    if(list.size()>0){
-        for( qint32 i = 0; i < list.count(); ++i ){
+    if (list.size()>0)
+    {
+        for ( qint32 i = 0; i < list.count(); ++i )
+        {
             QRectF itemRectOld = list.at(i)->sceneBoundingRect();
             //Get the current transform
             QTransform transform(list.at(i)->transform());
@@ -73,92 +81,112 @@ void VTableGraphicsView::MirrorItem(){
     }
 }
 
-void VTableGraphicsView::wheelEvent(QWheelEvent *event){
-    if (QGuiApplication::keyboardModifiers() == Qt::ControlModifier){
+void VTableGraphicsView::wheelEvent(QWheelEvent *event)
+{
+    if (QGuiApplication::keyboardModifiers() == Qt::ControlModifier)
+    {
         // Если нажата клавиша CTRL этот код выполнится
-        if ((event->delta())>0){
+        if ((event->delta())>0)
+        {
             ZoomIn();
-        } else if ((event->delta())<0){
+        }
+        else if ((event->delta())<0)
+        {
             ZoomOut();
         }
-    } else {
+    }
+    else
+    {
        verticalScrollBar()->setValue(verticalScrollBar()->value()-event->delta());
     }
 }
 
-void VTableGraphicsView::mousePressEvent(QMouseEvent *mousePress){
-    if(mousePress->button() & Qt::LeftButton){
-        switch(QGuiApplication::keyboardModifiers()){
-        case Qt::ControlModifier:
-            QGraphicsView::setDragMode(QGraphicsView::ScrollHandDrag);
-            QGraphicsView::mousePressEvent(mousePress);
-            break;
-        default:
-            QGraphicsView::mousePressEvent(mousePress);
-            break;
+void VTableGraphicsView::mousePressEvent(QMouseEvent *mousePress)
+{
+    if (mousePress->button() & Qt::LeftButton)
+    {
+        switch (QGuiApplication::keyboardModifiers())
+        {
+            case Qt::ControlModifier:
+                QGraphicsView::setDragMode(QGraphicsView::ScrollHandDrag);
+                QGraphicsView::mousePressEvent(mousePress);
+                break;
+            default:
+                QGraphicsView::mousePressEvent(mousePress);
+                break;
         }
     }
 }
 
-void VTableGraphicsView::mouseReleaseEvent(QMouseEvent *event){
+void VTableGraphicsView::mouseReleaseEvent(QMouseEvent *event)
+{
     QGraphicsView::mouseReleaseEvent ( event );
     QGraphicsView::setDragMode( QGraphicsView::RubberBandDrag );
 }
 
-void VTableGraphicsView::keyPressEvent(QKeyEvent *event){
-    switch(event->key()){
-    case Qt::Key_Space:
-        rotateIt();
-        break;
-    case Qt::Key_Left:
-        MoveItem(VTableGraphicsView::Left);
-        break;
-    case Qt::Key_Right:
-        MoveItem(VTableGraphicsView::Right);
-        break;
-    case Qt::Key_Up:
-        MoveItem(VTableGraphicsView::Up);
-        break;
-    case Qt::Key_Down:
-        MoveItem(VTableGraphicsView::Down);
-        break;
+void VTableGraphicsView::keyPressEvent(QKeyEvent *event)
+{
+    switch (event->key())
+    {
+        case Qt::Key_Space:
+            rotateIt();
+            break;
+        case Qt::Key_Left:
+            MoveItem(VTableGraphicsView::Left);
+            break;
+        case Qt::Key_Right:
+            MoveItem(VTableGraphicsView::Right);
+            break;
+        case Qt::Key_Up:
+            MoveItem(VTableGraphicsView::Up);
+            break;
+        case Qt::Key_Down:
+            MoveItem(VTableGraphicsView::Down);
+            break;
     }
     QGraphicsView::keyPressEvent ( event );
 }
 
-void VTableGraphicsView::rotateIt(){
+void VTableGraphicsView::rotateIt()
+{
     QList<QGraphicsItem *> list = scene()->selectedItems();
-    if(list.size()>0){
-        for( qint32 i = 0; i < list.count(); ++i ){
+    if (list.size()>0)
+    {
+        for ( qint32 i = 0; i < list.count(); ++i )
+        {
             list.at(i)->setTransformOriginPoint(list.at(i)->boundingRect().center());
             list.at(i)->setRotation(list.at(i)->rotation() + 180);
         }
     }
 }
 
-void VTableGraphicsView::MoveItem(VTableGraphicsView::typeMove_e move){
+void VTableGraphicsView::MoveItem(VTableGraphicsView::typeMove_e move)
+{
     qreal dx = 0, dy = 0;
-    switch(move){
-    case VTableGraphicsView::Left:
-        dx = -3;
-        dy = 0;
-        break;
-    case VTableGraphicsView::Right:
-        dx = 3;
-        dy = 0;
-        break;
-    case VTableGraphicsView::Up:
-        dx = 0;
-        dy = -3;
-        break;
-    case VTableGraphicsView::Down:
-        dx = 0;
-        dy = 3;
-        break;
+    switch (move)
+    {
+        case VTableGraphicsView::Left:
+            dx = -3;
+            dy = 0;
+            break;
+        case VTableGraphicsView::Right:
+            dx = 3;
+            dy = 0;
+            break;
+        case VTableGraphicsView::Up:
+            dx = 0;
+            dy = -3;
+            break;
+        case VTableGraphicsView::Down:
+            dx = 0;
+            dy = 3;
+            break;
     }
     QList<QGraphicsItem *> listSelectedItems = scene()->selectedItems();
-    if(listSelectedItems.size()>0){
-        for( qint32 i = 0; i < listSelectedItems.count(); ++i ){
+    if (listSelectedItems.size()>0)
+    {
+        for ( qint32 i = 0; i < listSelectedItems.count(); ++i )
+        {
             listSelectedItems.at(i)->moveBy(dx, dy);
         }
     }
diff --git a/widgets/vtablegraphicsview.h b/widgets/vtablegraphicsview.h
index 8b52ac2a7..3f78d7f4f 100644
--- a/widgets/vtablegraphicsview.h
+++ b/widgets/vtablegraphicsview.h
@@ -24,7 +24,8 @@
 
 #include <QGraphicsView>
 
-class VTableGraphicsView : public QGraphicsView{
+class VTableGraphicsView : public QGraphicsView
+{
     Q_OBJECT
 public:
     enum typeMove_e { Left, Right, Up, Down };
@@ -51,11 +52,11 @@ public slots:
     /**
      * @brief ZoomIn збільшує масштаб листа.
      */
-    inline void ZoomIn() {scale(1.1,1.1);}
+    inline void ZoomIn() {scale(1.1, 1.1);}
     /**
      * @brief ZoomOut зменшує масштаб листа.
      */
-    inline void ZoomOut() {scale(1/1.1,1/1.1);}
+    inline void ZoomOut() {scale(1/1.1, 1/1.1);}
 protected:
     /**
      * @brief wheelEvent обробник повороту колеса мишки.
diff --git a/xml/vdomdocument.cpp b/xml/vdomdocument.cpp
index 7dc3e5807..76c73c831 100644
--- a/xml/vdomdocument.cpp
+++ b/xml/vdomdocument.cpp
@@ -34,57 +34,64 @@
 #include <tools/nodeDetails/vnodesplinepath.h>
 #include <tools/nodeDetails/vnodearc.h>
 
-VDomDocument::VDomDocument(VContainer *data, QComboBox *comboBoxDraws, Draw::Draws *mode) : QDomDocument(),
-    map(QHash<QString, QDomElement>()), nameActivDraw(QString()), data(data),
+VDomDocument::VDomDocument(VContainer *data, QComboBox *comboBoxDraws, Draw::Draws *mode)
+    : QDomDocument(), map(QHash<QString, QDomElement>()), nameActivDraw(QString()), data(data),
     tools(QHash<qint64, VDataTool*>()), history(QVector<VToolRecord>()), cursor(0),
-    comboBoxDraws(comboBoxDraws), mode(mode){
-}
+    comboBoxDraws(comboBoxDraws), mode(mode){}
 
 VDomDocument::VDomDocument(const QString& name, VContainer *data, QComboBox *comboBoxDraws,
-                           Draw::Draws *mode) :
-    QDomDocument(name), map(QHash<QString, QDomElement>()), nameActivDraw(QString()), data(data),
+                           Draw::Draws *mode)
+    :QDomDocument(name), map(QHash<QString, QDomElement>()), nameActivDraw(QString()), data(data),
     tools(QHash<qint64, VDataTool*>()), history(QVector<VToolRecord>()), cursor(0),
-    comboBoxDraws(comboBoxDraws), mode(mode){
-}
+    comboBoxDraws(comboBoxDraws), mode(mode){}
 
 VDomDocument::VDomDocument(const QDomDocumentType& doctype, VContainer *data, QComboBox *comboBoxDraws,
-                           Draw::Draws *mode) :
-    QDomDocument(doctype), map(QHash<QString, QDomElement>()), nameActivDraw(QString()), data(data),
+                           Draw::Draws *mode)
+    :QDomDocument(doctype), map(QHash<QString, QDomElement>()), nameActivDraw(QString()), data(data),
     tools(QHash<qint64, VDataTool*>()), history(QVector<VToolRecord>()), cursor(0),
-    comboBoxDraws(comboBoxDraws), mode(mode){
-}
+    comboBoxDraws(comboBoxDraws), mode(mode){}
 
-QDomElement VDomDocument::elementById(const QString& id){
-    if (map.contains(id)) {
+QDomElement VDomDocument::elementById(const QString& id)
+{
+    if (map.contains(id))
+    {
        QDomElement e = map[id];
-       if (e.parentNode().nodeType() != QDomNode::BaseNode) {
+       if (e.parentNode().nodeType() != QDomNode::BaseNode)
+       {
            return e;
        }
        map.remove(id);
     }
 
     bool res = this->find(this->documentElement(), id);
-    if (res) {
+    if (res)
+    {
        return map[id];
     }
 
     return QDomElement();
 }
 
-bool VDomDocument::find(QDomElement node, const QString& id){
-    if (node.hasAttribute("id")) {
+bool VDomDocument::find(QDomElement node, const QString& id)
+{
+    if (node.hasAttribute("id"))
+    {
         QString value = node.attribute("id");
         this->map[value] = node;
-        if (value == id) {
+        if (value == id)
+        {
             return true;
         }
     }
 
-    for (qint32 i=0; i<node.childNodes().length(); ++i) {
+    for (qint32 i=0; i<node.childNodes().length(); ++i)
+    {
         QDomNode n = node.childNodes().at(i);
-        if (n.isElement()) {
+        if (n.isElement())
+        {
             bool res = this->find(n.toElement(), id);
-            if (res) {
+            if (res)
+            {
                 return true;
             }
         }
@@ -93,7 +100,8 @@ bool VDomDocument::find(QDomElement node, const QString& id){
     return false;
 }
 
-void VDomDocument::CreateEmptyFile(){
+void VDomDocument::CreateEmptyFile()
+{
     QDomElement domElement = this->createElement("lekalo");
     this->appendChild(domElement);
     QDomNode xmlNode = this->createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\"");
@@ -102,17 +110,22 @@ void VDomDocument::CreateEmptyFile(){
     domElement.appendChild(incrElement);
 }
 
-bool VDomDocument::CheckNameDraw(const QString& name) const{
-    Q_ASSERT_X(!name.isEmpty(), "CheckNameDraw", "name draw is empty");
+bool VDomDocument::CheckNameDraw(const QString& name) const
+{
+    Q_ASSERT_X(name.isEmpty() == false, "CheckNameDraw", "name draw is empty");
     QDomNodeList elements = this->documentElement().elementsByTagName( "draw" );
-    if(elements.size() == 0){
+    if (elements.size() == 0)
+    {
         return false;
     }
-    for ( qint32 i = 0; i < elements.count(); i++ ){
+    for ( qint32 i = 0; i < elements.count(); i++ )
+    {
         QDomElement elem = elements.at( i ).toElement();
-        if(!elem.isNull()){
+        if (elem.isNull() == false)
+        {
             QString fieldName = elem.attribute( "name" );
-            if ( fieldName == name ){
+            if ( fieldName == name )
+            {
                 return true;
             }
         }
@@ -120,12 +133,15 @@ bool VDomDocument::CheckNameDraw(const QString& name) const{
     return false;
 }
 
-bool VDomDocument::appendDraw(const QString& name){
-    Q_ASSERT_X(!name.isEmpty(), "appendDraw", "name draw is empty");
-    if(name.isEmpty()){
+bool VDomDocument::appendDraw(const QString& name)
+{
+    Q_ASSERT_X(name.isEmpty() == false, "appendDraw", "name draw is empty");
+    if (name.isEmpty())
+    {
         return false;
     }
-    if(CheckNameDraw(name)== false){
+    if (CheckNameDraw(name)== false)
+    {
         QDomElement rootElement = this->documentElement();
 
         QDomElement drawElement = this->createElement("draw");
@@ -142,60 +158,79 @@ bool VDomDocument::appendDraw(const QString& name){
 
         rootElement.appendChild(drawElement);
 
-        if(nameActivDraw.isEmpty()){
+        if (nameActivDraw.isEmpty())
+        {
             SetActivDraw(name);
-        } else {
+        }
+        else
+        {
             ChangeActivDraw(name);
         }
         return true;
-    } else {
+    }
+    else
+    {
         return false;
     }
     return false;
 }
 
-void VDomDocument::ChangeActivDraw(const QString& name, Document::Documents parse){
-    Q_ASSERT_X(!name.isEmpty(), "ChangeActivDraw", "name draw is empty");
-    if(CheckNameDraw(name) == true){
+void VDomDocument::ChangeActivDraw(const QString& name, Document::Documents parse)
+{
+    Q_ASSERT_X(name.isEmpty() == false, "ChangeActivDraw", "name draw is empty");
+    if (CheckNameDraw(name) == true)
+    {
         this->nameActivDraw = name;
-        if(parse == Document::FullParse){
+        if (parse == Document::FullParse)
+        {
             emit ChangedActivDraw(name);
         }
     }
 }
 
-bool VDomDocument::SetNameDraw(const QString& name){
-    Q_ASSERT_X(!name.isEmpty(), "SetNameDraw", "name draw is empty");
+bool VDomDocument::SetNameDraw(const QString& name)
+{
+    Q_ASSERT_X(name.isEmpty() == false, "SetNameDraw", "name draw is empty");
     QString oldName = nameActivDraw;
     QDomElement element;
-    if(GetActivDrawElement(element)){
+    if (GetActivDrawElement(element))
+    {
         nameActivDraw = name;
         element.setAttribute("name", nameActivDraw);
         emit haveChange();
         emit ChangedNameDraw(oldName, nameActivDraw);
         return true;
-    } else {
+    }
+    else
+    {
         qWarning()<<"Can't find activ draw"<<Q_FUNC_INFO;
         return false;
     }
 }
 
-void VDomDocument::SetActivDraw(const QString& name){
-    Q_ASSERT_X(!name.isEmpty(), "SetActivDraw", "name draw is empty");
+void VDomDocument::SetActivDraw(const QString& name)
+{
+    Q_ASSERT_X(name.isEmpty() == false, "SetActivDraw", "name draw is empty");
     this->nameActivDraw = name;
 }
 
-bool VDomDocument::GetActivDrawElement(QDomElement &element){
-    if(!nameActivDraw.isEmpty()){
+bool VDomDocument::GetActivDrawElement(QDomElement &element)
+{
+    if (nameActivDraw.isEmpty() == false)
+    {
         QDomNodeList elements = this->documentElement().elementsByTagName( "draw" );
-        if(elements.size() == 0){
+        if (elements.size() == 0)
+        {
             return false;
         }
-        for ( qint32 i = 0; i < elements.count(); i++ ){
+        for ( qint32 i = 0; i < elements.count(); i++ )
+        {
             element = elements.at( i ).toElement();
-            if(!element.isNull()){
+            if (element.isNull() == false)
+            {
                 QString fieldName = element.attribute( "name" );
-                if ( fieldName == nameActivDraw ){
+                if ( fieldName == nameActivDraw )
+                {
                     return true;
                 }
             }
@@ -204,58 +239,79 @@ bool VDomDocument::GetActivDrawElement(QDomElement &element){
     return false;
 }
 
-bool VDomDocument::GetActivCalculationElement(QDomElement &element){
+bool VDomDocument::GetActivCalculationElement(QDomElement &element)
+{
     bool ok = GetActivNodeElement("calculation", element);
-    if(ok){
+    if (ok)
+    {
         return true;
-    } else {
+    }
+    else
+    {
         return false;
     }
 }
 
-bool VDomDocument::GetActivModelingElement(QDomElement &element){
+bool VDomDocument::GetActivModelingElement(QDomElement &element)
+{
     bool ok = GetActivNodeElement("modeling", element);
-    if(ok){
+    if (ok)
+    {
         return true;
-    } else {
+    }
+    else
+    {
         return false;
     }
 }
 
-bool VDomDocument::GetActivDetailsElement(QDomElement &element){
+bool VDomDocument::GetActivDetailsElement(QDomElement &element)
+{
     bool ok = GetActivNodeElement("details", element);
-    if(ok){
+    if (ok)
+    {
         return true;
-    } else {
+    }
+    else
+    {
         return false;
     }
 }
 
-bool VDomDocument::GetActivNodeElement(const QString& name, QDomElement &element){
-    Q_ASSERT_X(!name.isEmpty(), "GetActivNodeElement", "name draw is empty");
+bool VDomDocument::GetActivNodeElement(const QString& name, QDomElement &element)
+{
+    Q_ASSERT_X(name.isEmpty() == false, "GetActivNodeElement", "name draw is empty");
     QDomElement drawElement;
     bool drawOk = this->GetActivDrawElement(drawElement);
-    if(drawOk == true){
+    if (drawOk == true)
+    {
         QDomNodeList listElement = drawElement.elementsByTagName(name);
-        if(listElement.size() == 0 || listElement.size() > 1){
+        if (listElement.size() == 0 || listElement.size() > 1)
+        {
             return false;
         }
         element = listElement.at( 0 ).toElement();
-        if(!element.isNull()){
+        if (element.isNull() == false)
+        {
             return true;
-        } else {
+        }
+        else
+        {
             return false;
         }
-    } else {
+    }
+    else
+    {
         return false;
     }
 }
 
-void VDomDocument::Parse(Document::Documents parse, VMainGraphicsScene *sceneDraw,
-                         VMainGraphicsScene *sceneDetail){
+void VDomDocument::Parse(Document::Documents parse, VMainGraphicsScene *sceneDraw, VMainGraphicsScene *sceneDetail)
+{
     Q_ASSERT(sceneDraw != 0);
     Q_ASSERT(sceneDetail != 0);
-    if(parse == Document::FullParse){
+    if (parse == Document::FullParse)
+    {
         TestUniqueId();
         data->Clear();
         nameActivDraw.clear();
@@ -272,24 +328,35 @@ void VDomDocument::Parse(Document::Documents parse, VMainGraphicsScene *sceneDra
     history.clear();
     QDomElement rootElement = this->documentElement();
     QDomNode domNode = rootElement.firstChild();
-    while(!domNode.isNull()){
-        if(domNode.isElement()){
+    while (domNode.isNull() == false)
+    {
+        if (domNode.isElement())
+        {
             QDomElement domElement = domNode.toElement();
-            if(!domElement.isNull()){
-                if(domElement.tagName()=="draw"){
-                    if(parse == Document::FullParse){
-                        if(nameActivDraw.isEmpty()){
+            if (domElement.isNull() == false)
+            {
+                if (domElement.tagName()=="draw")
+                {
+                    if (parse == Document::FullParse)
+                    {
+                        if (nameActivDraw.isEmpty())
+                        {
                             SetActivDraw(domElement.attribute("name"));
-                        } else {
+                        }
+                        else
+                        {
                             ChangeActivDraw(domElement.attribute("name"));
                         }
                         comboBoxDraws->addItem(domElement.attribute("name"));
-                    } else {
+                    }
+                    else
+                    {
                         ChangeActivDraw(domElement.attribute("name"), Document::LiteParse);
                     }
                     ParseDrawElement(sceneDraw, sceneDetail, domElement, parse);
                 }
-                if(domElement.tagName()=="increments"){
+                if (domElement.tagName()=="increments")
+                {
                     ParseIncrementsElement(domElement);
                 }
             }
@@ -298,13 +365,18 @@ void VDomDocument::Parse(Document::Documents parse, VMainGraphicsScene *sceneDra
     }
 }
 
-void VDomDocument::ParseIncrementsElement(const QDomNode &node){
+void VDomDocument::ParseIncrementsElement(const QDomNode &node)
+{
     QDomNode domNode = node.firstChild();
-    while(!domNode.isNull()){
-        if(domNode.isElement()){
+    while (domNode.isNull() == false)
+    {
+        if (domNode.isElement())
+        {
             QDomElement domElement = domNode.toElement();
-            if(!domElement.isNull()){
-                if(domElement.tagName() == "increment"){
+            if (domElement.isNull() == false)
+            {
+                if (domElement.tagName() == "increment")
+                {
                     qint64 id = GetParametrId(domElement);
                     QString name = GetParametrString(domElement, "name");
                     qreal base = GetParametrDouble(domElement, "base");
@@ -321,86 +393,107 @@ void VDomDocument::ParseIncrementsElement(const QDomNode &node){
     }
 }
 
-qint64 VDomDocument::GetParametrId(const QDomElement &domElement) const{
-    Q_ASSERT_X(!domElement.isNull(), Q_FUNC_INFO, "domElement is null");
+qint64 VDomDocument::GetParametrId(const QDomElement &domElement) const
+{
+    Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
     qint64 id = GetParametrLongLong(domElement, "id");
-    if(id <= 0){
+    if (id <= 0)
+    {
         throw VExceptionWrongParameterId(tr("Got wrong parameter id. Need only id > 0."), domElement);
     }
     return id;
 }
 
-qint64 VDomDocument::GetParametrLongLong(const QDomElement &domElement, const QString &name) const{
-    Q_ASSERT_X(!name.isEmpty(), Q_FUNC_INFO, "name of parametr is empty");
-    Q_ASSERT_X(!domElement.isNull(), Q_FUNC_INFO, "domElement is null");
+qint64 VDomDocument::GetParametrLongLong(const QDomElement &domElement, const QString &name) const
+{
+    Q_ASSERT_X(name.isEmpty() == false, Q_FUNC_INFO, "name of parametr is empty");
+    Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
     bool ok = false;
     QString parametr = GetParametrString(domElement, name);
     qint64 id = parametr.toLongLong(&ok);
-    if(ok == false){
+    if (ok == false)
+    {
         throw VExceptionConversionError(tr("Can't convert toLongLong parameter"), name);
     }
     return id;
 }
 
-QString VDomDocument::GetParametrString(const QDomElement &domElement, const QString &name) const{
-    Q_ASSERT_X(!name.isEmpty(), Q_FUNC_INFO, "name of parametr is empty");
-    Q_ASSERT_X(!domElement.isNull(), Q_FUNC_INFO, "domElement is null");
+QString VDomDocument::GetParametrString(const QDomElement &domElement, const QString &name) const
+{
+    Q_ASSERT_X(name.isEmpty() == false, Q_FUNC_INFO, "name of parametr is empty");
+    Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
     QString parameter = domElement.attribute(name, "");
-    if(parameter.isEmpty()){
+    if (parameter.isEmpty())
+    {
         throw VExceptionEmptyParameter(tr("Got empty parameter"), name, domElement);
     }
     return parameter;
 }
 
-qreal VDomDocument::GetParametrDouble(const QDomElement &domElement, const QString &name) const{
-    Q_ASSERT_X(!name.isEmpty(), Q_FUNC_INFO, "name of parametr is empty");
-    Q_ASSERT_X(!domElement.isNull(), Q_FUNC_INFO, "domElement is null");
+qreal VDomDocument::GetParametrDouble(const QDomElement &domElement, const QString &name) const
+{
+    Q_ASSERT_X(name.isEmpty() == false, Q_FUNC_INFO, "name of parametr is empty");
+    Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
     bool ok = false;
     QString parametr = GetParametrString(domElement, name);
     qreal param = parametr.replace(",", ".").toDouble(&ok);
-    if(ok == false){
+    if (ok == false)
+    {
         throw VExceptionConversionError(tr("Can't convert toDouble parameter"), name);
     }
     return param;
 }
 
-void VDomDocument::TestUniqueId() const{
+void VDomDocument::TestUniqueId() const
+{
     QVector<qint64> vector;
     CollectId(this->documentElement(), vector);
 }
 
-void VDomDocument::CollectId(QDomElement node, QVector<qint64> &vector) const{
-    if (node.hasAttribute("id")) {
+void VDomDocument::CollectId(QDomElement node, QVector<qint64> &vector) const
+{
+    if (node.hasAttribute("id"))
+    {
         qint64 id = GetParametrId(node);
-        if(vector.contains(id)){
+        if (vector.contains(id))
+        {
             throw VExceptionUniqueId(tr("This id is not unique."), node);
         }
         vector.append(id);
     }
 
-    for (qint32 i=0; i<node.childNodes().length(); ++i) {
+    for (qint32 i=0; i<node.childNodes().length(); ++i)
+    {
         QDomNode n = node.childNodes().at(i);
-        if (n.isElement()) {
+        if (n.isElement())
+        {
             CollectId(n.toElement(), vector);
         }
     }
 }
 
 void VDomDocument::ParseDrawElement(VMainGraphicsScene *sceneDraw, VMainGraphicsScene *sceneDetail,
-                                    const QDomNode& node, const Document::Documents &parse){
+                                    const QDomNode& node, const Document::Documents &parse)
+{
     QDomNode domNode = node.firstChild();
-    while(!domNode.isNull()){
-        if(domNode.isElement()){
+    while (domNode.isNull() == false)
+    {
+        if (domNode.isElement())
+        {
             QDomElement domElement = domNode.toElement();
-            if(!domElement.isNull()){
-                if(domElement.tagName() == "calculation"){
+            if (domElement.isNull() == false)
+            {
+                if (domElement.tagName() == "calculation")
+                {
                     data->ClearObject();
                     ParseDrawMode(sceneDraw, sceneDetail, domElement, parse, Draw::Calculation);
                 }
-                if(domElement.tagName() == "modeling"){
+                if (domElement.tagName() == "modeling")
+                {
                     ParseDrawMode(sceneDraw, sceneDetail, domElement, parse, Draw::Modeling);
                 }
-                if(domElement.tagName() == "details"){
+                if (domElement.tagName() == "details")
+                {
                     ParseDetails(sceneDetail, domElement, parse);
                 }
             }
@@ -410,34 +503,43 @@ void VDomDocument::ParseDrawElement(VMainGraphicsScene *sceneDraw, VMainGraphics
 }
 
 void VDomDocument::ParseDrawMode(VMainGraphicsScene *sceneDraw, VMainGraphicsScene *sceneDetail,
-                                 const QDomNode& node, const Document::Documents &parse,
-                                 Draw::Draws mode){
+                                 const QDomNode& node, const Document::Documents &parse, Draw::Draws mode)
+{
     Q_ASSERT(sceneDraw != 0);
     Q_ASSERT(sceneDetail != 0);
     VMainGraphicsScene *scene = 0;
-    if(mode == Draw::Calculation){
+    if (mode == Draw::Calculation)
+    {
         scene = sceneDraw;
-    } else {
+    }
+    else
+    {
         scene = sceneDetail;
     }
     QDomNodeList nodeList = node.childNodes();
     qint32 num = nodeList.size();
-    for(qint32 i = 0; i < num; ++i){
+    for (qint32 i = 0; i < num; ++i)
+    {
         QDomElement domElement = nodeList.at(i).toElement();
-        if(!domElement.isNull()){
-            if(domElement.tagName() == "point"){
+        if (domElement.isNull() == false)
+        {
+            if (domElement.tagName() == "point")
+            {
                 ParsePointElement(scene, domElement, parse, domElement.attribute("type", ""), mode);
                 continue;
             }
-            if(domElement.tagName() == "line"){
+            if (domElement.tagName() == "line")
+            {
                 ParseLineElement(scene, domElement, parse, mode);
                 continue;
             }
-            if(domElement.tagName() == "spline"){
+            if (domElement.tagName() == "spline")
+            {
                 ParseSplineElement(scene, domElement, parse, domElement.attribute("type", ""), mode);
                 continue;
             }
-            if(domElement.tagName() == "arc"){
+            if (domElement.tagName() == "arc")
+            {
                 ParseArcElement(scene, domElement, parse, domElement.attribute("type", ""), mode);
                 continue;
             }
@@ -446,10 +548,12 @@ void VDomDocument::ParseDrawMode(VMainGraphicsScene *sceneDraw, VMainGraphicsSce
 }
 
 void VDomDocument::ParseDetailElement(VMainGraphicsScene *sceneDetail, const QDomElement &domElement,
-                                      const Document::Documents &parse){
+                                      const Document::Documents &parse)
+{
     Q_ASSERT(sceneDetail != 0);
-    Q_ASSERT_X(!domElement.isNull(), Q_FUNC_INFO, "domElement is null");
-    try{
+    Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
+    try
+    {
         VDetail detail;
         VDetail oldDetail;
         qint64 id = GetParametrId(domElement);
@@ -462,10 +566,13 @@ void VDomDocument::ParseDetailElement(VMainGraphicsScene *sceneDetail, const QDo
 
         QDomNodeList nodeList = domElement.childNodes();
         qint32 num = nodeList.size();
-        for(qint32 i = 0; i < num; ++i){
+        for (qint32 i = 0; i < num; ++i)
+        {
             QDomElement element = nodeList.at(i).toElement();
-            if(!element.isNull()){
-                if(element.tagName() == "node"){
+            if (element.isNull() == false)
+            {
+                if (element.tagName() == "node")
+                {
                     qint64 id = GetParametrLongLong(element, "idObject");
                     qreal mx = toPixel(GetParametrDouble(element, "mx"));
                     qreal my = toPixel(GetParametrDouble(element, "my"));
@@ -473,53 +580,88 @@ void VDomDocument::ParseDetailElement(VMainGraphicsScene *sceneDetail, const QDo
                     Draw::Draws mode;
                     NodeDetail::NodeDetails nodeType = NodeDetail::Contour;
                     QString t = GetParametrString(element, "type");
-                    if(t == "NodePoint"){
+                    if (t == "NodePoint")
+                    {
                         tool = Tool::NodePoint;
                         VPointF point = data->GetModelingPoint(id);
                         mode = point.getMode();
                         oldDetail.append(VNodeDetail(point.getIdObject(), tool, mode, NodeDetail::Contour));
-                    } else if(t == "NodeArc"){
+                    }
+                    else if (t == "NodeArc")
+                    {
                         tool = Tool::NodeArc;
                         VArc arc = data->GetModelingArc(id);
                         mode = arc.getMode();
                         oldDetail.append(VNodeDetail(arc.getIdObject(), tool, mode, NodeDetail::Contour));
-                    } else if(t == "NodeSpline"){
+                    }
+                    else if (t == "NodeSpline")
+                    {
                         tool = Tool::NodeSpline;
                         VSpline spl = data->GetModelingSpline(id);
                         mode = spl.getMode();
                         oldDetail.append(VNodeDetail(spl.getIdObject(), tool, mode, NodeDetail::Contour));
-                    } else if(t == "NodeSplinePath"){
+                    }
+                    else if (t == "NodeSplinePath")
+                    {
                         tool = Tool::NodeSplinePath;
                         VSplinePath splPath = data->GetModelingSplinePath(id);
                         mode = splPath.getMode();
                         oldDetail.append(VNodeDetail(splPath.getIdObject(), tool, mode, NodeDetail::Contour));
-                    } else if(t == "AlongLineTool"){
+                    }
+                    else if (t == "AlongLineTool")
+                    {
                         tool = Tool::AlongLineTool;
-                    } else if(t == "ArcTool"){
+                    }
+                    else if (t == "ArcTool")
+                    {
                         tool = Tool::ArcTool;
-                    } else if(t == "BisectorTool"){
+                    }
+                    else if (t == "BisectorTool")
+                    {
                         tool = Tool::BisectorTool;
-                    } else if(t == "EndLineTool"){
+                    }
+                    else if (t == "EndLineTool")
+                    {
                         tool = Tool::EndLineTool;
-                    } else if(t == "LineIntersectTool"){
+                    }
+                    else if (t == "LineIntersectTool")
+                    {
                         tool = Tool::LineIntersectTool;
-                    } else if(t == "LineTool"){
+                    }
+                    else if (t == "LineTool")
+                    {
                         tool = Tool::LineTool;
-                    } else if(t == "NormalTool"){
+                    }
+                    else if (t == "NormalTool")
+                    {
                         tool = Tool::NormalTool;
-                    } else if(t == "PointOfContact"){
+                    }
+                    else if (t == "PointOfContact")
+                    {
                         tool = Tool::PointOfContact;
-                    } else if(t == "ShoulderPointTool"){
+                    }
+                    else if (t == "ShoulderPointTool")
+                    {
                         tool = Tool::ShoulderPointTool;
-                    } else if(t == "SplinePathTool"){
+                    }
+                    else if (t == "SplinePathTool")
+                    {
                         tool = Tool::SplinePathTool;
-                    } else if(t == "SplineTool"){
+                    }
+                    else if (t == "SplineTool")
+                    {
                         tool = Tool::SplineTool;
-                    } else if(t == "Height"){
+                    }
+                    else if (t == "Height")
+                    {
                         tool = Tool::Height;
-                    } else if(t == "Triangle"){
+                    }
+                    else if (t == "Triangle")
+                    {
                         tool = Tool::Triangle;
-                    } else if(t == "PointOfIntersection"){
+                    }
+                    else if (t == "PointOfIntersection")
+                    {
                         tool = Tool::PointOfIntersection;
                     }
                     detail.append(VNodeDetail(id, tool, Draw::Modeling, nodeType, mx, my));
@@ -528,7 +670,8 @@ void VDomDocument::ParseDetailElement(VMainGraphicsScene *sceneDetail, const QDo
         }
         VToolDetail::Create(id, detail, sceneDetail, this, data, parse, Tool::FromFile);
     }
-    catch(const VExceptionBadId &e){
+    catch (const VExceptionBadId &e)
+    {
         VExceptionObjectError excep(tr("Error creating or updating detail"), domElement);
         excep.AddMoreInformation(e.ErrorMessage());
         throw excep;
@@ -536,15 +679,20 @@ void VDomDocument::ParseDetailElement(VMainGraphicsScene *sceneDetail, const QDo
 }
 
 void VDomDocument::ParseDetails(VMainGraphicsScene *sceneDetail, const QDomElement &domElement,
-                                const Document::Documents &parse){
+                                const Document::Documents &parse)
+{
     Q_ASSERT(sceneDetail != 0);
-    Q_ASSERT_X(!domElement.isNull(), Q_FUNC_INFO, "domElement is null");
+    Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
     QDomNode domNode = domElement.firstChild();
-    while(!domNode.isNull()){
-        if(domNode.isElement()){
+    while (domNode.isNull() == false)
+    {
+        if (domNode.isElement())
+        {
             QDomElement domElement = domNode.toElement();
-            if(!domElement.isNull()){
-                if(domElement.tagName() == "detail"){
+            if (domElement.isNull() == false)
+            {
+                if (domElement.tagName() == "detail")
+                {
                     ParseDetailElement(sceneDetail, domElement, parse);
                 }
             }
@@ -554,13 +702,15 @@ void VDomDocument::ParseDetails(VMainGraphicsScene *sceneDetail, const QDomEleme
 }
 
 void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElement& domElement,
-                                     const Document::Documents &parse, const QString& type,
-                                     Draw::Draws mode){
+                                     const Document::Documents &parse, const QString& type, Draw::Draws mode)
+{
     Q_ASSERT(scene != 0);
-    Q_ASSERT_X(!domElement.isNull(), Q_FUNC_INFO, "domElement is null");
-    Q_ASSERT_X(!type.isEmpty(), Q_FUNC_INFO, "type of point is empty");
-    if(type == "single"){
-        try{
+    Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
+    Q_ASSERT_X(type.isEmpty() == false, Q_FUNC_INFO, "type of point is empty");
+    if (type == "single")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             QString name = GetParametrString(domElement, "name");
             qreal x = toPixel(GetParametrDouble(domElement, "x"));
@@ -570,10 +720,12 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
 
             data->UpdatePoint(id, VPointF(x, y, name, mx, my));
             VDrawTool::AddRecord(id, Tool::SinglePointTool, this);
-            if(parse != Document::FullParse){
+            if (parse != Document::FullParse)
+            {
                 UpdateToolData(id, data);
             }
-            if(parse == Document::FullParse){
+            if (parse == Document::FullParse)
+            {
                 VToolSinglePoint *spoint = new VToolSinglePoint(this, data, id, Tool::FromFile);
                 Q_ASSERT(spoint != 0);
                 scene->addItem(spoint);
@@ -583,14 +735,17 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
             }
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating single point"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "endLine"){
-        try{
+    if (type == "endLine")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             QString name = GetParametrString(domElement, "name");
             qreal mx = toPixel(GetParametrDouble(domElement, "mx"));
@@ -599,23 +754,29 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
             QString formula = GetParametrString(domElement, "length");
             qint64 basePointId = GetParametrLongLong(domElement, "basePoint");
             qreal angle = GetParametrDouble(domElement, "angle");
-            if(mode == Draw::Calculation){
+            if (mode == Draw::Calculation)
+            {
                 VToolEndLine::Create(id, name, typeLine, formula, angle, basePointId, mx, my, scene, this,
                                      data, parse, Tool::FromFile);
-            } else {
+            }
+            else
+            {
                 VModelingEndLine::Create(id, name, typeLine, formula, angle, basePointId, mx, my, this,
                                          data, parse, Tool::FromFile);
             }
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating point of end line"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "alongLine"){
-        try{
+    if (type == "alongLine")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             QString name = GetParametrString(domElement, "name");
             qreal mx = toPixel(GetParametrDouble(domElement, "mx"));
@@ -625,23 +786,29 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
             qint64 firstPointId = GetParametrLongLong(domElement, "firstPoint");
             qint64 secondPointId = GetParametrLongLong(domElement, "secondPoint");
 
-            if(mode == Draw::Calculation){
+            if (mode == Draw::Calculation)
+            {
                 VToolAlongLine::Create(id, name, typeLine, formula, firstPointId, secondPointId, mx, my,
                                        scene, this, data, parse, Tool::FromFile);
-            } else {
+            }
+            else
+            {
                 VModelingAlongLine::Create(id, name, typeLine, formula, firstPointId, secondPointId, mx, my,
                                            this, data, parse, Tool::FromFile);
             }
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating point along line"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "shoulder"){
-        try{
+    if (type == "shoulder")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             QString name = GetParametrString(domElement, "name");
             qreal mx = toPixel(GetParametrDouble(domElement, "mx"));
@@ -652,23 +819,29 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
             qint64 p2Line = GetParametrLongLong(domElement, "p2Line");
             qint64 pShoulder = GetParametrLongLong(domElement, "pShoulder");
 
-            if(mode == Draw::Calculation){
+            if (mode == Draw::Calculation)
+            {
                 VToolShoulderPoint::Create(id, formula, p1Line, p2Line, pShoulder, typeLine, name, mx, my,
                                            scene, this, data, parse, Tool::FromFile);
-            } else {
+            }
+            else
+            {
                 VModelingShoulderPoint::Create(id, formula, p1Line, p2Line, pShoulder, typeLine, name, mx,
                                                my, this, data, parse, Tool::FromFile);
             }
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating point of shoulder"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "normal"){
-        try{
+    if (type == "normal")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             QString name = GetParametrString(domElement, "name");
             qreal mx = toPixel(GetParametrDouble(domElement, "mx"));
@@ -679,23 +852,29 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
             qint64 secondPointId = GetParametrLongLong(domElement, "secondPoint");
             qreal angle = GetParametrDouble(domElement, "angle");
 
-            if(mode == Draw::Calculation){
+            if (mode == Draw::Calculation)
+            {
                 VToolNormal::Create(id, formula, firstPointId, secondPointId, typeLine, name, angle,
                                     mx, my, scene, this, data, parse, Tool::FromFile);
-            } else {
+            }
+            else
+            {
                 VModelingNormal::Create(id, formula, firstPointId, secondPointId, typeLine, name, angle,
                                         mx, my, this, data, parse, Tool::FromFile);
             }
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating point of normal"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "bisector"){
-        try{
+    if (type == "bisector")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             QString name = GetParametrString(domElement, "name");
             qreal mx = toPixel(GetParametrDouble(domElement, "mx"));
@@ -706,23 +885,29 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
             qint64 secondPointId = GetParametrLongLong(domElement, "secondPoint");
             qint64 thirdPointId = GetParametrLongLong(domElement, "thirdPoint");
 
-            if(mode == Draw::Calculation){
+            if (mode == Draw::Calculation)
+            {
                 VToolBisector::Create(id, formula, firstPointId, secondPointId, thirdPointId, typeLine,
                                       name, mx, my, scene, this, data, parse, Tool::FromFile);
-            } else {
+            }
+            else
+            {
                 VModelingBisector::Create(id, formula, firstPointId, secondPointId, thirdPointId, typeLine,
                                           name, mx, my, this, data, parse, Tool::FromFile);
             }
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating point of bisector"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "lineIntersect"){
-        try{
+    if (type == "lineIntersect")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             QString name = GetParametrString(domElement, "name");
             qreal mx = toPixel(GetParametrDouble(domElement, "mx"));
@@ -732,23 +917,29 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
             qint64 p1Line2Id = GetParametrLongLong(domElement, "p1Line2");
             qint64 p2Line2Id = GetParametrLongLong(domElement, "p2Line2");
 
-            if(mode == Draw::Calculation){
+            if (mode == Draw::Calculation)
+            {
                 VToolLineIntersect::Create(id, p1Line1Id, p2Line1Id, p1Line2Id, p2Line2Id, name, mx, my,
                                            scene, this, data, parse, Tool::FromFile);
-            } else {
+            }
+            else
+            {
                 VModelingLineIntersect::Create(id, p1Line1Id, p2Line1Id, p1Line2Id, p2Line2Id, name, mx, my,
                                                this, data, parse, Tool::FromFile);
             }
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating point of lineintersection"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "pointOfContact"){
-        try{
+    if (type == "pointOfContact")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             QString name = GetParametrString(domElement, "name");
             qreal mx = toPixel(GetParametrDouble(domElement, "mx"));
@@ -758,32 +949,41 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
             qint64 firstPointId = GetParametrLongLong(domElement, "firstPoint");
             qint64 secondPointId = GetParametrLongLong(domElement, "secondPoint");
 
-            if(mode == Draw::Calculation){
+            if (mode == Draw::Calculation)
+            {
                 VToolPointOfContact::Create(id, radius, center, firstPointId, secondPointId, name, mx, my,
                                             scene, this, data, parse, Tool::FromFile);
-            } else {
+            }
+            else
+            {
                 VModelingPointOfContact::Create(id, radius, center, firstPointId, secondPointId, name, mx,
                                                 my, this, data, parse, Tool::FromFile);
             }
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating point of contact"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "modeling"){
-        try{
+    if (type == "modeling")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             qint64 idObject = GetParametrLongLong(domElement, "idObject");
             QString tObject = GetParametrString(domElement, "typeObject");
             VPointF point;
             Draw::Draws typeObject;
-            if(tObject == "Calculation"){
+            if (tObject == "Calculation")
+            {
                 typeObject = Draw::Calculation;
                 point = data->GetPoint(idObject );
-            } else {
+            }
+            else
+            {
                 typeObject = Draw::Modeling;
                 point = data->GetModelingPoint(idObject);
             }
@@ -794,14 +994,17 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
             VNodePoint::Create(this, data, id, idObject, mode, parse, Tool::FromFile);
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating modeling point"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "height"){
-        try{
+    if (type == "height")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             QString name = GetParametrString(domElement, "name");
             qreal mx = toPixel(GetParametrDouble(domElement, "mx"));
@@ -810,23 +1013,29 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
             qint64 basePointId = GetParametrLongLong(domElement, "basePoint");
             qint64 p1LineId = GetParametrLongLong(domElement, "p1Line");
             qint64 p2LineId = GetParametrLongLong(domElement, "p2Line");
-            if(mode == Draw::Calculation){
+            if (mode == Draw::Calculation)
+            {
                 VToolHeight::Create(id, name, typeLine, basePointId, p1LineId, p2LineId, mx, my, scene,
                                     this, data, parse, Tool::FromFile);
-            } else {
+            }
+            else
+            {
                 VModelingHeight::Create(id, name, typeLine,  basePointId, p1LineId, p2LineId, mx, my, this,
                                         data, parse, Tool::FromFile);
             }
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating height"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "triangle"){
-        try{
+    if (type == "triangle")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             QString name = GetParametrString(domElement, "name");
             qreal mx = toPixel(GetParametrDouble(domElement, "mx"));
@@ -836,23 +1045,29 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
             qint64 firstPointId = GetParametrLongLong(domElement, "firstPoint");
             qint64 secondPointId = GetParametrLongLong(domElement, "secondPoint");
 
-            if(mode == Draw::Calculation){
+            if (mode == Draw::Calculation)
+            {
                 VToolTriangle::Create(id, name, axisP1Id, axisP2Id, firstPointId, secondPointId, mx, my,
                                       scene, this, data, parse, Tool::FromFile);
-            } else {
+            }
+            else
+            {
                 VModelingTriangle::Create(id, name, axisP1Id, axisP2Id, firstPointId, secondPointId, mx, my,
                                           this, data, parse, Tool::FromFile);
             }
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating triangle"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "pointOfIntersection"){
-        try{
+    if (type == "pointOfIntersection")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             QString name = GetParametrString(domElement, "name");
             qreal mx = toPixel(GetParametrDouble(domElement, "mx"));
@@ -860,16 +1075,20 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
             qint64 firstPointId = GetParametrLongLong(domElement, "firstPoint");
             qint64 secondPointId = GetParametrLongLong(domElement, "secondPoint");
 
-            if(mode == Draw::Calculation){
+            if (mode == Draw::Calculation)
+            {
                 VToolPointOfIntersection::Create(id, name, firstPointId, secondPointId, mx, my, scene, this, data,
                                                  parse, Tool::FromFile);
-            } else {
+            }
+            else
+            {
                 VModelingPointOfIntersection::Create(id, name, firstPointId, secondPointId, mx, my, this, data,
                                                      parse, Tool::FromFile);
             }
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating point of intersection"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
@@ -878,22 +1097,28 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen
 }
 
 void VDomDocument::ParseLineElement(VMainGraphicsScene *scene, const QDomElement &domElement,
-                                    const Document::Documents &parse, Draw::Draws mode){
+                                    const Document::Documents &parse, Draw::Draws mode)
+{
     Q_ASSERT(scene != 0);
-    Q_ASSERT_X(!domElement.isNull(), Q_FUNC_INFO, "domElement is null");
-    try{
+    Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
+    try
+    {
         qint64 id = GetParametrId(domElement);
         qint64 firstPoint = GetParametrLongLong(domElement, "firstPoint");
         qint64 secondPoint = GetParametrLongLong(domElement, "secondPoint");
 
-        if(mode == Draw::Calculation){
+        if (mode == Draw::Calculation)
+        {
             VToolLine::Create(id, firstPoint, secondPoint, scene, this, data, parse, Tool::FromFile);
-        } else {
+        }
+        else
+        {
             VModelingLine::Create(id, firstPoint, secondPoint, this, data, parse, Tool::FromFile);
         }
 
     }
-    catch(const VExceptionBadId &e){
+    catch (const VExceptionBadId &e)
+    {
         VExceptionObjectError excep(tr("Error creating or updating line"), domElement);
         excep.AddMoreInformation(e.ErrorMessage());
         throw excep;
@@ -901,13 +1126,15 @@ void VDomDocument::ParseLineElement(VMainGraphicsScene *scene, const QDomElement
 }
 
 void VDomDocument::ParseSplineElement(VMainGraphicsScene *scene, const QDomElement &domElement,
-                                      const Document::Documents &parse, const QString &type,
-                                      Draw::Draws mode){
+                                      const Document::Documents &parse, const QString &type, Draw::Draws mode)
+{
     Q_ASSERT(scene != 0);
-    Q_ASSERT_X(!domElement.isNull(), Q_FUNC_INFO, "domElement is null");
-    Q_ASSERT_X(!type.isEmpty(), Q_FUNC_INFO, "type of spline is empty");
-    if(type == "simple"){
-        try{
+    Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
+    Q_ASSERT_X(type.isEmpty() == false, Q_FUNC_INFO, "type of spline is empty");
+    if (type == "simple")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             qint64 point1 = GetParametrLongLong(domElement, "point1");
             qint64 point4 = GetParametrLongLong(domElement, "point4");
@@ -917,70 +1144,89 @@ void VDomDocument::ParseSplineElement(VMainGraphicsScene *scene, const QDomEleme
             qreal kAsm2 = GetParametrDouble(domElement, "kAsm2");
             qreal kCurve = GetParametrDouble(domElement, "kCurve");
 
-            if(mode == Draw::Calculation){
+            if (mode == Draw::Calculation)
+            {
                 VToolSpline::Create(id, point1, point4, kAsm1, kAsm2, angle1, angle2, kCurve, scene, this,
                                     data, parse, Tool::FromFile);
-            } else {
+            }
+            else
+            {
                 VModelingSpline::Create(id, point1, point4, kAsm1, kAsm2, angle1, angle2, kCurve, this,
                                         data, parse, Tool::FromFile);
             }
 
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating simple curve"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "path"){
-        try{
+    if (type == "path")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             qreal kCurve = GetParametrDouble(domElement, "kCurve");
             VSplinePath path(data->DataPoints(), kCurve);
 
             QDomNodeList nodeList = domElement.childNodes();
             qint32 num = nodeList.size();
-            for(qint32 i = 0; i < num; ++i){
+            for (qint32 i = 0; i < num; ++i)
+            {
                 QDomElement element = nodeList.at(i).toElement();
-                if(!element.isNull()){
-                    if(element.tagName() == "pathPoint"){
+                if (element.isNull() == false)
+                {
+                    if (element.tagName() == "pathPoint")
+                    {
                         qreal kAsm1 = GetParametrDouble(element, "kAsm1");
                         qreal angle = GetParametrDouble(element, "angle");
                         qreal kAsm2 = GetParametrDouble(element, "kAsm2");
                         qint64 pSpline = GetParametrLongLong(element, "pSpline");
                         VSplinePoint splPoint(pSpline, kAsm1, angle, kAsm2);
                         path.append(splPoint);
-                        if(parse == Document::FullParse){
+                        if (parse == Document::FullParse)
+                        {
                             IncrementReferens(pSpline);
                         }
                     }
                 }
             }
-            if(mode == Draw::Calculation){
+            if (mode == Draw::Calculation)
+            {
                 VToolSplinePath::Create(id, path, scene, this, data, parse, Tool::FromFile);
-            } else {
+            }
+            else
+            {
                 VModelingSplinePath::Create(id, path, this, data, parse, Tool::FromFile);
             }
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating curve path"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "modelingSpline"){
-        try{
+    if (type == "modelingSpline")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             qint64 idObject = GetParametrLongLong(domElement, "idObject");
             QString tObject = GetParametrString(domElement, "typeObject");
             VSpline spl;
             Draw::Draws typeObject;
-            if(tObject == "Calculation"){
+            if (tObject == "Calculation")
+            {
                 typeObject = Draw::Calculation;
                 spl = data->GetSpline(idObject);
-            } else {
+            }
+            else
+            {
                 typeObject = Draw::Modeling;
                 spl = data->GetModelingSpline(idObject);
             }
@@ -990,23 +1236,29 @@ void VDomDocument::ParseSplineElement(VMainGraphicsScene *scene, const QDomEleme
             VNodeSpline::Create(this, data, id, idObject, mode, parse, Tool::FromFile);
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating modeling simple curve"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "modelingPath"){
-        try{
+    if (type == "modelingPath")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             qint64 idObject = GetParametrLongLong(domElement, "idObject");
             QString tObject = GetParametrString(domElement, "typeObject");
             VSplinePath path;
             Draw::Draws typeObject;
-            if(tObject == "Calculation"){
+            if (tObject == "Calculation")
+            {
                 typeObject = Draw::Calculation;
                 path = data->GetSplinePath(idObject);
-            } else {
+            }
+            else
+            {
                 typeObject = Draw::Modeling;
                 path = data->GetModelingSplinePath(idObject);
             }
@@ -1016,7 +1268,8 @@ void VDomDocument::ParseSplineElement(VMainGraphicsScene *scene, const QDomEleme
             VNodeSplinePath::Create(this, data, id, idObject, mode, parse, Tool::FromFile);
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating modeling curve path"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
@@ -1025,43 +1278,55 @@ void VDomDocument::ParseSplineElement(VMainGraphicsScene *scene, const QDomEleme
 }
 
 void VDomDocument::ParseArcElement(VMainGraphicsScene *scene, const QDomElement &domElement,
-                                   const Document::Documents &parse, const QString &type, Draw::Draws mode){
+                                   const Document::Documents &parse, const QString &type, Draw::Draws mode)
+{
     Q_ASSERT(scene != 0);
-    Q_ASSERT_X(!domElement.isNull(), Q_FUNC_INFO, "domElement is null");
-    Q_ASSERT_X(!type.isEmpty(), Q_FUNC_INFO, "type of spline is empty");
-    if(type == "simple"){
-        try{
+    Q_ASSERT_X(domElement.isNull() == false, Q_FUNC_INFO, "domElement is null");
+    Q_ASSERT_X(type.isEmpty() == false, Q_FUNC_INFO, "type of spline is empty");
+    if (type == "simple")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             qint64 center = GetParametrLongLong(domElement, "center");
             QString radius = GetParametrString(domElement, "radius");
             QString f1 = GetParametrString(domElement, "angle1");
             QString f2 = GetParametrString(domElement, "angle2");
 
-            if(mode == Draw::Calculation){
+            if (mode == Draw::Calculation)
+            {
                 VToolArc::Create(id, center, radius, f1, f2, scene, this, data, parse, Tool::FromFile);
-            } else {
+            }
+            else
+            {
                 VModelingArc::Create(id, center, radius, f1, f2, this, data, parse, Tool::FromFile);
             }
 
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating simple arc"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
         }
     }
-    if(type == "modeling"){
-        try{
+    if (type == "modeling")
+    {
+        try
+        {
             qint64 id = GetParametrId(domElement);
             qint64 idObject = GetParametrLongLong(domElement, "idObject");
             QString tObject = GetParametrString(domElement, "typeObject");
             VArc arc;
             Draw::Draws typeObject;
-            if(tObject == "Calculation"){
+            if (tObject == "Calculation")
+            {
                 typeObject = Draw::Calculation;
                 arc = data->GetArc(idObject);
-            } else {
+            }
+            else
+            {
                 typeObject = Draw::Modeling;
                 arc = data->GetModelingArc(idObject);
             }
@@ -1071,7 +1336,8 @@ void VDomDocument::ParseArcElement(VMainGraphicsScene *scene, const QDomElement
             VNodeArc::Create(this, data, id, idObject, mode, parse, Tool::FromFile);
             return;
         }
-        catch(const VExceptionBadId &e){
+        catch (const VExceptionBadId &e)
+        {
             VExceptionObjectError excep(tr("Error creating or updating modeling arc"), domElement);
             excep.AddMoreInformation(e.ErrorMessage());
             throw excep;
@@ -1079,14 +1345,17 @@ void VDomDocument::ParseArcElement(VMainGraphicsScene *scene, const QDomElement
     }
 }
 
-void VDomDocument::FullUpdateTree(){
+void VDomDocument::FullUpdateTree()
+{
     VMainGraphicsScene *scene = new VMainGraphicsScene();
     Q_ASSERT(scene != 0);
-    try{
+    try
+    {
         data->ClearObject();
         Parse(Document::LiteParse, scene, scene);
     }
-    catch (const std::bad_alloc &) {
+    catch (const std::bad_alloc &)
+    {
         delete scene;
         QMessageBox msgBox;
         msgBox.setWindowTitle(tr("Error!"));
@@ -1098,7 +1367,8 @@ void VDomDocument::FullUpdateTree(){
         msgBox.exec();
         return;
     }
-    catch(...){
+    catch (...)
+    {
         delete scene;
         throw;
     }
@@ -1109,42 +1379,54 @@ void VDomDocument::FullUpdateTree(){
     emit haveChange();
 }
 
-void VDomDocument::haveLiteChange(){
+void VDomDocument::haveLiteChange()
+{
     emit haveChange();
 }
 
-void VDomDocument::ShowHistoryTool(qint64 id, Qt::GlobalColor color, bool enable){
+void VDomDocument::ShowHistoryTool(qint64 id, Qt::GlobalColor color, bool enable)
+{
     emit ShowTool(id, color, enable);
 }
 
-void VDomDocument::setCursor(const qint64 &value){
+void VDomDocument::setCursor(const qint64 &value)
+{
     cursor = value;
     emit ChangedCursor(cursor);
 }
 
-void VDomDocument::setCurrentData(){
-    if(*mode == Draw::Calculation){
+void VDomDocument::setCurrentData()
+{
+    if (*mode == Draw::Calculation)
+    {
         QString nameDraw = comboBoxDraws->itemText(comboBoxDraws->currentIndex());
-        if(nameActivDraw != nameDraw){
+        if (nameActivDraw != nameDraw)
+        {
             nameActivDraw = nameDraw;
             qint64 id = 0;
-            if(history.size() == 0){
+            if (history.size() == 0)
+            {
                 return;
             }
-            for(qint32 i = 0; i < history.size(); ++i){
+            for (qint32 i = 0; i < history.size(); ++i)
+            {
                 VToolRecord tool = history.at(i);
-                if(tool.getNameDraw() == nameDraw){
+                if (tool.getNameDraw() == nameDraw)
+                {
                     id = tool.getId();
                 }
             }
-            if(id == 0){
+            if (id == 0)
+            {
                 VToolRecord tool = history.at(history.size()-1);
                 id = tool.getId();
-                if(id == 0){
+                if (id == 0)
+                {
                     return;
                 }
             }
-            if(tools.size() > 0){
+            if (tools.size() > 0)
+            {
                 VDataTool *vTool = tools.value(id);
                 data->setData(vTool->getData());
             }
@@ -1152,13 +1434,15 @@ void VDomDocument::setCurrentData(){
     }
 }
 
-void VDomDocument::AddTool(const qint64 &id, VDataTool *tool){
+void VDomDocument::AddTool(const qint64 &id, VDataTool *tool)
+{
     Q_ASSERT_X(id > 0, Q_FUNC_INFO, "id <= 0");
     Q_ASSERT(tool != 0);
     tools.insert(id, tool);
 }
 
-void VDomDocument::UpdateToolData(const qint64 &id, VContainer *data){
+void VDomDocument::UpdateToolData(const qint64 &id, VContainer *data)
+{
     Q_ASSERT_X(id > 0, Q_FUNC_INFO, "id <= 0");
     Q_ASSERT(data != 0);
     VDataTool *tool = tools.value(id);
@@ -1166,14 +1450,16 @@ void VDomDocument::UpdateToolData(const qint64 &id, VContainer *data){
     tool->VDataTool::setData(data);
 }
 
-void VDomDocument::IncrementReferens(qint64 id) const{
+void VDomDocument::IncrementReferens(qint64 id) const
+{
     Q_ASSERT_X(id > 0, Q_FUNC_INFO, "id <= 0");
     VDataTool *tool = tools.value(id);
     Q_ASSERT(tool != 0);
     tool->incrementReferens();
 }
 
-void VDomDocument::DecrementReferens(qint64 id) const{
+void VDomDocument::DecrementReferens(qint64 id) const
+{
     Q_ASSERT_X(id > 0, Q_FUNC_INFO, "id <= 0");
     VDataTool *tool = tools.value(id);
     Q_ASSERT(tool != 0);
diff --git a/xml/vdomdocument.h b/xml/vdomdocument.h
index 8f9f5709d..fbd67550b 100644
--- a/xml/vdomdocument.h
+++ b/xml/vdomdocument.h
@@ -28,7 +28,8 @@
 #include <tools/vdatatool.h>
 #include "vtoolrecord.h"
 
-namespace Document {
+namespace Document
+{
     enum Document { LiteParse, FullParse};
     Q_DECLARE_FLAGS(Documents, Document)
 }
@@ -36,12 +37,12 @@ Q_DECLARE_OPERATORS_FOR_FLAGS(Document::Documents)
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Weffc++"
-class VDomDocument : public QObject, public QDomDocument{
+class VDomDocument : public QObject, public QDomDocument
+{
     Q_OBJECT
 public:
-                   VDomDocument(VContainer *data,QComboBox *comboBoxDraws, Draw::Draws *mode);
-                   VDomDocument(const QString& name, VContainer *data, QComboBox *comboBoxDraws,
-                                Draw::Draws *mode);
+                   VDomDocument(VContainer *data, QComboBox *comboBoxDraws, Draw::Draws *mode);
+                   VDomDocument(const QString& name, VContainer *data, QComboBox *comboBoxDraws, Draw::Draws *mode);
                    VDomDocument(const QDomDocumentType& doctype, VContainer *data, QComboBox *comboBoxDraws,
                                 Draw::Draws *mode);
                    ~VDomDocument(){}
diff --git a/xml/vtoolrecord.cpp b/xml/vtoolrecord.cpp
index 881a484d9..1df97da1f 100644
--- a/xml/vtoolrecord.cpp
+++ b/xml/vtoolrecord.cpp
@@ -21,9 +21,8 @@
 
 #include "vtoolrecord.h"
 
-VToolRecord::VToolRecord():id(0), typeTool(Tool::ArrowTool), nameDraw(QString()){
-}
+VToolRecord::VToolRecord()
+    :id(0), typeTool(Tool::ArrowTool), nameDraw(QString()){}
 
-VToolRecord::VToolRecord(const qint64 &id, const Tool::Tools &typeTool, const QString &nameDraw):id(id),
-    typeTool(typeTool), nameDraw(nameDraw){
-}
+VToolRecord::VToolRecord(const qint64 &id, const Tool::Tools &typeTool, const QString &nameDraw)
+    :id(id), typeTool(typeTool), nameDraw(nameDraw){}
diff --git a/xml/vtoolrecord.h b/xml/vtoolrecord.h
index ce598c1e0..3a4184e63 100644
--- a/xml/vtoolrecord.h
+++ b/xml/vtoolrecord.h
@@ -22,7 +22,8 @@
 #ifndef VTOOLRECORD_H
 #define VTOOLRECORD_H
 
-class VToolRecord{
+class VToolRecord
+{
 public:
                        VToolRecord();
                        VToolRecord(const qint64 &id, const Tool::Tools &typeTool, const QString &nameDraw);