@react-native-ohos/react-native-clippathview 1.1.9-rc.1 → 1.1.9-rc.2

package/harmony/clipPath/src/main/cpp/SVGPathParser.cpp

@@ -4,7 +4,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -17,7 +17,7 @@
 #include <native_drawing/drawing_path.h>
 #include <stdexcept>
 #include <sstream>
-#include "math.h"
+#include <cmath>
 #include <cctype>
 #include "cmath"
 #include "vector"
@@ -36,12 +36,13 @@ float SVGPathParser::mPenDownX = 0.0f;
 float SVGPathParser::mPenDownY = 0.0f;
 bool SVGPathParser::mPenDown = false;
 
-OH_Drawing_Path *SVGPathParser::parse(const std::string d) {
+OH_Drawing_Path *SVGPathParser::parse(const std::string d)
+{
     if (d.empty()) {
         return nullptr;
     }
     OH_Drawing_Path *cPath_ = OH_Drawing_PathCreate();
-    char prev_cmd = ' ';
+    char prevCmd = ' ';
     l = d.length();
     s = d;
     i = 0;
@@ -55,13 +56,11 @@ OH_Drawing_Path *SVGPathParser::parse(const std::string d) {
     mPenDown = false;
 
     while (i < l) {
-        skip_spaces();
-
+        SkipSpaces();
         if (i >= l) {
             break;
         }
-
-        bool has_prev_cmd = prev_cmd != ' ';
+        bool has_prev_cmd = prevCmd != ' ';
         char first_char = s.at(i);
 
         if (!has_prev_cmd && first_char != 'M' && first_char != 'm') {
@@ -71,34 +70,33 @@ OH_Drawing_Path *SVGPathParser::parse(const std::string d) {
             throw std::logic_error(oss.str());
         }
 
-        // TODO: simplify
         bool is_implicit_move_to;
         char cmd;
-        if (is_cmd(first_char)) {
+        if (IsCmd(first_char)) {
             is_implicit_move_to = false;
             cmd = first_char;
             i += 1;
         } else if (is_number_start(first_char) && has_prev_cmd) {
-            if (prev_cmd == 'Z' || prev_cmd == 'z') {
+            if (prevCmd == 'Z' || prevCmd == 'z') {
                 // ClosePath cannot be followed by a number.
                 std::ostringstream oss;
                 oss << "Unexpected number after 'z' (s=" << s << ")";
                 throw std::logic_error(oss.str());
             }
 
-            if (prev_cmd == 'M' || prev_cmd == 'm') {
+            if (prevCmd == 'M' || prevCmd == 'm') {
                 // 'If a moveto is followed by multiple pairs of coordinates,
                 // the subsequent pairs are treated as implicit lineto commands.'
                 // So we parse them as LineTo.
                 is_implicit_move_to = true;
-                if (is_absolute(prev_cmd)) {
+                if (is_absolute(prevCmd)) {
                     cmd = 'L';
                 } else {
                     cmd = 'l';
                 }
             } else {
                 is_implicit_move_to = false;
-                cmd = prev_cmd;
+                cmd = prevCmd;
             }
         } else {
             std::ostringstream oss;
@@ -107,203 +105,219 @@ OH_Drawing_Path *SVGPathParser::parse(const std::string d) {
         }
         bool absolute = is_absolute(cmd);
         switch (cmd) {
-        case 'm': {
-        rnoh:
-            move(parse_list_number(), parse_list_number(), cPath_);
-            break;
-        }
-        case 'M': {
-            moveTo(parse_list_number(), parse_list_number(), cPath_);
-            break;
-        }
-        case 'l': {
-            line(parse_list_number(), parse_list_number(), cPath_);
-            break;
-        }
-        case 'L': {
-            lineTo(parse_list_number(), parse_list_number(), cPath_);
-            break;
-        }
-        case 'h': {
-            line(parse_list_number(), 0, cPath_);
-            break;
-        }
-        case 'H': {
-            lineTo(parse_list_number(), mPenY, cPath_);
-            break;
-        }
-        case 'v': {
-            line(0, parse_list_number(), cPath_);
-            break;
-        }
-        case 'V': {
-            lineTo(mPenX, parse_list_number(), cPath_);
-            break;
-        }
-        case 'c': {
-            curve(parse_list_number(), parse_list_number(), parse_list_number(), parse_list_number(),
-                  parse_list_number(), parse_list_number(), cPath_);
-            break;
-        }
-        case 'C': {
-            curveTo(parse_list_number(), parse_list_number(), parse_list_number(), parse_list_number(),
+            case 'm': {
+                rnoh:
+                    move(parse_list_number(), parse_list_number(), cPath_);
+                    break;
+            }
+            case 'M': {
+                moveTo(parse_list_number(), parse_list_number(), cPath_);
+                break;
+            }
+            case 'l': {
+                line(parse_list_number(), parse_list_number(), cPath_);
+                break;
+            }
+            case 'L': {
+                lineTo(parse_list_number(), parse_list_number(), cPath_);
+                break;
+            }
+            case 'h': {
+                line(parse_list_number(), 0, cPath_);
+                break;
+            }
+            case 'H': {
+                lineTo(parse_list_number(), mPenY, cPath_);
+                break;
+            }
+            case 'v': {
+                line(0, parse_list_number(), cPath_);
+                break;
+            }
+            case 'V': {
+                lineTo(mPenX, parse_list_number(), cPath_);
+                break;
+            }
+            case 'c': {
+                curve(parse_list_number(), parse_list_number(), parse_list_number(), parse_list_number(),
                     parse_list_number(), parse_list_number(), cPath_);
-            break;
-        }
-        case 's': {
-            smoothCurve(parse_list_number(), parse_list_number(), parse_list_number(), parse_list_number(), cPath_);
-            break;
-        }
-        case 'S': {
-            smoothCurveTo(parse_list_number(), parse_list_number(), parse_list_number(), parse_list_number(), cPath_);
-            break;
-        }
-        case 'q': {
-            quadraticBezierCurve(parse_list_number(), parse_list_number(), parse_list_number(), parse_list_number(),
-                                 cPath_);
-            break;
-        }
-        case 'Q': {
-            quadraticBezierCurveTo(parse_list_number(), parse_list_number(), parse_list_number(), parse_list_number(),
-                                   cPath_);
-            break;
-        }
-        case 't': {
-            smoothQuadraticBezierCurve(parse_list_number(), parse_list_number(), cPath_);
-            break;
-        }
-        case 'T': {
-            smoothQuadraticBezierCurveTo(parse_list_number(), parse_list_number(), cPath_);
-            break;
-        }
-        case 'a': {
-            arc(parse_list_number(), parse_list_number(), parse_list_number(), parse_flag(), parse_flag(),
-                parse_list_number(), parse_list_number(), cPath_);
-            break;
-        }
-        case 'A': {
-            arcTo(parse_list_number(), parse_list_number(), parse_list_number(), parse_flag(), parse_flag(),
-                  parse_list_number(), parse_list_number(), cPath_);
-            break;
-        }
-        case 'z':
-        case 'Z': {
-            close(cPath_);
-            break;
-        }
-        default: {
-            std::ostringstream oss;
-            oss << "Unexpected comand " << cmd << ",s=" << s << ")";
-            throw std::logic_error(oss.str());
-        }
+                break;
+            }
+            case 'C': {
+                curveTo(parse_list_number(), parse_list_number(), parse_list_number(), parse_list_number(),
+                    parse_list_number(), parse_list_number(), cPath_);
+                break;
+            }
+            case 's': {
+                smoothCurve(parse_list_number(), parse_list_number(), parse_list_number(), parse_list_number(), cPath_);
+                break;
+            }
+            case 'S': {
+                smoothCurveTo(parse_list_number(), parse_list_number(), parse_list_number(), parse_list_number(),
+                    cPath_);
+                break;
+            }
+            case 'q': {
+                quadraticBezierCurve(parse_list_number(), parse_list_number(), parse_list_number(), parse_list_number(),
+                    cPath_);
+                break;
+            }
+            case 'Q': {
+                quadraticBezierCurveTo(parse_list_number(), parse_list_number(), parse_list_number(),
+                    parse_list_number(), cPath_);
+                break;
+            }
+            case 't': {
+                smoothQuadraticBezierCurve(parse_list_number(), parse_list_number(), cPath_);
+                break;
+            }
+            case 'T': {
+                smoothQuadraticBezierCurveTo(parse_list_number(), parse_list_number(), cPath_);
+                break;
+            }
+            case 'a': {
+                arc(parse_list_number(), parse_list_number(), parse_list_number(), parse_flag(), parse_flag(),
+                    parse_list_number(), parse_list_number(), cPath_);
+                break;
+            }
+            case 'A': {
+                arcTo(parse_list_number(), parse_list_number(), parse_list_number(), parse_flag(), parse_flag(),
+                    parse_list_number(), parse_list_number(), cPath_);
+                break;
+            }
+            case 'z':
+            case 'Z': {
+                close(cPath_);
+                break;
+            }
+            default: {
+                std::ostringstream oss;
+                oss << "Unexpected comand " << cmd << ",s=" << s << ")";
+                throw std::logic_error(oss.str());
+            }
         }
 
         if (is_implicit_move_to) {
             if (absolute) {
-                prev_cmd = 'M';
+                prevCmd = 'M';
             } else {
-                prev_cmd = 'm';
+                prevCmd = 'm';
             }
         } else {
-            prev_cmd = cmd;
+            prevCmd = cmd;
         }
     }
     return cPath_;
 }
 
-void SVGPathParser::move(float x, float y, OH_Drawing_Path *cPath_) { moveTo(x + mPenX, y + mPenY, cPath_); }
+void SVGPathParser::move(float x, float y, OH_Drawing_Path *cPath_)
+{
+    moveTo(x + mPenX, y + mPenY, cPath_);
+}
 
-void SVGPathParser::moveTo(float x, float y, OH_Drawing_Path *cPath_) {
+void SVGPathParser::moveTo(float x, float y, OH_Drawing_Path *cPath_)
+{
     mPenDownX = mPivotX = mPenX = x;
     mPenDownY = mPivotY = mPenY = y;
     OH_Drawing_PathMoveTo(cPath_, x * mScale, y * mScale);
 }
 
-void SVGPathParser::line(float x, float y, OH_Drawing_Path *cPath_) { lineTo(x + mPenX, y + mPenY, cPath_); }
-void SVGPathParser::lineTo(float x, float y, OH_Drawing_Path *cPath_) {
-    // FLog.w(ReactConstants.TAG, "line x: " + x + " y: " + y);
-    setPenDown();
+void SVGPathParser::line(float x, float y, OH_Drawing_Path *cPath_)
+{
+    lineTo(x + mPenX, y + mPenY, cPath_);
+}
+void SVGPathParser::lineTo(float x, float y, OH_Drawing_Path *cPath_)
+{
+    SetPenDown();
     mPivotX = mPenX = x;
     mPivotY = mPenY = y;
     OH_Drawing_PathLineTo(cPath_, x * mScale, y * mScale);
 }
 
-void SVGPathParser::curve(float c1x, float c1y, float c2x, float c2y, float ex, float ey, OH_Drawing_Path *cPath_) {
+void SVGPathParser::curve(float c1x, float c1y, float c2x, float c2y, float ex, float ey, OH_Drawing_Path *cPath_)
+{
     curveTo(c1x + mPenX, c1y + mPenY, c2x + mPenX, c2y + mPenY, ex + mPenX, ey + mPenY, cPath_);
 }
 
-void SVGPathParser::curveTo(float c1x, float c1y, float c2x, float c2y, float ex, float ey, OH_Drawing_Path *cPath_) {
+void SVGPathParser::curveTo(float c1x, float c1y, float c2x, float c2y, float ex, float ey, OH_Drawing_Path *cPath_)
+{
     mPivotX = c2x;
     mPivotY = c2y;
     cubicTo(c1x, c1y, c2x, c2y, ex, ey, cPath_);
 }
 
-void SVGPathParser::cubicTo(float c1x, float c1y, float c2x, float c2y, float ex, float ey, OH_Drawing_Path *cPath_) {
-    setPenDown();
+void SVGPathParser::cubicTo(float c1x, float c1y, float c2x, float c2y, float ex, float ey, OH_Drawing_Path *cPath_)
+{
+    SetPenDown();
     mPenX = ex;
     mPenY = ey;
     OH_Drawing_PathCubicTo(cPath_, c1x * mScale, c1y * mScale, c2x * mScale, c2y * mScale, ex * mScale, ey * mScale);
 }
 
 
-void SVGPathParser::smoothCurve(float c1x, float c1y, float ex, float ey, OH_Drawing_Path *cPath_) {
+void SVGPathParser::smoothCurve(float c1x, float c1y, float ex, float ey, OH_Drawing_Path *cPath_)
+{
     smoothCurveTo(c1x + mPenX, c1y + mPenY, ex + mPenX, ey + mPenY, cPath_);
 }
-void SVGPathParser::smoothCurveTo(float c1x, float c1y, float ex, float ey, OH_Drawing_Path *cPath_) {
-    // FLog.w(ReactConstants.TAG, "smoothcurve c1x: " + c1x + " c1y: " + c1y + "ex: " + ex + " ey: " + ey);
+void SVGPathParser::smoothCurveTo(float c1x, float c1y, float ex, float ey, OH_Drawing_Path *cPath_)
+{
     float c2x = c1x;
     float c2y = c1y;
-    c1x = (mPenX * 2) - mPivotX;
-    c1y = (mPenY * 2) - mPivotY;
+    int count2 = 2;
+    c1x = (mPenX * count2) - mPivotX;
+    c1y = (mPenY * count2) - mPivotY;
     mPivotX = c2x;
     mPivotY = c2y;
     cubicTo(c1x, c1y, c2x, c2y, ex, ey, cPath_);
 }
 
-void SVGPathParser::quadraticBezierCurve(float c1x, float c1y, float c2x, float c2y, OH_Drawing_Path *cPath_) {
+void SVGPathParser::quadraticBezierCurve(float c1x, float c1y, float c2x, float c2y, OH_Drawing_Path *cPath_)
+{
     quadraticBezierCurveTo(c1x + mPenX, c1y + mPenY, c2x + mPenX, c2y + mPenY, cPath_);
 }
 
-void SVGPathParser::quadraticBezierCurveTo(float c1x, float c1y, float c2x, float c2y, OH_Drawing_Path *cPath_) {
-    // FLog.w(ReactConstants.TAG, "quad c1x: " + c1x + " c1y: " + c1y + "c2x: " + c2x + " c2y: " + c2y);
+void SVGPathParser::quadraticBezierCurveTo(float c1x, float c1y, float c2x, float c2y, OH_Drawing_Path *cPath_)
+{
+    int count2 = 2;
+    int count3 = 3;
     mPivotX = c1x;
     mPivotY = c1y;
     float ex = c2x;
     float ey = c2y;
-    c2x = (ex + c1x * 2) / 3;
-    c2y = (ey + c1y * 2) / 3;
-    c1x = (mPenX + c1x * 2) / 3;
-    c1y = (mPenY + c1y * 2) / 3;
+    c2x = (ex + c1x * count2) / count3;
+    c2y = (ey + c1y * count2) / count3;
+    c1x = (mPenX + c1x * count2) / count3;
+    c1y = (mPenY + c1y * count2) / count3;
     cubicTo(c1x, c1y, c2x, c2y, ex, ey, cPath_);
 }
 
-void SVGPathParser::smoothQuadraticBezierCurve(float c1x, float c1y, OH_Drawing_Path *cPath_) {
+void SVGPathParser::smoothQuadraticBezierCurve(float c1x, float c1y, OH_Drawing_Path *cPath_)
+{
     smoothQuadraticBezierCurveTo(c1x + mPenX, c1y + mPenY, cPath_);
 }
 
-void SVGPathParser::smoothQuadraticBezierCurveTo(float c1x, float c1y, OH_Drawing_Path *cPath_) {
-    // FLog.w(ReactConstants.TAG, "smoothquad c1x: " + c1x + " c1y: " + c1y);
+void SVGPathParser::smoothQuadraticBezierCurveTo(float c1x, float c1y, OH_Drawing_Path *cPath_)
+{
     float c2x = c1x;
     float c2y = c1y;
-    c1x = (mPenX * 2) - mPivotX;
-    c1y = (mPenY * 2) - mPivotY;
+    int count2 = 2;
+    c1x = (mPenX * count2) - mPivotX;
+    c1y = (mPenY * count2) - mPivotY;
     quadraticBezierCurveTo(c1x, c1y, c2x, c2y, cPath_);
 }
 void SVGPathParser::arc(float rx, float ry, float rotation, bool outer, bool clockwise, float x, float y,
-                        OH_Drawing_Path *cPath_) {
+    OH_Drawing_Path *cPath_)
+{
     arcTo(rx, ry, rotation, outer, clockwise, x + mPenX, y + mPenY, cPath_);
 }
 
 void SVGPathParser::arcTo(float rx, float ry, float rotation, bool outer, bool clockwise, float x, float y,
-                          OH_Drawing_Path *cPath_) {
-    // FLog.w(ReactConstants.TAG, "arc rx: " + rx + " ry: " + ry + " rotation: " + rotation + " outer: " + outer + "
-    // clockwise: " + clockwise + " x: " + x + " y: " + y);
+    OH_Drawing_Path *cPath_)
+{
     float tX = mPenX;
     float tY = mPenY;
-
     ry = abs(ry == 0 ? (rx == 0 ? (y - tY) : rx) : ry);
     rx = abs(rx == 0 ? (x - tX) : rx);
-
     if (rx == 0 || ry == 0 || (x == tX && y == tY)) {
         lineTo(x, y, cPath_);
         return;
@@ -316,8 +330,9 @@ void SVGPathParser::arcTo(float rx, float ry, float rotation, bool outer, bool c
     y -= tY;
 
     // Ellipse Center
-    float cx = cos * x / 2 + sin * y / 2;
-    float cy = -sin * x / 2 + cos * y / 2;
+    int count2 = 2;
+    float cx = cos * x / count2 + sin * y / count2;
+    float cy = -sin * x / count2 + cos * y / count2;
     float rxry = rx * rx * ry * ry;
     float rycx = ry * ry * cx * cx;
     float rxcy = rx * rx * cy * cy;
@@ -327,8 +342,8 @@ void SVGPathParser::arcTo(float rx, float ry, float rotation, bool outer, bool c
         a = std::sqrt(1 - a / rxry);
         rx *= a;
         ry *= a;
-        cx = x / 2;
-        cy = y / 2;
+        cx = x / count2;
+        cy = y / count2;
     } else {
         a = std::sqrt(a / (rxcy + rycx));
 
@@ -337,8 +352,8 @@ void SVGPathParser::arcTo(float rx, float ry, float rotation, bool outer, bool c
         }
         float cxd = -a * cy * rx / ry;
         float cyd = a * cx * ry / rx;
-        cx = cos * cxd - sin * cyd + x / 2;
-        cy = sin * cxd + cos * cyd + y / 2;
+        cx = cos * cxd - sin * cyd + x / count2;
+        cy = sin * cxd + cos * cyd + y / count2;
     }
 
     // Rotation + Scale Transform
@@ -356,27 +371,29 @@ void SVGPathParser::arcTo(float rx, float ry, float rotation, bool outer, bool c
     x += tX;
     y += tY;
 
-    setPenDown();
+    SetPenDown();
 
     mPenX = mPivotX = x;
     mPenY = mPivotY = y;
+    int count180 = 180;
+    int count360 = 360;
+    double point180 = 180.0;
 
     if (rx != ry || rad != 0.f) {
         arcToBezier(cx, cy, rx, ry, sa, ea, clockwise, rad, cPath_);
     } else {
-
-        float start = static_cast<float>(sa * 180.0 / M_PI);
-        float end = static_cast<float>(ea * 180.0 / M_PI);
-        float sweep = abs((start - end) - std::floor((start - end) / 360) * 360);
+        float start = static_cast<float>(sa * point180 / M_PI);
+        float end = static_cast<float>(ea * point180 / M_PI);
+        float sweep = abs((start - end) - std::floor((start - end) / count360) * count360);
 
 
         if (outer) {
-            if (sweep < 180) {
-                sweep = 360 - sweep;
+            if (sweep < count180) {
+                sweep = count360 - sweep;
             }
         } else {
-            if (sweep > 180) {
-                sweep = 360 - sweep;
+            if (sweep > count180) {
+                sweep = count360 - sweep;
             }
         }
 
@@ -384,17 +401,19 @@ void SVGPathParser::arcTo(float rx, float ry, float rotation, bool outer, bool c
             sweep = -sweep;
         }
         OH_Drawing_PathArcTo(cPath_, (cx - rx) * mScale, (cy - rx) * mScale, (cx + rx) * mScale, (cy + rx) * mScale,
-                             start, sweep);
+            start, sweep);
     }
 }
-void SVGPathParser::setPenDown() {
+void SVGPathParser::SetPenDown()
+{
     if (!mPenDown) {
         mPenDownX = mPenX;
         mPenDownY = mPenY;
         mPenDown = true;
     }
 }
-void SVGPathParser::close(OH_Drawing_Path *cPath_) {
+void SVGPathParser::close(OH_Drawing_Path *cPath_)
+{
     if (mPenDown) {
         mPenX = mPenDownX;
         mPenY = mPenDownY;
@@ -403,7 +422,8 @@ void SVGPathParser::close(OH_Drawing_Path *cPath_) {
     }
 }
 void SVGPathParser::arcToBezier(float cx, float cy, float rx, float ry, float sa, float ea, bool clockwise, float rad,
-                                OH_Drawing_Path *cPath_) {
+    OH_Drawing_Path *cPath_)
+{
     // Inverse Rotation + Scale Transform
     float cos = std::cos(rad);
     float sin = std::sin(rad);
@@ -414,109 +434,126 @@ void SVGPathParser::arcToBezier(float cx, float cy, float rx, float ry, float sa
 
     // Bezier Curve Approximation
     float arc = ea - sa;
+    int count2 = 2;
+    int count4 = 4;
+    double point3 = 3.0;
     if (arc < 0 && clockwise) {
-        arc += M_PI * 2;
+        arc += M_PI * count2;
     } else if (arc > 0 && !clockwise) {
-        arc -= M_PI * 2;
+        arc -= M_PI * count2;
     }
 
-    int n = (int)std::ceil(std::abs(round(arc / (M_PI / 2))));
+    int n = static_cast<int>(std::ceil(std::abs(round(arc / (M_PI / count2)))));
 
     float step = arc / n;
-    float k = (float)((4 / 3.0) * std::tan(step / 4));
+    float k = static_cast<float>((count4 / point3) * std::tan(step / count4));
     float x = std::cos(sa);
     float y = std::sin(sa);
 
-    for (int i = 0; i < n; i++) {
+    for (int counti = 0; counti < n; counti++) {
         float cp1x = x - k * y;
         float cp1y = y + k * x;
 
         sa += step;
-        x = std::cos(sa);
-        y = std::sin(sa);
+        float newX = std::cos(sa);
+        float newY = std::sin(sa);
 
-        float cp2x = x + k * y;
-        float cp2y = y - k * x;
+        float cp2x = newX + k * newY;
+        float cp2y = newY - k * newX;
 
         float c1x = (cx + xx * cp1x + yx * cp1y);
         float c1y = (cy + xy * cp1x + yy * cp1y);
         float c2x = (cx + xx * cp2x + yx * cp2y);
         float c2y = (cy + xy * cp2x + yy * cp2y);
-        float ex = (cx + xx * x + yx * y);
-        float ey = (cy + xy * x + yy * y);
+        float ex = (cx + xx * newX + yx * newY);
+        float ey = (cy + xy * newX + yy * newY);
         OH_Drawing_PathCubicTo(cPath_, c1x * mScale, c1y * mScale, c2x * mScale, c2y * mScale, ex * mScale,
-                               ey * mScale);
+            ey * mScale);
     }
 }
 
-double SVGPathParser::_round(double val) {
+double SVGPathParser::_round(double val)
+{
     double multiplier = pow(10, 4);
     return round(val * multiplier) / multiplier;
 }
 
-void SVGPathParser::skip_spaces() {
-    while (i < l && std::isspace(s.at(i)))
+void SVGPathParser::SkipSpaces()
+{
+    while (i < l && std::isspace(s.at(i))) {
         i++;
+    }
 }
-bool SVGPathParser::is_cmd(char c) {
+bool SVGPathParser::IsCmd(char c)
+{
     switch (c) {
-    case 'M':
-    case 'm':
-    case 'Z':
-    case 'z':
-    case 'L':
-    case 'l':
-    case 'H':
-    case 'h':
-    case 'V':
-    case 'v':
-    case 'C':
-    case 'c':
-    case 'S':
-    case 's':
-    case 'Q':
-    case 'q':
-    case 'T':
-    case 't':
-    case 'A':
-    case 'a':
-        return true;
+        case 'M':
+        case 'm':
+        case 'Z':
+        case 'z':
+        case 'L':
+        case 'l':
+        case 'H':
+        case 'h':
+        case 'V':
+        case 'v':
+        case 'C':
+        case 'c':
+        case 'S':
+        case 's':
+        case 'Q':
+        case 'q':
+        case 'T':
+        case 't':
+        case 'A':
+        case 'a':
+            return true;
+        default:
+            return false;
     }
     return false;
 }
 
 
-bool SVGPathParser::is_number_start(char c) { return (c >= '0' && c <= '9') || c == '.' || c == '-' || c == '+'; }
+bool SVGPathParser::is_number_start(char c)
+{
+    return (c >= '0' && c <= '9') || c == '.' || c == '-' || c == '+';
+}
 
-bool SVGPathParser::is_absolute(char c) { return std::isupper(c); }
+bool SVGPathParser::is_absolute(char c)
+{
+    return std::isupper(c);
+}
 // By the SVG spec 'large-arc' and 'sweep' must contain only one char
 // and can be written without any separators, e.g.: 10 20 30 01 10 20.
 
-bool SVGPathParser::parse_flag() {
-    skip_spaces();
+bool SVGPathParser::parse_flag()
+{
+    SkipSpaces();
 
     char c = s.at(i);
     switch (c) {
-    case '0':
-    case '1': {
-        i += 1;
-        if (i < l && s.at(i) == ',') {
+        case '0':
+        case '1': {
             i += 1;
+            if (i < l && s.at(i) == ',') {
+                i += 1;
+            }
+            SkipSpaces();
+            break;
         }
-        skip_spaces();
-        break;
-    }
-    default:
-        std::ostringstream oss;
-        oss << "Unexpected flag" << c << ",i=" << i << ",s=" << s;
-        throw std::logic_error(oss.str());
+        default:
+            std::ostringstream oss;
+            oss << "Unexpected flag" << c << ",i=" << i << ",s=" << s;
+            throw std::logic_error(oss.str());
     }
 
     return c == '1';
 }
 
 
-float SVGPathParser::parse_list_number() {
+float SVGPathParser::parse_list_number()
+{
     if (i == l) {
         std::ostringstream oss;
         oss << "Unexpected end (s=" << s << ")";
@@ -524,15 +561,16 @@ float SVGPathParser::parse_list_number() {
     }
 
     float n = parse_number();
-    skip_spaces();
+    SkipSpaces();
     parse_list_separator();
 
     return n;
 }
 
-float SVGPathParser::parse_number() {
+float SVGPathParser::parse_number()
+{
     // Strip off leading whitespaces.
-    skip_spaces();
+    SkipSpaces();
 
     if (i == l) {
         std::ostringstream oss;
@@ -552,7 +590,7 @@ float SVGPathParser::parse_number() {
 
     // Consume integer.
     if (c >= '0' && c <= '9') {
-        skip_digits();
+        SkipDigits();
         if (i < l) {
             c = s.at(i);
         }
@@ -565,7 +603,7 @@ float SVGPathParser::parse_number() {
     // Consume fraction.
     if (c == '.') {
         i += 1;
-        skip_digits();
+        SkipDigits();
         if (i < l) {
             c = s.at(i);
         }
@@ -580,9 +618,9 @@ float SVGPathParser::parse_number() {
 
             if (c == '+' || c == '-') {
                 i += 1;
-                skip_digits();
+                SkipDigits();
             } else if (c >= '0' && c <= '9') {
-                skip_digits();
+                SkipDigits();
             } else {
                 std::ostringstream oss;
                 oss << "Invalid number formating character " << c << ",i=" << i << ",s=" << s;
@@ -590,10 +628,8 @@ float SVGPathParser::parse_number() {
             }
         }
     }
-
     std::string num = s.substr(start, i);
     float n = std::stof(num);
-
     // inf, nan, etc. are an error.
     if (std::isinf(n) || std::isnan(n)) {
         std::ostringstream oss;
@@ -604,14 +640,17 @@ float SVGPathParser::parse_number() {
     return n;
 }
 
-void SVGPathParser::parse_list_separator() {
+void SVGPathParser::parse_list_separator()
+{
     if (i < l && s.at(i) == ',') {
         i += 1;
     }
 }
 
-void SVGPathParser::skip_digits() {
-    while (i < l && std::isdigit(s.at(i)))
+void SVGPathParser::SkipDigits()
+{
+    while (i < l && std::isdigit(s.at(i))) {
         i++;
+    }
 }
 }; // namespace rnoh