Commonize PathSegmentIterator

skiko/src/commonMain/cpp/generated/PathSegmentIterator.cc

-
-// This file has been auto generated.
-
 #include "SkPath.h"
 #include "common.h"
 
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathSegmentIterator__1nMake
   (KNativePointer pathPtr, KBoolean forceClose) {
-    SkPath* path = reinterpret_cast<SkPath*>((pathPtr));
+    SkPath* path = reinterpret_cast<SkPath*>(pathPtr);
     SkPath::Iter* iter = new SkPath::Iter(*path, forceClose);
     return reinterpret_cast<KNativePointer>(iter);
 }
@@ -16,46 +13,38 @@ static void deletePathSegmentIterator(SkPath::Iter* iter) {
     delete iter;
 }
 
-SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathSegmentIterator__1nGetFinalizer
-  () {
+SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathSegmentIterator__1nGetFinalizer() {
     return reinterpret_cast<KNativePointer>((&deletePathSegmentIterator));
 }
 
-
-SKIKO_EXPORT KInteropPointer org_jetbrains_skia_PathSegmentIterator__1nNext
-  (KNativePointer ptr) {
-    TODO("implement org_jetbrains_skia_PathSegmentIterator__1nNext");
-}
-     
-#if 0 
-SKIKO_EXPORT KInteropPointer org_jetbrains_skia_PathSegmentIterator__1nNext
-  (KNativePointer ptr) {
-    SkPath::Iter* instance = reinterpret_cast<SkPath::Iter*>((ptr));
+SKIKO_EXPORT void org_jetbrains_skia_PathSegmentIterator__1nNext(KNativePointer ptr, KInt* data) {
+    SkPath::Iter* instance = reinterpret_cast<SkPath::Iter*>(ptr);
     SkPoint pts[4];
     SkPath::Verb verb = instance->next(pts);
-    KInteropPointer segment;
-    switch (verb) {
-        case SkPath::Verb::kDone_Verb:
-            segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorDone);
-            break;
-        case SkPath::Verb::kMove_Verb:
-        case SkPath::Verb::kClose_Verb:
-            segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorMoveClose, static_cast<KInt>(verb), pts[0].fX, pts[0].fY, instance->isClosedContour());
-            break;
-        case SkPath::Verb::kLine_Verb:
-            segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorLine, pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, instance->isCloseLine(), instance->isClosedContour());
-            break;
-        case SkPath::Verb::kQuad_Verb:
-            segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorQuad, pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY, instance->isClosedContour());
-            break;
-        case SkPath::Verb::kConic_Verb:
-            segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorConic, pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY, instance->conicWeight(), instance->isClosedContour());
-            break;
-        case SkPath::Verb::kCubic_Verb:
-            segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorConic, pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY, pts[3].fX, pts[3].fY, instance->isClosedContour());
-            break;
+
+    data[0] = rawBits(pts[0].fX);
+    data[1] = rawBits(pts[0].fY);
+
+    data[2] = rawBits(pts[1].fX);
+    data[3] = rawBits(pts[1].fY);
+
+    data[4] = rawBits(pts[2].fX);
+    data[5] = rawBits(pts[2].fY);
+
+    data[6] = rawBits(pts[3].fX);
+    data[7] = rawBits(pts[3].fY);
+
+    // Otherwise it's null.
+    if (verb == SkPath::Verb::kConic_Verb)
+        data[8] = rawBits(instance->conicWeight());
+
+    int context = verb;
+    if (instance -> isClosedContour()) {
+        context = context | (1 << 7);
+    }
+    if (instance -> isCloseLine()) {
+        context = context | (1 << 6);
     }
-    return segment;
-}
-#endif
 
+    data[9] = context;
+}
\ No newline at end of file

skiko/src/commonMain/kotlin/org/jetbrains/skia/Path.kt

