Further commonization of skiko events. (#430)

samples/SkiaMultiplatformSample/src/commonMain/kotlin/org/jetbrains/skiko/sample/Clocks.kt

@@ -129,11 +129,11 @@ class Clocks(private val layer: SkiaLayer): SkikoView {
             SkikoPointerEventKind.SCROLL -> {
                 when (event.modifiers) {
                     SkikoInputModifiers.CONTROL -> {
-                        rotate += if (event.y < 0) -5.0 else 5.0
+                        rotate += if (event.deltaY < 0) -5.0 else 5.0
                     }
                     else -> {
                         if (event.y != 0.0) {
-                            scale *= if (event.y < 0) 0.9 else 1.1
+                            scale *= if (event.deltaY < 0) 0.9 else 1.1
                         }
                     }
                 }
@@ -194,9 +194,16 @@ class Clocks(private val layer: SkiaLayer): SkikoView {
         }
     }
 
+    override fun onTouchEvent(events: Array<SkikoTouchEvent>) {
+        val event = events.first()
+        if (event.kind == SkikoTouchEventKind.STARTED) {
+            xpos = event.x - xOffset
+            ypos = event.y - yOffset
+        }
+    }
+
     override fun onGestureEvent(event: SkikoGestureEvent) {
         when (event.kind) {
-            SkikoGestureEventKind.PRESS,
             SkikoGestureEventKind.TAP -> {
                 xpos = event.x - xOffset
                 ypos = event.y - yOffset

skiko/.run/test.run.xml

@@ -13,9 +13,7 @@
       </option>
       <option name="vmOptions" />
     </ExternalSystemSettings>
-    <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
-    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
-    <DebugAllEnabled>false</DebugAllEnabled>
+    <GradleScriptDebugEnabled>true</GradleScriptDebugEnabled>
     <method v="2" />
   </configuration>
-</component>
+</component>
\ No newline at end of file

skiko/src/awtMain/kotlin/org/jetbrains/skiko/Convertors.jvm.kt

@@ -77,11 +77,11 @@ fun BufferedImage.toImage(): Image {
 
 fun toSkikoEvent(event: MouseEvent): SkikoPointerEvent {
     return SkikoPointerEvent(
-        event.x.toDouble(),
-        event.y.toDouble(),
-        toSkikoMouseButtons(event.modifiersEx),
-        toSkikoModifiers(event.modifiersEx),
-        when(event.id) {
+        x = event.x.toDouble(),
+        y = event.y.toDouble(),
+        buttons = toSkikoMouseButtons(event.modifiersEx),
+        modifiers = toSkikoModifiers(event.modifiersEx),
+        kind = when(event.id) {
             MouseEvent.MOUSE_PRESSED -> SkikoPointerEventKind.DOWN
             MouseEvent.MOUSE_RELEASED -> SkikoPointerEventKind.UP
             MouseEvent.MOUSE_DRAGGED -> SkikoPointerEventKind.DRAG
@@ -90,7 +90,8 @@ fun toSkikoEvent(event: MouseEvent): SkikoPointerEvent {
             MouseEvent.MOUSE_EXITED -> SkikoPointerEventKind.EXIT
             else -> SkikoPointerEventKind.UNKNOWN
         },
-        event
+        timestamp = event.`when`,
+        platform = event
     )
 }
 
@@ -98,60 +99,65 @@ fun toSkikoEvent(event: MouseWheelEvent): SkikoPointerEvent {
     val scrollAmount = event.getPreciseWheelRotation()
     val modifiers = toSkikoModifiers(event.modifiersEx)
     val isShiftPressed = modifiers.has(SkikoInputModifiers.SHIFT)
-    val x = if (isShiftPressed) scrollAmount else 0.0
-    val y = if (isShiftPressed) 0.0 else scrollAmount
+    val deltaX = if (isShiftPressed) scrollAmount else 0.0
+    val deltaY = if (isShiftPressed) 0.0 else scrollAmount
     return SkikoPointerEvent(
-        x,
-        y,
-        toSkikoMouseButtons(event.modifiersEx),
-        modifiers,
-        when(event.id) {
+        x = event.x.toDouble(),
+        y = event.y.toDouble(),
+        deltaX = deltaX,
+        deltaY = deltaY,
+        buttons = toSkikoMouseButtons(event.modifiersEx),
+        modifiers = modifiers,
+        kind = when(event.id) {
             MouseEvent.MOUSE_WHEEL-> SkikoPointerEventKind.SCROLL
             else -> SkikoPointerEventKind.UNKNOWN
         },
-        event
+        timestamp = event.`when`,
+        platform = event
     )
 }
 
 fun toSkikoEvent(event: KeyEvent): SkikoKeyboardEvent {
-    var key = event.keyCode
-    val side = event.getKeyLocation()
-    if (side == KEY_LOCATION_RIGHT) {
-        if (
-            key == SkikoKey.KEY_LEFT_CONTROL.value ||
-            key == SkikoKey.KEY_LEFT_SHIFT.value ||
-            key == SkikoKey.KEY_LEFT_META.value
-        )
-        key = key.or(0x80000000.toInt())
-    }
-    if (side == KEY_LOCATION_NUMPAD) {
-        if (key == SkikoKey.KEY_ENTER.value) {
-            key = key.or(0x80000000.toInt())
-        }
-    }
     return SkikoKeyboardEvent(
-        SkikoKey.valueOf(key),
+        SkikoKey.valueOf(toSkikoKey(event)),
         toSkikoModifiers(event.modifiersEx),
         when(event.id) {
             KeyEvent.KEY_PRESSED -> SkikoKeyboardEventKind.DOWN
             KeyEvent.KEY_RELEASED -> SkikoKeyboardEventKind.UP
             else -> SkikoKeyboardEventKind.UNKNOWN
         },
+        event.`when`,
         event
     )
 }
 
-fun toSkikoTypeEvent(event: KeyEvent): SkikoInputEvent {
+fun toSkikoTypeEvent(typeEvent: KeyEvent, keyEvent: KeyEvent?): SkikoInputEvent {
+    var key: Int = -1
+    var modifiers = SkikoInputModifiers.EMPTY
+    if (keyEvent != null) {
+        key = toSkikoKey(keyEvent)
+        modifiers = toSkikoModifiers(keyEvent.modifiersEx)
+    }
     return SkikoInputEvent(
-        event.keyChar.toString(),
+        typeEvent.keyChar.toString(),
+        SkikoKey.valueOf(key),
+        modifiers,
         SkikoKeyboardEventKind.TYPE,
-        event
+        typeEvent
     )
 }
 
-fun toSkikoEvent(event: InputMethodEvent): SkikoInputEvent {
+fun toSkikoTypeEvent(event: InputMethodEvent, keyEvent: KeyEvent?): SkikoInputEvent {
+    var key: Int = -1
+    var modifiers = SkikoInputModifiers.EMPTY
+    if (keyEvent != null) {
+        key = toSkikoKey(keyEvent)
+        modifiers = toSkikoModifiers(keyEvent.modifiersEx)
+    }
     return SkikoInputEvent(
         "",
+        SkikoKey.valueOf(key),
+        modifiers,
         SkikoKeyboardEventKind.TYPE,
         event
     )

skiko/src/awtMain/kotlin/org/jetbrains/skiko/SkiaLayer.awt.kt

@@ -157,6 +157,8 @@ actual open class SkiaLayer internal constructor(
         jComponent.add(this)
     }
 
+    private var keyEvent: KeyEvent? = null
+
     fun addView(view: SkikoView) {
         skikoView = view
         addMouseListener(object : MouseAdapter() {
@@ -191,22 +193,24 @@ actual open class SkiaLayer internal constructor(
 
         addKeyListener(object : KeyAdapter() {
             override fun keyPressed(e: KeyEvent) {
+                keyEvent = e
                 skikoView?.onKeyboardEvent(toSkikoEvent(e))
             }
             override fun keyReleased(e: KeyEvent) {
+                keyEvent = e
                 skikoView?.onKeyboardEvent(toSkikoEvent(e))
             }
             override fun keyTyped(e: KeyEvent) {
-                skikoView?.onInputEvent(toSkikoTypeEvent(e))
+                skikoView?.onInputEvent(toSkikoTypeEvent(e, keyEvent))
             }
         })
 
         addInputMethodListener(object : InputMethodListener {
             override fun caretPositionChanged(e: InputMethodEvent) {
-                skikoView?.onInputEvent(toSkikoEvent(e))
+                skikoView?.onInputEvent(toSkikoTypeEvent(e, keyEvent))
             }
             override fun inputMethodTextChanged(e: InputMethodEvent) {
-                skikoView?.onInputEvent(toSkikoEvent(e))
+                skikoView?.onInputEvent(toSkikoTypeEvent(e, keyEvent))
             }
         })
     }
@@ -546,6 +550,7 @@ internal fun defaultFPSCounter(
 }
 
 // InputEvent is abstract, so we wrap to match modality.
+actual typealias SkikoTouchPlatformEvent = Any
 actual typealias SkikoGesturePlatformEvent = Any
 actual typealias SkikoPlatformInputEvent = Any
 actual typealias SkikoPlatformKeyboardEvent = KeyEvent

skiko/src/awtMain/kotlin/org/jetbrains/skiko/SkikoKey.awt.kt

@@ -5,7 +5,7 @@ import java.awt.event.KeyEvent.*
 actual enum class SkikoKey(val value: Int) {
     KEY_UNKNOWN(-1),
     KEY_A(VK_A),
-    KEY_S(VK_B),
+    KEY_S(VK_S),
     KEY_D(VK_D),
     KEY_F(VK_F),
     KEY_H(VK_H),

skiko/src/commonMain/kotlin/org/jetbrains/skiko/Events.kt

@@ -199,7 +199,7 @@ expect enum class SkikoKey {
 }
 
 enum class SkikoGestureEventKind {
-    PRESS, TAP, PAN, PINCH, ROTATION, LONGPRESS, SWIPE, UNKNOWN
+    TAP, PAN, PINCH, ROTATION, LONGPRESS, SWIPE, UNKNOWN
 }
 enum class SkikoGestureEventDirection {
     UP, DOWN, LEFT, RIGHT, UNKNOWN
@@ -209,7 +209,8 @@ enum class SkikoGestureEventState {
 }
 expect class SkikoGesturePlatformEvent
 data class SkikoGestureEvent(
-    val x: Double, val y: Double,
+    val x: Double,
+    val y: Double,
     val velocity: Double = 0.0,
     val direction: SkikoGestureEventDirection = SkikoGestureEventDirection.UNKNOWN,
     val rotation: Double = 0.0,
@@ -219,9 +220,23 @@ data class SkikoGestureEvent(
     val platform: SkikoGesturePlatformEvent? = null
 )
 
+enum class SkikoTouchEventKind {
+    STARTED, ENDED, MOVED, CANCELLED, UNKNOWN
+}
+expect class SkikoTouchPlatformEvent
+data class SkikoTouchEvent(
+    val x: Double,
+    val y: Double,
+    val kind: SkikoTouchEventKind = SkikoTouchEventKind.UNKNOWN,
+    val timestamp: Long = 0,
+    val platform: SkikoTouchPlatformEvent? = null
+)
+
 expect class SkikoPlatformInputEvent
 data class SkikoInputEvent(
     val input: String,
+    val key: SkikoKey,
+    val modifiers: SkikoInputModifiers = SkikoInputModifiers.EMPTY,
     val kind: SkikoKeyboardEventKind,
     val platform: SkikoPlatformInputEvent?
 )
@@ -234,6 +249,7 @@ data class SkikoKeyboardEvent(
     val key: SkikoKey,
     val modifiers: SkikoInputModifiers = SkikoInputModifiers.EMPTY,
     val kind: SkikoKeyboardEventKind,
+    val timestamp: Long = 0,
     val platform: SkikoPlatformKeyboardEvent?
 )
 
@@ -243,10 +259,14 @@ enum class SkikoPointerEventKind {
 
 expect class SkikoPlatformPointerEvent
 data class SkikoPointerEvent(
-    val x: Double, val y: Double,
+    val x: Double,
+    val y: Double,
+    val deltaX: Double = 0.0,
+    val deltaY: Double = 0.0,
     val buttons: SkikoMouseButtons = SkikoMouseButtons.NONE,
     val modifiers: SkikoInputModifiers = SkikoInputModifiers.EMPTY,
     val kind: SkikoPointerEventKind,
+    val timestamp: Long = 0,
     val platform: SkikoPlatformPointerEvent?
 )
 

skiko/src/commonMain/kotlin/org/jetbrains/skiko/SkikoView.kt

@@ -7,6 +7,7 @@ interface SkikoView {
     fun onKeyboardEvent(event: SkikoKeyboardEvent) = Unit
     fun onPointerEvent(event: SkikoPointerEvent) = Unit
     fun onInputEvent(event: SkikoInputEvent) = Unit
+    fun onTouchEvent(events: Array<SkikoTouchEvent>) = Unit
     fun onGestureEvent(event: SkikoGestureEvent) = Unit
 
     // Rendering
@@ -38,6 +39,10 @@ open class GenericSkikoView(
         app.onPointerEvent(event)
     }
 
+    override fun onTouchEvent(events: Array<SkikoTouchEvent>) {
+        app.onTouchEvent(events)
+    }
+
     override fun onGestureEvent(event: SkikoGestureEvent) {
         app.onGestureEvent(event)
     }

skiko/src/iosMain/kotlin/org/jetbrains/skiko/Convertors.ios.kt

@@ -22,11 +22,15 @@ fun toSkikoGestureState(state: UIGestureRecognizerState ) : SkikoGestureEventSta
     }
 }
 
-fun toSkikoTypeEvent(character: String): SkikoInputEvent {
+fun toSkikoTypeEvent(character: String, event: UIPress?): SkikoInputEvent {
+    val key = if (event != null) SkikoKey.valueOf(event.key!!.keyCode) else SkikoKey.KEY_UNKNOWN
+    val modifiers = if (event != null) toSkikoModifiers(event) else SkikoInputModifiers.EMPTY
     return SkikoInputEvent(
         character,
+        key,
+        modifiers,
         SkikoKeyboardEventKind.TYPE,
-        UIEvent()
+        event
     )
 }
 
@@ -34,10 +38,12 @@ fun toSkikoKeyboardEvent(
     event: UIPress,
     kind: SkikoKeyboardEventKind
 ): SkikoKeyboardEvent {
+    val timestamp = (event.timestamp * 1_000).toLong()
     return SkikoKeyboardEvent(
         SkikoKey.valueOf(event.key!!.keyCode),
         toSkikoModifiers(event),
         kind,
+        timestamp,
         event
     )
 }

skiko/src/iosMain/kotlin/org/jetbrains/skiko/SkiaLayer.ios.kt

@@ -185,7 +185,8 @@ actual open class SkiaLayer {
 }
 
 // TODO: do properly
+actual typealias SkikoTouchPlatformEvent = UITouch
 actual typealias SkikoGesturePlatformEvent = UIEvent
-actual typealias SkikoPlatformInputEvent = UIEvent
+actual typealias SkikoPlatformInputEvent = UIPress
 actual typealias SkikoPlatformKeyboardEvent = UIPress
 actual typealias SkikoPlatformPointerEvent = UIEvent

skiko/src/iosMain/kotlin/org/jetbrains/skiko/SkikoViewController.kt

@@ -24,6 +24,7 @@ class SkikoViewController : UIViewController, UIKeyInputProtocol {
 
     override fun canBecomeFirstResponder() = true
 
+    private var keyEvent: UIPress? = null
     private var inputText: String = ""
     override fun hasText(): Boolean {
         return inputText.length > 0
@@ -31,7 +32,7 @@ class SkikoViewController : UIViewController, UIKeyInputProtocol {
 
     override fun insertText(theText: String) {
         inputText += theText
-        skikoLayer.skikoView?.onInputEvent(toSkikoTypeEvent(theText))
+        skikoLayer.skikoView?.onInputEvent(toSkikoTypeEvent(theText, keyEvent))
     }
 
     override fun deleteBackward() {
@@ -41,8 +42,9 @@ class SkikoViewController : UIViewController, UIKeyInputProtocol {
     override fun pressesBegan(presses: Set<*>, withEvent: UIPressesEvent?) {
         if (withEvent != null) {
             for (press in withEvent.allPresses) {
+                keyEvent = press as UIPress
                 skikoLayer.skikoView?.onKeyboardEvent(
-                    toSkikoKeyboardEvent(press as UIPress, SkikoKeyboardEventKind.DOWN)
+                    toSkikoKeyboardEvent(press, SkikoKeyboardEventKind.DOWN)
                 )
             }
         }
@@ -52,8 +54,9 @@ class SkikoViewController : UIViewController, UIKeyInputProtocol {
     override fun pressesEnded(presses: Set<*>, withEvent: UIPressesEvent?) {
         if (withEvent != null) {
             for (press in withEvent.allPresses) {
+                keyEvent = press as UIPress
                 skikoLayer.skikoView?.onKeyboardEvent(
-                    toSkikoKeyboardEvent(press as UIPress, SkikoKeyboardEventKind.UP)
+                    toSkikoKeyboardEvent(press, SkikoKeyboardEventKind.UP)
                 )
             }
         }
@@ -62,20 +65,58 @@ class SkikoViewController : UIViewController, UIKeyInputProtocol {
 
     override fun touchesBegan(touches: Set<*>, withEvent: UIEvent?) {
         super.touchesBegan(touches, withEvent)
-        val sender = (touches.elementAt(0) as UITouch)
-        val (x, y) = sender.locationInView(null).useContents { x to y }
-        skikoLayer.skikoView?.onGestureEvent(
-            SkikoGestureEvent(
-                x = x,
-                y = y,
-                kind = SkikoGestureEventKind.PRESS,
-                state = SkikoGestureEventState.PRESSED
+        val events: MutableList<SkikoTouchEvent> = mutableListOf()
+        for (touch in touches) {
+            val event = touch as UITouch
+            val (x, y) = event.locationInView(null).useContents { x to y }
+            val timestamp = (event.timestamp * 1_000).toLong()
+            events.add(
+                SkikoTouchEvent(x, y, SkikoTouchEventKind.STARTED, timestamp, event)
             )
-        )
+        }
+        skikoLayer.skikoView?.onTouchEvent(events.toTypedArray())
     }
 
     override fun touchesEnded(touches: Set<*>, withEvent: UIEvent?) {
         super.touchesEnded(touches, withEvent)
+        val events: MutableList<SkikoTouchEvent> = mutableListOf()
+        for (touch in touches) {
+            val event = touch as UITouch
+            val (x, y) = event.locationInView(null).useContents { x to y }
+            val timestamp = (event.timestamp * 1_000).toLong()
+            events.add(
+                SkikoTouchEvent(x, y, SkikoTouchEventKind.ENDED, timestamp, event)
+            )
+        }
+        skikoLayer.skikoView?.onTouchEvent(events.toTypedArray())
+    }
+
+    override fun touchesMoved(touches: Set<*>, withEvent: UIEvent?) {
+        super.touchesMoved(touches, withEvent)
+        val events: MutableList<SkikoTouchEvent> = mutableListOf()
+        for (touch in touches) {
+            val event = touch as UITouch
+            val (x, y) = event.locationInView(null).useContents { x to y }
+            val timestamp = (event.timestamp * 1_000).toLong()
+            events.add(
+                SkikoTouchEvent(x, y, SkikoTouchEventKind.MOVED, timestamp, event)
+            )
+        }
+        skikoLayer.skikoView?.onTouchEvent(events.toTypedArray())
+    }
+
+    override fun touchesCancelled(touches: Set<*>, withEvent: UIEvent?) {
+        super.touchesCancelled(touches, withEvent)
+        val events: MutableList<SkikoTouchEvent> = mutableListOf()
+        for (touch in touches) {
+            val event = touch as UITouch
+            val (x, y) = event.locationInView(null).useContents { x to y }
+            val timestamp = (event.timestamp * 1_000).toLong()
+            events.add(
+                SkikoTouchEvent(x, y, SkikoTouchEventKind.CANCELLED, timestamp, event)
+            )
+        }
+        skikoLayer.skikoView?.onTouchEvent(events.toTypedArray())
     }
 
     internal lateinit var appFactory: (SkiaLayer) -> SkikoView

skiko/src/jsMain/kotlin/org/jetbrains/skiko/Convertors.js.kt

@@ -11,12 +11,13 @@ fun toSkikoEvent(
     kind: SkikoPointerEventKind
 ): SkikoPointerEvent {
     return SkikoPointerEvent(
-        event.offsetX,
-        event.offsetY,
-        toSkikoMouseButtons(event, buttons),
-        toSkikoModifiers(event),
-        kind,
-        event
+        x = event.offsetX,
+        y = event.offsetY,
+        buttons = toSkikoMouseButtons(event, buttons),
+        modifiers = toSkikoModifiers(event),
+        kind = kind,
+        timestamp = event.timeStamp.toLong(),
+        platform = event
     )
 }
 
@@ -24,12 +25,13 @@ fun toSkikoDragEvent(
     event: MouseEvent
 ): SkikoPointerEvent {
     return SkikoPointerEvent(
-        event.offsetX,
-        event.offsetY,
-        toSkikoMouseButtons(event, true),
-        toSkikoModifiers(event),
-        SkikoPointerEventKind.DRAG,
-        event
+        x = event.offsetX,
+        y = event.offsetY,
+        buttons = toSkikoMouseButtons(event, true),
+        modifiers = toSkikoModifiers(event),
+        kind = SkikoPointerEventKind.DRAG,
+        timestamp = event.timeStamp.toLong(),
+        platform = event
     )
 }
 
@@ -41,6 +43,7 @@ fun toSkikoEvent(
         SkikoKey.valueOf(toSkikoKey(event)),
         toSkikoModifiers(event),
         kind,
+        event.timeStamp.toLong(),
         event
     )
 }
@@ -50,12 +53,15 @@ fun toSkikoScrollEvent(
     buttons: Boolean
 ): SkikoPointerEvent {
     return SkikoPointerEvent(
-        event.deltaX,
-        event.deltaY,
-        toSkikoMouseButtons(event, buttons),
-        toSkikoModifiers(event),
-        SkikoPointerEventKind.SCROLL,
-        event
+        x = event.offsetX,
+        y = event.offsetY,
+        deltaX = event.deltaX,
+        deltaY = event.deltaY,
+        buttons = toSkikoMouseButtons(event, buttons),
+        modifiers = toSkikoModifiers(event),
+        kind = SkikoPointerEventKind.SCROLL,
+        timestamp = event.timeStamp.toLong(),
+        platform = event
     )
 }
 

skiko/src/jsMain/kotlin/org/jetbrains/skiko/SkiaLayer.js.kt

@@ -105,6 +105,7 @@ actual open class SkiaLayer {
 
 var onContentScaleChanged: ((Float) -> Unit)? = null
 
+actual typealias SkikoTouchPlatformEvent = Any
 actual typealias SkikoGesturePlatformEvent = Any
 actual typealias SkikoPlatformInputEvent = InputEvent
 actual typealias SkikoPlatformKeyboardEvent = KeyboardEvent

skiko/src/linuxMain/kotlin/org/jetbrains/skiko/SkiaLayer.linux.kt

@@ -25,6 +25,7 @@ actual open class SkiaLayer  {
 }
 
 // TODO: do properly
+actual typealias SkikoTouchPlatformEvent = Any
 actual typealias SkikoGesturePlatformEvent = Any
 actual typealias SkikoPlatformInputEvent = Any
 actual typealias SkikoPlatformKeyboardEvent = Any

skiko/src/macosMain/kotlin/org/jetbrains/skiko/Convertors.macos.kt

@@ -15,13 +15,15 @@ fun toSkikoEvent(
     view.frame.useContents {
        ypos = size.height - ypos
     }
+    val timestamp = (event.timestamp * 1_000).toLong()
     return SkikoPointerEvent(
-        xpos,
-        ypos,
-        toSkikoMouseButtons(event, kind),
-        toSkikoModifiers(event),
-        kind,
-        event
+        x = xpos,
+        y = ypos,
+        buttons = toSkikoMouseButtons(event, kind),
+        modifiers = toSkikoModifiers(event),
+        kind = kind,
+        timestamp = timestamp,
+        platform = event
     )
 }
 
@@ -38,6 +40,7 @@ fun toSkikoEvent(
     view.frame.useContents {
        ypos = size.height - ypos
     }
+    val timestamp = (event.timestamp * 1_000).toLong()
     var buttons: SkikoMouseButtons
     if (kind == SkikoPointerEventKind.DOWN) {
         buttonsFlags = buttonsFlags.or(button.value)
@@ -47,25 +50,38 @@ fun toSkikoEvent(
         buttonsFlags = buttonsFlags.xor(button.value)
     }
     return SkikoPointerEvent(
-        xpos,
-        ypos,
-        buttons,
-        toSkikoModifiers(event),
-        kind,
-        event
+        x = xpos,
+        y = ypos,
+        buttons = buttons,
+        modifiers = toSkikoModifiers(event),
+        kind = kind,
+        timestamp = timestamp,
+        platform = event
     )
 }
 
 fun toSkikoScrollEvent(
-    event: NSEvent
+    event: NSEvent,
+    view: NSView
 ): SkikoPointerEvent {
+    var (xpos, ypos) = event.locationInWindow.useContents {
+        x to y
+    }
+    // Translate.
+    view.frame.useContents {
+       ypos = size.height - ypos
+    }
+    val timestamp = (event.timestamp * 1_000).toLong()
     return SkikoPointerEvent(
-        event.deltaX,
-        event.deltaY,
-        SkikoMouseButtons.NONE,
-        toSkikoModifiers(event),
-        SkikoPointerEventKind.SCROLL,
-        event
+        x = xpos,
+        y = ypos,
+        deltaX = event.deltaX,
+        deltaY = event.deltaY,
+        buttons = SkikoMouseButtons.NONE,
+        modifiers = toSkikoModifiers(event),
+        kind = SkikoPointerEventKind.SCROLL,
+        timestamp = timestamp,
+        platform = event
     )
 }
 
@@ -73,20 +89,26 @@ fun toSkikoEvent(
     event: NSEvent,
     kind: SkikoKeyboardEventKind
 ): SkikoKeyboardEvent {
+    val timestamp = (event.timestamp * 1_000).toLong()
     return SkikoKeyboardEvent(
         SkikoKey.valueOf(event.keyCode.toInt()),
         toSkikoModifiers(event),
         kind,
+        timestamp,
         event
     )
 }
 
 fun toSkikoTypeEvent(
     character: String,
-    event: NSEvent,
+    event: NSEvent?,
 ): SkikoInputEvent {
+    val key = if (event != null) SkikoKey.valueOf(event.keyCode.toInt()) else SkikoKey.KEY_UNKNOWN
+    val modifiers = if (event != null) toSkikoModifiers(event) else SkikoInputModifiers.EMPTY
     return SkikoInputEvent(
         character,
+        key,
+        modifiers,
         SkikoKeyboardEventKind.TYPE,
         event
     )
@@ -114,10 +136,12 @@ fun toSkikoEvent(
     if (modifierKeyUpFlag == actionAllKeyUpFlag) {
         kind = SkikoKeyboardEventKind.UP
     }
+    val timestamp = (event.timestamp * 1_000).toLong()
     return SkikoKeyboardEvent(
         SkikoKey.valueOf(event.keyCode.toInt()),
         toSkikoModifiers(event),
         kind,
+        timestamp,
         event
     )
 }

skiko/src/macosMain/kotlin/org/jetbrains/skiko/SkiaLayer.macos.kt

@@ -108,17 +108,19 @@ actual open class SkiaLayer() {
                 skikoView?.onPointerEvent(toSkikoEvent(event, SkikoPointerEventKind.DRAG, nsView))
             }
             override fun scrollWheel(event: NSEvent) {
-                skikoView?.onPointerEvent(toSkikoScrollEvent(event))
+                skikoView?.onPointerEvent(toSkikoScrollEvent(event, nsView))
             }
             override fun keyDown(event: NSEvent) {
-                skikoView?.onKeyboardEvent(toSkikoEvent(event, SkikoKeyboardEventKind.DOWN))
                 keyEvent = event
+                skikoView?.onKeyboardEvent(toSkikoEvent(event, SkikoKeyboardEventKind.DOWN))
                 interpretKeyEvents(listOf(event))
             }
             override fun flagsChanged(event: NSEvent) {
+                keyEvent = event
                 skikoView?.onKeyboardEvent(toSkikoEvent(event))
             }
             override fun keyUp(event: NSEvent) {
+                keyEvent = event
                 skikoView?.onKeyboardEvent(toSkikoEvent(event, SkikoKeyboardEventKind.UP))
             }
             
@@ -151,7 +153,7 @@ actual open class SkiaLayer() {
                 } else {
                     character = string as String
                 }
-                skikoView?.onInputEvent(toSkikoTypeEvent(character, keyEvent!!))
+                skikoView?.onInputEvent(toSkikoTypeEvent(character, keyEvent))
             }
             override fun setMarkedText(string: Any, selectedRange: CValue<NSRange>, replacementRange: CValue<NSRange>) {
                 if (string is NSAttributedString) {
@@ -232,6 +234,7 @@ actual open class SkiaLayer() {
 }
 
 // TODO: do properly
+actual typealias SkikoTouchPlatformEvent = NSEvent
 actual typealias SkikoGesturePlatformEvent = NSEvent
 actual typealias SkikoPlatformInputEvent = NSEvent
 actual typealias SkikoPlatformKeyboardEvent = NSEvent