@@ -1978,7 +1978,7 @@ class Path internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHol
     }
 
     fun iterator(forceClose: Boolean): PathSegmentIterator {
-        return PathSegmentIterator.Companion.make(this, forceClose)
+        return PathSegmentIterator.make(this, forceClose)
     }
 
     /**

skiko/src/commonMain/kotlin/org/jetbrains/skia/PathSegmentIterator.kt

 package org.jetbrains.skia
 
+import org.jetbrains.skia.impl.InteropPointer
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
 import org.jetbrains.skia.impl.Managed
 import org.jetbrains.skia.impl.NativePointer
 import org.jetbrains.skia.impl.Stats
 import org.jetbrains.skia.impl.getPtr
 import org.jetbrains.skia.impl.reachabilityBarrier
+import org.jetbrains.skia.impl.withResult
 
-class PathSegmentIterator internal constructor(val _path: Path?, ptr: NativePointer) : Managed(ptr, PathSegmentIterator_nGetFinalizer()),
+class PathSegmentIterator internal constructor(val _path: Path?, ptr: NativePointer) :
+    Managed(ptr, PathSegmentIterator_nGetFinalizer()),
     MutableIterator<PathSegment?> {
     companion object {
         fun make(path: Path?, forceClose: Boolean): PathSegmentIterator {
             return try {
-                val ptr =
-                    _nMake(getPtr(path), forceClose)
-                val i = PathSegmentIterator(path, ptr)
-                i._nextSegment = PathSegmentIterator_nNext(ptr)
+                val i = PathSegmentIterator(path, _nMake(getPtr(path), forceClose))
+                i._nextSegment = i.nextSegment()
                 i
             } finally {
                 reachabilityBarrier(path)
@@ -32,7 +33,7 @@ class PathSegmentIterator internal constructor(val _path: Path?, ptr: NativePoin
         return try {
             if (_nextSegment?.verb == PathVerb.DONE) throw NoSuchElementException()
             val res = _nextSegment
-            _nextSegment = PathSegmentIterator_nNext(_ptr)
+            _nextSegment = nextSegment()
             res
         } finally {
             reachabilityBarrier(this)
@@ -54,13 +55,81 @@ class PathSegmentIterator internal constructor(val _path: Path?, ptr: NativePoin
     override fun remove() {
         TODO("Not yet implemented")
     }
+
+    private fun nextSegment() = pathSegmentFromIntArray(withResult(IntArray(10)) {
+        PathSegmentIterator_nNext(this._ptr, it)
+    })
+}
+
+private fun pathSegmentFromIntArray(points: IntArray): PathSegment {
+    val context = points.last()
+
+    val verb = (context) and ((1 shl 3) - 1)
+    val isClosedBit = ((context shr 7) and 1)
+    val isClosedLineBit = ((context shr 6) and 1)
+    val isClosed = isClosedBit != 0
+
+    return when (PathVerb.values()[verb]) {
+        PathVerb.MOVE, PathVerb.CLOSE -> {
+            PathSegment(verb, Float.fromBits(points[0]), Float.fromBits(points[1]), isClosed)
+        }
+        PathVerb.LINE -> {
+            PathSegment(
+                Float.fromBits(points[0]),
+                Float.fromBits(points[1]),
+                Float.fromBits(points[2]),
+                Float.fromBits(points[3]),
+                isClosedLineBit != 0,
+                isClosed
+            )
+        }
+        PathVerb.QUAD -> {
+            PathSegment(
+                Float.fromBits(points[0]),
+                Float.fromBits(points[1]),
+                Float.fromBits(points[2]),
+                Float.fromBits(points[3]),
+                Float.fromBits(points[4]),
+                Float.fromBits(points[5]),
+                isClosed
+            )
+        }
+        PathVerb.CONIC -> {
+            PathSegment(
+                Float.fromBits(points[0]),
+                Float.fromBits(points[1]),
+                Float.fromBits(points[2]),
+                Float.fromBits(points[3]),
+                Float.fromBits(points[4]),
+                Float.fromBits(points[5]),
+                Float.fromBits(points[8]),
+                isClosed
+            )
+        }
+        PathVerb.CUBIC -> {
+            PathSegment(
+                Float.fromBits(points[0]),
+                Float.fromBits(points[1]),
+                Float.fromBits(points[2]),
+                Float.fromBits(points[3]),
+                Float.fromBits(points[4]),
+                Float.fromBits(points[5]),
+                Float.fromBits(points[6]),
+                Float.fromBits(points[7]),
+                isClosed
+            )
+        }
+        PathVerb.DONE -> {
+            PathSegment()
+        }
+    }
 }
 
 @ExternalSymbolName("org_jetbrains_skia_PathSegmentIterator__1nGetFinalizer")
 private external fun PathSegmentIterator_nGetFinalizer(): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_PathSegmentIterator__1nNext")
-private external fun PathSegmentIterator_nNext(ptr: NativePointer): PathSegment?
+private external fun PathSegmentIterator_nNext(ptr: NativePointer, points: InteropPointer)
 
 @ExternalSymbolName("org_jetbrains_skia_PathSegmentIterator__1nMake")
 private external fun _nMake(pathPtr: NativePointer, forceClose: Boolean): NativePointer
\ No newline at end of file

skiko/src/commonTest/kotlin/org/jetbrains/skia/PathTests.kt

+package org.jetbrains.skia
+
+import org.jetbrains.skia.impl.use
+import kotlin.test.Test
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import org.jetbrains.skiko.tests.runTest
+import org.jetbrains.skia.tests.assertCloseEnough
+
+
+class PathTests {
+    @Test
+    fun iterTest() = runTest {
+        Path().moveTo(10f, 10f).lineTo(20f, 0f).lineTo(20f, 20f).closePath().use { p ->
+            p.iterator().use { i ->
+                assertTrue(i.hasNext())
+
+                var s = i.next()!!
+                assertEquals(PathVerb.MOVE, s.verb)
+                assertEquals(Point(10f, 10f), s.p0)
+                assertTrue(s.isClosedContour, "segment[0] is a closed contour")
+                assertTrue(i.hasNext())
+
+                s = i.next()!!
+                assertEquals(PathVerb.LINE, s.verb)
+                assertEquals(Point(10f, 10f), s.p0)
+                assertEquals(Point(20f, 0f), s.p1)
+                assertFalse(s.isCloseLine, "segment[1] is a closed line")
+                assertTrue(i.hasNext())
+
+                s = i.next()!!
+                assertEquals(PathVerb.LINE, s.verb)
+                assertEquals(Point(20f, 0f), s.p0)
+                assertEquals(Point(20f, 20f), s.p1)
+                assertFalse(s.isCloseLine, "segment[2] is a closed line")
+                assertTrue(i.hasNext())
+
+                s = i.next()!!
+                assertEquals(PathVerb.LINE, s.verb)
+                assertEquals(Point(20f, 20f), s.p0)
+                assertEquals(Point(10f, 10f), s.p1)
+                assertTrue(s.isCloseLine, "segment[3] is a closed line")
+                assertTrue(i.hasNext())
+
+                s = i.next()!!
+                assertEquals(PathVerb.CLOSE, s.verb)
+                assertEquals(Point(10f, 10f), s.p0)
+                assertFalse(i.hasNext())
+                assertFailsWith<NoSuchElementException> {
+                    i.next()
+                }
+            }
+        }
+    }
+
+    @Test
+    fun convexityTest() = runTest {
+        Path().lineTo(40f, 20f).lineTo(0f, 40f).lineTo(0f, 0f).closePath().use { p -> assertTrue(p.isConvex) }
+        Path().lineTo(40f, 40f).lineTo(40f, 0f).lineTo(0f, 40f).lineTo(0f, 0f).closePath().use { p ->
+            assertFalse(p.isConvex)
+        }
+    }
+
+
+}
\ No newline at end of file

skiko/src/jvmTest/kotlin/org/jetbrains/skiko/helpers/assertCloseEnough.kt → skiko/src/commonTest/kotlin/org/jetbrains/skia/util/assertCloseEnough.kt

-package org.jetbrains.skiko.skija
+package org.jetbrains.skia.tests
 
 import org.jetbrains.skia.Matrix33
 import org.jetbrains.skia.Point

skiko/src/jvmTest/kotlin/org/jetbrains/skiko/helpers/makeFromResource.kt → skiko/src/commonTest/kotlin/org/jetbrains/skia/util/makeFromResource.kt

-package org.jetbrains.skiko.skija
+package org.jetbrains.skia.tests
 
 import org.jetbrains.skia.Data
 import org.jetbrains.skia.Typeface

skiko/src/jvmMain/cpp/common/PathSegmentIterator.cc

@@ -19,32 +19,52 @@ extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_PathSegmentIteratorKt
     return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deletePathSegmentIterator));
 }
 
-extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skia_PathSegmentIteratorKt_PathSegmentIterator_1nNext
-  (JNIEnv* env, jclass jclass, jlong ptr) {
+extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skia_PathSegmentIteratorKt_PathSegmentIterator_1nNext
+  (JNIEnv* env, jclass jclass, jlong ptr, jintArray result) {
     SkPath::Iter* instance = reinterpret_cast<SkPath::Iter*>(static_cast<uintptr_t>(ptr));
     SkPoint pts[4];
     SkPath::Verb verb = instance->next(pts);
-    jobject segment;
+
+    int context = verb;
+    if (instance -> isClosedContour()) {
+        context = context | (1 << 7);
+    }
+    if (instance -> isCloseLine()) {
+        context = context | (1 << 6);
+    }
+
     switch (verb) {
-        case SkPath::Verb::kDone_Verb:
-            segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorDone);
+        case SkPath::Verb::kDone_Verb: {
+            jint d[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, context};
+            env->SetIntArrayRegion(result, 0, 10, d);
             break;
+        }
         case SkPath::Verb::kMove_Verb:
-        case SkPath::Verb::kClose_Verb:
-            segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorMoveClose, static_cast<jint>(verb), pts[0].fX, pts[0].fY, instance->isClosedContour());
+        case SkPath::Verb::kClose_Verb: {
+            jint d[10] = { rawBits(pts[0].fX), rawBits(pts[0].fY), 0, 0, 0, 0, 0, 0, 0, context};
+            env->SetIntArrayRegion(result, 0, 10, d);
             break;
-        case SkPath::Verb::kLine_Verb:
-            segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorLine, pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, instance->isCloseLine(), instance->isClosedContour());
+        }
+        case SkPath::Verb::kLine_Verb: {
+            jint d[10] = { rawBits(pts[0].fX), rawBits(pts[0].fY), rawBits(pts[1].fX), rawBits(pts[1].fY), 0, 0, 0, 0, 0, context};
+            env->SetIntArrayRegion(result, 0, 10, d);
             break;
-        case SkPath::Verb::kQuad_Verb:
-            segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorQuad, pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY, instance->isClosedContour());
+        }
+        case SkPath::Verb::kQuad_Verb: {
+            jint d[10] = { rawBits(pts[0].fX), rawBits(pts[0].fY), rawBits(pts[1].fX), rawBits(pts[1].fY), rawBits(pts[2].fX), rawBits(pts[2].fY), 0, 0, 0, context};
+            env->SetIntArrayRegion(result, 0, 10, d);
             break;
-        case SkPath::Verb::kConic_Verb:
-            segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorConic, pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY, instance->conicWeight(), instance->isClosedContour());
+        }
+        case SkPath::Verb::kConic_Verb: {
+            jint d[10] = { rawBits(pts[0].fX), rawBits(pts[0].fY), rawBits(pts[1].fX), rawBits(pts[1].fY), rawBits(pts[2].fX), rawBits(pts[2].fY), 0, 0, rawBits(instance->conicWeight()), context};
+            env->SetIntArrayRegion(result, 0, 10, d);
             break;
-        case SkPath::Verb::kCubic_Verb:
-            segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorConic, pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY, pts[3].fX, pts[3].fY, instance->isClosedContour());
+        }
+        case SkPath::Verb::kCubic_Verb: {
+            jint d[10] = { rawBits(pts[0].fX), rawBits(pts[0].fY), rawBits(pts[1].fX), rawBits(pts[1].fY), rawBits(pts[2].fX), rawBits(pts[2].fY), rawBits(pts[3].fX), rawBits(pts[3].fY), 0, context};
+            env->SetIntArrayRegion(result, 0, 10, d);
             break;
         }
-    return segment;
+    }
+
 }

skiko/src/jvmTest/kotlin/org/jetbrains/skiko/FontMgrTest.kt

@@ -4,10 +4,10 @@ import org.jetbrains.skia.Data
 import org.jetbrains.skia.FontStyle
 import org.jetbrains.skia.Typeface
 import org.jetbrains.skia.paragraph.TypefaceFontProvider
-import org.jetbrains.skiko.skija.makeFromResource
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNull
+import org.jetbrains.skia.tests.makeFromResource
 
 class FontMgrTest {
     @Test

skiko/src/jvmTest/kotlin/org/jetbrains/skiko/PathMeasureTest.kt

@@ -4,9 +4,9 @@ import org.jetbrains.skia.Matrix33
 import org.jetbrains.skia.Path
 import org.jetbrains.skia.PathMeasure
 import org.jetbrains.skia.Point
-import org.jetbrains.skiko.skija.assertCloseEnough
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import org.jetbrains.skia.tests.assertCloseEnough
 
 class PathMeasureTest {
     @Test

skiko/src/jvmTest/kotlin/org/jetbrains/skiko/PathTest.kt

@@ -18,57 +18,6 @@ import kotlin.test.assertNull
 import kotlin.test.assertTrue
 
 class PathTest {
-    @Test
-    fun iterTest() {
-        Path().moveTo(10f, 10f).lineTo(20f, 0f).lineTo(20f, 20f).closePath().use { p ->
-            p.iterator().use { i ->
-                assertTrue(i.hasNext())
-
-                var s = i.next()!!
-                assertEquals(PathVerb.MOVE, s.verb)
-                assertEquals(Point(10f, 10f), s.p0)
-                assertTrue(s.isClosedContour)
-                assertTrue(i.hasNext())
-
-                s = i.next()!!
-                assertEquals(PathVerb.LINE, s.verb)
-                assertEquals(Point(10f, 10f), s.p0)
-                assertEquals(Point(20f, 0f), s.p1)
-                assertFalse(s.isCloseLine)
-                assertTrue(i.hasNext())
-
-                s = i.next()!!
-                assertEquals(PathVerb.LINE, s.verb)
-                assertEquals(Point(20f, 0f), s.p0)
-                assertEquals(Point(20f, 20f), s.p1)
-                assertFalse(s.isCloseLine)
-                assertTrue(i.hasNext())
-
-                s = i.next()!!
-                assertEquals(PathVerb.LINE, s.verb)
-                assertEquals(Point(20f, 20f), s.p0)
-                assertEquals(Point(10f, 10f), s.p1)
-                assertTrue(s.isCloseLine)
-                assertTrue(i.hasNext())
-
-                s = i.next()!!
-                assertEquals(PathVerb.CLOSE, s.verb)
-                assertEquals(Point(10f, 10f), s.p0)
-                assertFalse(i.hasNext())
-                assertFailsWith<NoSuchElementException> {
-                    i.next()
-                }
-            }
-        }
-    }
-
-    @Test
-    fun convexityTest() {
-        Path().lineTo(40f, 20f).lineTo(0f, 40f).lineTo(0f, 0f).closePath().use { p -> assertTrue(p.isConvex) }
-        Path().lineTo(40f, 40f).lineTo(40f, 0f).lineTo(0f, 40f).lineTo(0f, 0f).closePath().use { p ->
-            assertFalse(p.isConvex)
-        }
-    }
 
     @Test
     fun isShapeTest() {

skiko/src/jvmTest/kotlin/org/jetbrains/skiko/TestLineTest.kt

@@ -3,12 +3,12 @@ package org.jetbrains.skiko
 import org.jetbrains.skia.Font
 import org.jetbrains.skia.TextLine
 import org.jetbrains.skia.Typeface
-import org.jetbrains.skiko.skija.assertCloseEnough
-import org.jetbrains.skiko.skija.makeFromResource
 import kotlin.test.Test
 import kotlin.test.assertContentEquals
 import kotlin.test.assertEquals
 import kotlin.test.assertNotEquals
+import org.jetbrains.skia.tests.makeFromResource
+import org.jetbrains.skia.tests.assertCloseEnough
 
 class TextLineTest {
     private var inter36: Font = Font(Typeface.makeFromResource("InterHinted-Regular.ttf"), 36f)

skiko/src/jvmTest/kotlin/org/jetbrains/skiko/TypefaceTest.kt

@@ -6,7 +6,6 @@ import org.jetbrains.skia.FontStyle
 import org.jetbrains.skia.FontVariation
 import org.jetbrains.skia.FontVariationAxis
 import org.jetbrains.skia.Typeface
-import org.jetbrains.skiko.skija.makeFromResource
 import kotlin.test.Test
 import kotlin.test.assertContentEquals
 import kotlin.test.assertEquals
@@ -15,6 +14,7 @@ import kotlin.test.assertNotEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
+import org.jetbrains.skia.tests.makeFromResource
 
 class TypefaceTest {
 

skiko/src/jvmTest/kotlin/org/jetbrains/skiko/paragraph/FontCollectionTest.kt

@@ -5,7 +5,7 @@ import org.jetbrains.skia.FontStyle
 import org.jetbrains.skia.Typeface
 import org.jetbrains.skia.paragraph.FontCollection
 import org.jetbrains.skia.paragraph.TypefaceFontProvider
-import org.jetbrains.skiko.skija.makeFromResource
+import org.jetbrains.skia.tests.makeFromResource
 import kotlin.test.Test
 import kotlin.test.assertContentEquals
 import kotlin.test.assertEquals