Skiko events update. Text/Key input for (jvm, macos, ios). (#422)

* Skiko events uptade. Text/Key input for (jvm, macos, ios).

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

@@ -12,6 +12,7 @@ import kotlin.math.PI
 import kotlin.math.pow
 
 class Clocks(private val layer: SkiaLayer): SkikoView {
+    private val platformYOffset = if (hostOs == OS.Ios) 50f else 5f
     private var frame = 0
     private var xpos = 0.0
     private var ypos = 0.0
@@ -22,6 +23,8 @@ class Clocks(private val layer: SkiaLayer): SkikoView {
     private var rotate = 0.0
     private val fontCollection = FontCollection()
         .setDefaultFontManager(FontMgr.default)
+    private val style = ParagraphStyle()
+    private var inputText = ""
 
     override fun onRender(canvas: Canvas, width: Int, height: Int, nanoTime: Long) {
         canvas.translate(xOffset.toFloat(), yOffset.toFloat())
@@ -40,7 +43,7 @@ class Clocks(private val layer: SkiaLayer): SkikoView {
         }
         val watchFillHover = Paint().apply { color = 0xFFE4FF01.toInt() }
         for (x in 0 .. width - 50 step 50) {
-            for (y in 20 .. height - 50 step 50) {
+            for (y in 30 + platformYOffset.toInt() .. height - 50 step 50) {
                 val hover = 
                     (xpos - xOffset) / scale > x &&
                     (xpos - xOffset) / scale < x + 50 &&
@@ -83,14 +86,22 @@ class Clocks(private val layer: SkiaLayer): SkikoView {
             }
         }
 
-        val style = ParagraphStyle()
         val renderInfo = ParagraphBuilder(style, fontCollection)
             .pushStyle(TextStyle().setColor(0xFF000000.toInt()))
             .addText("Graphics API: ${layer.renderApi} ✿ﾟ ${currentSystemTheme}")
             .popStyle()
             .build()
         renderInfo.layout(Float.POSITIVE_INFINITY)
-        renderInfo.paint(canvas, 5f, 50f)
+        renderInfo.paint(canvas, 5f, platformYOffset)
+
+        val input = ParagraphBuilder(style, fontCollection)
+            .pushStyle(TextStyle().setColor(0xFF000000.toInt()))
+            .addText("TextInput: $inputText")
+            .popStyle()
+            .build()
+        input.layout(Float.POSITIVE_INFINITY)
+        input.paint(canvas, 5f, platformYOffset + 20f)
+        
         val frames = ParagraphBuilder(style, fontCollection)
             .pushStyle(TextStyle().setColor(0xff9BC730L.toInt()).setFontSize(20f))
             .addText("Frames: ${frame++}\nAngle: $rotate")
@@ -132,20 +143,30 @@ class Clocks(private val layer: SkiaLayer): SkikoView {
     }
 
     override fun onInputEvent(event: SkikoInputEvent) {
-        // TODO: provide example that covers all features of text input event
+        if (event.input != "\b") {
+            inputText += event.input
+        }
     }
 
     override fun onKeyboardEvent(event: SkikoKeyboardEvent) {
         if (event.kind == SkikoKeyboardEventKind.DOWN) {
             when (event.key) {
-                SkikoKey.KEY_NUMPAD_ADD,
-                SkikoKey.KEY_I -> scale *= 1.1
-                SkikoKey.KEY_NUMPAD_SUBTRACT,
-                SkikoKey.KEY_O -> scale *= 0.9
+                SkikoKey.KEY_NUMPAD_ADD -> scale *= 1.1
+                SkikoKey.KEY_I -> {
+                    if (event.modifiers == SkikoInputModifiers.CONTROL) {
+                        scale *= 1.1
+                    }
+                }
+                SkikoKey.KEY_NUMPAD_SUBTRACT -> scale *= 0.9
+                SkikoKey.KEY_O -> {
+                    if (event.modifiers == SkikoInputModifiers.CONTROL) {
+                        scale *= 0.9
+                    }
+                }
                 SkikoKey.KEY_R -> {
                     if (event.modifiers == SkikoInputModifiers.SHIFT) {
                         rotate -= 5.0
-                    } else {
+                    } else if (event.modifiers == SkikoInputModifiers.CONTROL) {
                         rotate += 5.0
                     }
                 }
@@ -163,6 +184,11 @@ class Clocks(private val layer: SkiaLayer): SkikoView {
                     rotate = 0.0
                     scale = 1.0
                 }
+                SkikoKey.KEY_BACKSPACE -> {
+                    if (inputText.isNotEmpty()) {
+                        inputText = inputText.dropLast(1)
+                    }
+                }
                 else -> {}
             }
         }

samples/SkiaMultiplatformSample/src/macosMain/kotlin/org/jetbrains/skiko/sample/App.macos.kt

@@ -40,9 +40,8 @@ fun main() {
         backing = NSBackingStoreBuffered,
         defer = false
     ) {
-        override fun canBecomeKeyWindow(): Boolean {
-            return true
-        }
+        override fun canBecomeKeyWindow() = true
+        override fun canBecomeMainWindow() = true
     }
     val skiaLayer = SkiaLayer()
     skiaLayer.skikoView = GenericSkikoView(skiaLayer, makeApp(skiaLayer))

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

@@ -153,6 +153,7 @@ expect enum class SkikoKey {
     KEY_RIGHT_SHIFT,
     KEY_RIGHT_ALT,
     KEY_RIGHT_CONTROL,
+    KEY_MENU,
     KEY_UP,
     KEY_DOWN,
     KEY_LEFT,
@@ -194,7 +195,7 @@ expect enum class SkikoKey {
     KEY_NUMPAD_SUBTRACT,
     KEY_NUMPAD_MULTIPLY,
     KEY_NUMPAD_DIVIDE,
-    KEY_NUMPAD_DECIMAC;
+    KEY_NUMPAD_DECIMAL;
 }
 
 enum class SkikoGestureEventKind {
@@ -221,6 +222,7 @@ data class SkikoGestureEvent(
 expect class SkikoPlatformInputEvent
 data class SkikoInputEvent(
     val input: String,
+    val kind: SkikoKeyboardEventKind,
     val platform: SkikoPlatformInputEvent?
 )
 

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

@@ -21,3 +21,41 @@ fun toSkikoGestureState(state: UIGestureRecognizerState ) : SkikoGestureEventSta
         else -> SkikoGestureEventState.UNKNOWN
     }
 }
+
+fun toSkikoTypeEvent(character: String): SkikoInputEvent {
+    return SkikoInputEvent(
+        character,
+        SkikoKeyboardEventKind.TYPE,
+        UIEvent()
+    )
+}
+
+fun toSkikoKeyboardEvent(
+    event: UIPress,
+    kind: SkikoKeyboardEventKind
+): SkikoKeyboardEvent {
+    return SkikoKeyboardEvent(
+        SkikoKey.valueOf(event.key!!.keyCode),
+        toSkikoModifiers(event),
+        kind,
+        event
+    )
+}
+
+private fun toSkikoModifiers(event: UIPress): SkikoInputModifiers {
+    var result = 0
+    val modifiers = event.key!!.modifierFlags
+    if (modifiers and UIKeyModifierAlternate != 0L) {
+        result = result.or(SkikoInputModifiers.ALT.value)
+    }
+    if (modifiers and UIKeyModifierShift != 0L) {
+        result = result.or(SkikoInputModifiers.SHIFT.value)
+    }
+    if (modifiers and UIKeyModifierControl != 0L) {
+        result = result.or(SkikoInputModifiers.CONTROL.value)
+    }
+    if (modifiers and UIKeyModifierCommand != 0L) {
+        result = result.or(SkikoInputModifiers.META.value)
+    }
+    return SkikoInputModifiers(result)
+}

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

@@ -187,119 +187,5 @@ actual open class SkiaLayer {
 // TODO: do properly
 actual typealias SkikoGesturePlatformEvent = UIEvent
 actual typealias SkikoPlatformInputEvent = UIEvent
-actual typealias SkikoPlatformKeyboardEvent = UIEvent
+actual typealias SkikoPlatformKeyboardEvent = UIPress
 actual typealias SkikoPlatformPointerEvent = UIEvent
-
-actual enum class SkikoKey(val value: Int) {
-    KEY_UNKNOWN(-1),
-    KEY_A(0),
-    KEY_S(1),
-    KEY_D(2),
-    KEY_F(3),
-    KEY_H(4),
-    KEY_G(5),
-    KEY_Z(6),
-    KEY_X(7),
-    KEY_C(8),
-    KEY_V(9),
-    KEY_B(11),
-    KEY_Q(12),
-    KEY_W(13),
-    KEY_E(14),
-    KEY_R(15),
-    KEY_Y(16),
-    KEY_T(17),
-    KEY_U(32),
-    KEY_I(34),
-    KEY_P(35),
-    KEY_L(37),
-    KEY_J(38),
-    KEY_K(40),
-    KEY_N(45),
-    KEY_M(46),
-    KEY_O(31),
-    KEY_1(18),
-    KEY_2(19),
-    KEY_3(20),
-    KEY_4(21),
-    KEY_5(23),
-    KEY_6(22),
-    KEY_7(26),
-    KEY_8(28),
-    KEY_9(25),
-    KEY_0(29),
-    KEY_CLOSE_BRACKET(30),
-    KEY_OPEN_BRACKET(33),
-    KEY_QUOTE(39),
-    KEY_SEMICOLON(41),
-    KEY_SLASH(42),
-    KEY_COMMA(43),
-    KEY_BACKSLASH(44),
-    KEY_PERIOD(47),
-    KEY_BACK_QUOTE(50),
-    KEY_EQUALS(24),
-    KEY_MINUS(27),
-    KEY_ENTER(36),
-    KEY_ESCAPE(53),
-    KEY_TAB(48),
-    KEY_BACKSPACE(51),
-    KEY_SPACE(49),
-    KEY_CAPSLOCK(57),
-    KEY_LEFT_META(55),
-    KEY_LEFT_SHIFT(56),
-    KEY_LEFT_ALT(58),
-    KEY_LEFT_CONTROL(59),
-    KEY_RIGHT_META(54),
-    KEY_RIGHT_SHIFT(60),
-    KEY_RIGHT_ALT(61),
-    KEY_RIGHT_CONTROL(62),
-    KEY_UP(126),
-    KEY_DOWN(125),
-    KEY_LEFT(123),
-    KEY_RIGHT(124),
-    KEY_F1(122),
-    KEY_F2(120),
-	KEY_F3(99),
-    KEY_F4(118),
-    KEY_F5(96),
-	KEY_F6(97),
-	KEY_F7(98),
-	KEY_F8(100),
-	KEY_F9(101),
-    KEY_F10(109),
-	KEY_F11(103),
-	KEY_F12(111),
-	KEY_PRINTSCEEN(105),
-	KEY_SCROLL_LOCK(107),
-	KEY_PAUSE(113),
-    KEY_INSERT(114),
-    KEY_HOME(115),
-	KEY_PGUP(116),
-    KEY_DELETE(117),
-    KEY_END(119),
-    KEY_PGDOWN(121),
-    KEY_NUM_LOCK(71),
-    KEY_NUMPAD_0(82),
-    KEY_NUMPAD_1(83),
-    KEY_NUMPAD_2(84),
-    KEY_NUMPAD_3(85),
-    KEY_NUMPAD_4(86),
-    KEY_NUMPAD_5(87),
-    KEY_NUMPAD_6(88),
-    KEY_NUMPAD_7(88),
-    KEY_NUMPAD_8(91),
-    KEY_NUMPAD_9(92),
-    KEY_NUMPAD_ENTER(76),
-    KEY_NUMPAD_ADD(69),
-    KEY_NUMPAD_SUBTRACT(78),
-    KEY_NUMPAD_MULTIPLY(67),
-    KEY_NUMPAD_DIVIDE(75),
-    KEY_NUMPAD_DECIMAC(65);
-
-    companion object {
-        fun valueOf(value: Int): SkikoKey {
-            val key = SkikoKey.values().firstOrNull { it.value == value }
-            return if (key == null) SkikoKey.KEY_UNKNOWN else key
-        }
-    }
-}
\ No newline at end of file

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

+package org.jetbrains.skiko
+
+import platform.UIKit.*
+
+actual enum class SkikoKey(val value: UIKeyboardHIDUsage) {
+    KEY_UNKNOWN(-1),
+    KEY_A(UIKeyboardHIDUsageKeyboardA),
+    KEY_S(UIKeyboardHIDUsageKeyboardS),
+    KEY_D(UIKeyboardHIDUsageKeyboardD),
+    KEY_F(UIKeyboardHIDUsageKeyboardF),
+    KEY_H(UIKeyboardHIDUsageKeyboardH),
+    KEY_G(UIKeyboardHIDUsageKeyboardG),
+    KEY_Z(UIKeyboardHIDUsageKeyboardZ),
+    KEY_X(UIKeyboardHIDUsageKeyboardX),
+    KEY_C(UIKeyboardHIDUsageKeyboardC),
+    KEY_V(UIKeyboardHIDUsageKeyboardV),
+    KEY_B(UIKeyboardHIDUsageKeyboardB),
+    KEY_Q(UIKeyboardHIDUsageKeyboardQ),
+    KEY_W(UIKeyboardHIDUsageKeyboardW),
+    KEY_E(UIKeyboardHIDUsageKeyboardE),
+    KEY_R(UIKeyboardHIDUsageKeyboardR),
+    KEY_Y(UIKeyboardHIDUsageKeyboardY),
+    KEY_T(UIKeyboardHIDUsageKeyboardT),
+    KEY_U(UIKeyboardHIDUsageKeyboardU),
+    KEY_I(UIKeyboardHIDUsageKeyboardI),
+    KEY_P(UIKeyboardHIDUsageKeyboardP),
+    KEY_L(UIKeyboardHIDUsageKeyboardL),
+    KEY_J(UIKeyboardHIDUsageKeyboardJ),
+    KEY_K(UIKeyboardHIDUsageKeyboardK),
+    KEY_N(UIKeyboardHIDUsageKeyboardN),
+    KEY_M(UIKeyboardHIDUsageKeyboardM),
+    KEY_O(UIKeyboardHIDUsageKeyboardO),
+    KEY_1(UIKeyboardHIDUsageKeyboard1),
+    KEY_2(UIKeyboardHIDUsageKeyboard2),
+    KEY_3(UIKeyboardHIDUsageKeyboard3),
+    KEY_4(UIKeyboardHIDUsageKeyboard4),
+    KEY_5(UIKeyboardHIDUsageKeyboard5),
+    KEY_6(UIKeyboardHIDUsageKeyboard6),
+    KEY_7(UIKeyboardHIDUsageKeyboard7),
+    KEY_8(UIKeyboardHIDUsageKeyboard8),
+    KEY_9(UIKeyboardHIDUsageKeyboard9),
+    KEY_0(UIKeyboardHIDUsageKeyboard0),
+    KEY_CLOSE_BRACKET(UIKeyboardHIDUsageKeyboardCloseBracket),
+    KEY_OPEN_BRACKET(UIKeyboardHIDUsageKeyboardOpenBracket),
+    KEY_QUOTE(UIKeyboardHIDUsageKeyboardQuote),
+    KEY_SEMICOLON(UIKeyboardHIDUsageKeyboardSemicolon),
+    KEY_SLASH(UIKeyboardHIDUsageKeyboardSlash),
+    KEY_COMMA(UIKeyboardHIDUsageKeyboardComma),
+    KEY_BACKSLASH(UIKeyboardHIDUsageKeyboardBackslash),
+    KEY_PERIOD(UIKeyboardHIDUsageKeyboardPeriod),
+    KEY_BACK_QUOTE(53),
+    KEY_EQUALS(UIKeyboardHIDUsageKeyboardEqualSign),
+    KEY_MINUS(UIKeyboardHIDUsageKeyboardHyphen),
+    KEY_ENTER(40),
+    KEY_ESCAPE(UIKeyboardHIDUsageKeyboardEscape),
+    KEY_TAB(UIKeyboardHIDUsageKeyboardTab),
+    KEY_BACKSPACE(UIKeyboardHIDUsageKeyboardDeleteOrBackspace),
+    KEY_SPACE(UIKeyboardHIDUsageKeyboardSpacebar),
+    KEY_CAPSLOCK(UIKeyboardHIDUsageKeyboardCapsLock),
+    KEY_LEFT_META(227),
+    KEY_LEFT_SHIFT(UIKeyboardHIDUsageKeyboardLeftShift),
+    KEY_LEFT_ALT(UIKeyboardHIDUsageKeyboardLeftAlt),
+    KEY_LEFT_CONTROL(UIKeyboardHIDUsageKeyboardLeftControl),
+    KEY_RIGHT_META(231),
+    KEY_RIGHT_SHIFT(UIKeyboardHIDUsageKeyboardRightShift),
+    KEY_RIGHT_ALT(UIKeyboardHIDUsageKeyboardRightAlt),
+    KEY_RIGHT_CONTROL(UIKeyboardHIDUsageKeyboardRightControl),
+    KEY_MENU(101),
+    KEY_UP(UIKeyboardHIDUsageKeyboardUpArrow),
+    KEY_DOWN(UIKeyboardHIDUsageKeyboardDownArrow),
+    KEY_LEFT(UIKeyboardHIDUsageKeyboardLeftArrow),
+    KEY_RIGHT(UIKeyboardHIDUsageKeyboardRightArrow),
+    KEY_F1(UIKeyboardHIDUsageKeyboardF1),
+    KEY_F2(UIKeyboardHIDUsageKeyboardF2),
+	KEY_F3(UIKeyboardHIDUsageKeyboardF3),
+    KEY_F4(UIKeyboardHIDUsageKeyboardF4),
+    KEY_F5(UIKeyboardHIDUsageKeyboardF5),
+	KEY_F6(UIKeyboardHIDUsageKeyboardF6),
+	KEY_F7(UIKeyboardHIDUsageKeyboardF7),
+	KEY_F8(UIKeyboardHIDUsageKeyboardF8),
+	KEY_F9(UIKeyboardHIDUsageKeyboardF9),
+    KEY_F10(UIKeyboardHIDUsageKeyboardF10),
+	KEY_F11(UIKeyboardHIDUsageKeyboardF11),
+	KEY_F12(UIKeyboardHIDUsageKeyboardF12),
+	KEY_PRINTSCEEN(104),
+	KEY_SCROLL_LOCK(UIKeyboardHIDUsageKeyboardScrollLock),
+	KEY_PAUSE(UIKeyboardHIDUsageKeyboardPause),
+    KEY_INSERT(117),
+    KEY_HOME(UIKeyboardHIDUsageKeyboardHome),
+	KEY_PGUP(UIKeyboardHIDUsageKeyboardPageUp),
+    KEY_DELETE(UIKeyboardHIDUsageKeyboardDeleteForward),
+    KEY_END(UIKeyboardHIDUsageKeyboardEnd),
+    KEY_PGDOWN(UIKeyboardHIDUsageKeyboardPageDown),
+    KEY_NUM_LOCK(UIKeyboardHIDUsageKeypadNumLock),
+    KEY_NUMPAD_0(UIKeyboardHIDUsageKeypad0),
+    KEY_NUMPAD_1(UIKeyboardHIDUsageKeypad1),
+    KEY_NUMPAD_2(90),
+    KEY_NUMPAD_3(UIKeyboardHIDUsageKeypad3),
+    KEY_NUMPAD_4(92),
+    KEY_NUMPAD_5(UIKeyboardHIDUsageKeypad5),
+    KEY_NUMPAD_6(94),
+    KEY_NUMPAD_7(UIKeyboardHIDUsageKeypad7),
+    KEY_NUMPAD_8(96),
+    KEY_NUMPAD_9(UIKeyboardHIDUsageKeypad9),
+    KEY_NUMPAD_ENTER(UIKeyboardHIDUsageKeypadEnter),
+    KEY_NUMPAD_ADD(87),
+    KEY_NUMPAD_SUBTRACT(86),
+    KEY_NUMPAD_MULTIPLY(UIKeyboardHIDUsageKeypadAsterisk),
+    KEY_NUMPAD_DIVIDE(UIKeyboardHIDUsageKeypadSlash),
+    KEY_NUMPAD_DECIMAL(99);
+
+    companion object {
+        fun valueOf(value: UIKeyboardHIDUsage): SkikoKey {
+            val key = SkikoKey.values().firstOrNull { it.value == value }
+            return key ?: SkikoKey.KEY_UNKNOWN
+        }
+    }
+}
\ No newline at end of file

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

@@ -10,15 +10,56 @@ import platform.UIKit.UIScreen
 import platform.UIKit.UIViewController
 import platform.UIKit.setFrame
 import platform.UIKit.contentScaleFactor
+import platform.UIKit.UIKeyInputProtocol
+import platform.UIKit.UIPress
+import platform.UIKit.UIPressesEvent
 
 @ExportObjCClass
-class SkikoViewController : UIViewController {
+class SkikoViewController : UIViewController, UIKeyInputProtocol {
     @OverrideInit
     constructor() : super(nibName = null, bundle = null)
 
     @OverrideInit
     constructor(coder: NSCoder) : super(coder)
 
+    override fun canBecomeFirstResponder() = true
+
+    private var inputText: String = ""
+    override fun hasText(): Boolean {
+        return inputText.length > 0
+    }
+
+    override fun insertText(theText: String) {
+        inputText += theText
+        skikoLayer.skikoView?.onInputEvent(toSkikoTypeEvent(theText))
+    }
+
+    override fun deleteBackward() {
+        inputText = inputText.dropLast(1)
+    }
+
+    override fun pressesBegan(presses: Set<*>, withEvent: UIPressesEvent?) {
+        if (withEvent != null) {
+            for (press in withEvent.allPresses) {
+                skikoLayer.skikoView?.onKeyboardEvent(
+                    toSkikoKeyboardEvent(press as UIPress, SkikoKeyboardEventKind.DOWN)
+                )
+            }
+        }
+        super.pressesBegan(presses, withEvent)
+    }
+
+    override fun pressesEnded(presses: Set<*>, withEvent: UIPressesEvent?) {
+        if (withEvent != null) {
+            for (press in withEvent.allPresses) {
+                skikoLayer.skikoView?.onKeyboardEvent(
+                    toSkikoKeyboardEvent(press as UIPress, SkikoKeyboardEventKind.UP)
+                )
+            }
+        }
+        super.pressesEnded(presses, withEvent)
+    }
+
     override fun touchesBegan(touches: Set<*>, withEvent: UIEvent?) {
         super.touchesBegan(touches, withEvent)
         val sender = (touches.elementAt(0) as UITouch)

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

@@ -3,6 +3,7 @@ package org.jetbrains.skiko
 import org.w3c.dom.events.MouseEvent
 import org.w3c.dom.events.KeyboardEvent
 import org.w3c.dom.events.WheelEvent
+import org.w3c.dom.events.InputEvent
 
 fun toSkikoEvent(
     event: MouseEvent,
@@ -36,18 +37,8 @@ fun toSkikoEvent(
     event: KeyboardEvent,
     kind: SkikoKeyboardEventKind
 ): SkikoKeyboardEvent {
-    var key = event.keyCode
-    val side = event.location
-    if (side == KeyboardEvent.DOM_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())
-    }
     return SkikoKeyboardEvent(
-        SkikoKey.valueOf(key),
+        SkikoKey.valueOf(toSkikoKey(event)),
         toSkikoModifiers(event),
         kind,
         event
@@ -119,3 +110,17 @@ private fun toSkikoModifiers(event: KeyboardEvent): SkikoInputModifiers {
     }
     return SkikoInputModifiers(result)
 }
+
+private fun toSkikoKey(event: KeyboardEvent): Int {
+    var key = event.keyCode
+    val side = event.location
+    if (side == KeyboardEvent.DOM_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())
+    }
+    return key
+}
\ No newline at end of file

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

@@ -63,6 +63,7 @@ actual enum class SkikoKey(val value: Int) {
     KEY_RIGHT_SHIFT(0x80000000.toInt() or 16),
     KEY_RIGHT_ALT(225),
     KEY_RIGHT_CONTROL(0x80000000.toInt() or 17),
+    KEY_MENU(93),
     KEY_UP(38),
     KEY_DOWN(40),
     KEY_LEFT(37),
@@ -104,7 +105,7 @@ actual enum class SkikoKey(val value: Int) {
     KEY_NUMPAD_SUBTRACT(109),
     KEY_NUMPAD_MULTIPLY(106),
     KEY_NUMPAD_DIVIDE(111),
-    KEY_NUMPAD_DECIMAC(110);
+    KEY_NUMPAD_DECIMAL(110);
 
     companion object {
         fun valueOf(value: Int): SkikoKey {

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

@@ -145,9 +145,18 @@ fun toSkikoEvent(event: KeyEvent): SkikoKeyboardEvent {
     )
 }
 
+fun toSkikoTypeEvent(event: KeyEvent): SkikoInputEvent {
+    return SkikoInputEvent(
+        event.keyChar.toString(),
+        SkikoKeyboardEventKind.TYPE,
+        event
+    )
+}
+
 fun toSkikoEvent(event: InputMethodEvent): SkikoInputEvent {
     return SkikoInputEvent(
-        "", // TODO: this parameter should be reconsidered
+        "",
+        SkikoKeyboardEventKind.TYPE,
         event
     )
 }
@@ -182,3 +191,22 @@ private fun toSkikoModifiers(modifiers: Int): SkikoInputModifiers {
     }
     return SkikoInputModifiers(result)
 }
+
+private fun toSkikoKey(event: KeyEvent): Int {
+    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 key
+}
\ No newline at end of file

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/SkiaLayer.jvm.kt

@@ -7,7 +7,6 @@ import java.awt.Color
 import java.awt.Component
 import java.awt.Graphics
 import java.awt.event.*
-import java.awt.event.KeyEvent.*
 import java.awt.im.InputMethodRequests
 import java.awt.Window
 import java.util.concurrent.CancellationException
@@ -198,6 +197,9 @@ actual open class SkiaLayer internal constructor(
             override fun keyReleased(e: KeyEvent) {
                 skikoView?.onKeyboardEvent(toSkikoEvent(e))
             }
+            override fun keyTyped(e: KeyEvent) {
+                skikoView?.onInputEvent(toSkikoTypeEvent(e))
+            }
         })
 
         addInputMethodListener(object : InputMethodListener {
@@ -546,120 +548,6 @@ internal fun defaultFPSCounter(
 
 // InputEvent is abstract, so we wrap to match modality.
 actual typealias SkikoGesturePlatformEvent = Any
-actual typealias SkikoPlatformInputEvent = InputMethodEvent
+actual typealias SkikoPlatformInputEvent = Any
 actual typealias SkikoPlatformKeyboardEvent = KeyEvent
 actual typealias SkikoPlatformPointerEvent = MouseEvent
-
-actual enum class SkikoKey(val value: Int) {
-    KEY_UNKNOWN(-1),
-    KEY_A(VK_A),
-    KEY_S(VK_B),
-    KEY_D(VK_D),
-    KEY_F(VK_F),
-    KEY_H(VK_H),
-    KEY_G(VK_G),
-    KEY_Z(VK_Z),
-    KEY_X(VK_X),
-    KEY_C(VK_C),
-    KEY_V(VK_V),
-    KEY_B(VK_B),
-    KEY_Q(VK_Q),
-    KEY_W(VK_W),
-    KEY_E(VK_E),
-    KEY_R(VK_R),
-    KEY_Y(VK_Y),
-    KEY_T(VK_T),
-    KEY_U(VK_U),
-    KEY_I(VK_I),
-    KEY_P(VK_P),
-    KEY_L(VK_L),
-    KEY_J(VK_J),
-    KEY_K(VK_K),
-    KEY_N(VK_N),
-    KEY_M(VK_M),
-    KEY_O(VK_O),
-    KEY_1(VK_1),
-    KEY_2(VK_2),
-    KEY_3(VK_3),
-    KEY_4(VK_4),
-    KEY_5(VK_5),
-    KEY_6(VK_6),
-    KEY_7(VK_7),
-    KEY_8(VK_8),
-    KEY_9(VK_9),
-    KEY_0(VK_0),
-    KEY_CLOSE_BRACKET(VK_CLOSE_BRACKET),
-    KEY_OPEN_BRACKET(VK_OPEN_BRACKET),
-    KEY_QUOTE(VK_QUOTE),
-    KEY_SEMICOLON(VK_SEMICOLON),
-    KEY_SLASH(VK_SLASH),
-    KEY_COMMA(VK_COMMA),
-    KEY_BACKSLASH(VK_BACK_SLASH),
-    KEY_PERIOD(VK_PERIOD),
-    KEY_BACK_QUOTE(VK_BACK_QUOTE),
-    KEY_EQUALS(VK_EQUALS),
-    KEY_MINUS(VK_MINUS),
-    KEY_ENTER(VK_ENTER),
-    KEY_ESCAPE(VK_ESCAPE),
-    KEY_TAB(VK_TAB),
-    KEY_BACKSPACE(VK_BACK_SPACE),
-    KEY_SPACE(VK_SPACE),
-    KEY_CAPSLOCK(VK_CAPS_LOCK),
-    KEY_LEFT_META(VK_META),
-    KEY_LEFT_SHIFT(VK_SHIFT),
-    KEY_LEFT_ALT(VK_ALT),
-    KEY_LEFT_CONTROL(VK_CONTROL),
-    KEY_RIGHT_META(0x80000000.toInt() or VK_META),
-    KEY_RIGHT_SHIFT(0x80000000.toInt() or VK_SHIFT),
-    KEY_RIGHT_ALT(VK_ALT_GRAPH),
-    KEY_RIGHT_CONTROL(0x80000000.toInt() or VK_CONTROL),
-    KEY_UP(VK_UP),
-    KEY_DOWN(VK_DOWN),
-    KEY_LEFT(VK_LEFT),
-    KEY_RIGHT(VK_RIGHT),
-    KEY_F1(VK_F1),
-    KEY_F2(VK_F2),
-	KEY_F3(VK_F3),
-    KEY_F4(VK_F4),
-    KEY_F5(VK_F5),
-	KEY_F6(VK_F6),
-	KEY_F7(VK_F7),
-	KEY_F8(VK_F8),
-	KEY_F9(VK_F9),
-    KEY_F10(VK_F10),
-	KEY_F11(VK_F11),
-	KEY_F12(VK_F12),
-	KEY_PRINTSCEEN(VK_PRINTSCREEN),
-	KEY_SCROLL_LOCK(VK_SCROLL_LOCK),
-	KEY_PAUSE(VK_PAUSE),
-    KEY_INSERT(VK_INSERT),
-    KEY_HOME(VK_HOME),
-	KEY_PGUP(VK_PAGE_UP),
-    KEY_DELETE(VK_DELETE),
-    KEY_END(VK_END),
-    KEY_PGDOWN(VK_PAGE_DOWN),
-    KEY_NUM_LOCK(VK_NUM_LOCK),
-    KEY_NUMPAD_0(VK_NUMPAD0),
-    KEY_NUMPAD_1(VK_NUMPAD1),
-    KEY_NUMPAD_2(VK_NUMPAD2),
-    KEY_NUMPAD_3(VK_NUMPAD3),
-    KEY_NUMPAD_4(VK_NUMPAD4),
-    KEY_NUMPAD_5(VK_NUMPAD5),
-    KEY_NUMPAD_6(VK_NUMPAD6),
-    KEY_NUMPAD_7(VK_NUMPAD7),
-    KEY_NUMPAD_8(VK_NUMPAD8),
-    KEY_NUMPAD_9(VK_NUMPAD9),
-    KEY_NUMPAD_ENTER(0x80000000.toInt() or VK_ENTER),
-    KEY_NUMPAD_ADD(VK_ADD),
-    KEY_NUMPAD_SUBTRACT(VK_SUBTRACT),
-    KEY_NUMPAD_MULTIPLY(VK_MULTIPLY),
-    KEY_NUMPAD_DIVIDE(VK_DIVIDE),
-    KEY_NUMPAD_DECIMAC(VK_DECIMAL);
-
-    companion object {
-        fun valueOf(value: Int): SkikoKey {
-            val key = SkikoKey.values().firstOrNull { it.value == value }
-            return if (key == null) SkikoKey.KEY_UNKNOWN else key
-        }
-    }
-}
\ No newline at end of file

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/SkikoKey.jvm.kt

+package org.jetbrains.skiko
+
+import java.awt.event.KeyEvent.*
+
+actual enum class SkikoKey(val value: Int) {
+    KEY_UNKNOWN(-1),
+    KEY_A(VK_A),
+    KEY_S(VK_B),
+    KEY_D(VK_D),
+    KEY_F(VK_F),
+    KEY_H(VK_H),
+    KEY_G(VK_G),
+    KEY_Z(VK_Z),
+    KEY_X(VK_X),
+    KEY_C(VK_C),
+    KEY_V(VK_V),
+    KEY_B(VK_B),
+    KEY_Q(VK_Q),
+    KEY_W(VK_W),
+    KEY_E(VK_E),
+    KEY_R(VK_R),
+    KEY_Y(VK_Y),
+    KEY_T(VK_T),
+    KEY_U(VK_U),
+    KEY_I(VK_I),
+    KEY_P(VK_P),
+    KEY_L(VK_L),
+    KEY_J(VK_J),
+    KEY_K(VK_K),
+    KEY_N(VK_N),
+    KEY_M(VK_M),
+    KEY_O(VK_O),
+    KEY_1(VK_1),
+    KEY_2(VK_2),
+    KEY_3(VK_3),
+    KEY_4(VK_4),
+    KEY_5(VK_5),
+    KEY_6(VK_6),
+    KEY_7(VK_7),
+    KEY_8(VK_8),
+    KEY_9(VK_9),
+    KEY_0(VK_0),
+    KEY_CLOSE_BRACKET(VK_CLOSE_BRACKET),
+    KEY_OPEN_BRACKET(VK_OPEN_BRACKET),
+    KEY_QUOTE(VK_QUOTE),
+    KEY_SEMICOLON(VK_SEMICOLON),
+    KEY_SLASH(VK_SLASH),
+    KEY_COMMA(VK_COMMA),
+    KEY_BACKSLASH(VK_BACK_SLASH),
+    KEY_PERIOD(VK_PERIOD),
+    KEY_BACK_QUOTE(VK_BACK_QUOTE),
+    KEY_EQUALS(VK_EQUALS),
+    KEY_MINUS(VK_MINUS),
+    KEY_ENTER(VK_ENTER),
+    KEY_ESCAPE(VK_ESCAPE),
+    KEY_TAB(VK_TAB),
+    KEY_BACKSPACE(VK_BACK_SPACE),
+    KEY_SPACE(VK_SPACE),
+    KEY_CAPSLOCK(VK_CAPS_LOCK),
+    KEY_LEFT_META(VK_META),
+    KEY_LEFT_SHIFT(VK_SHIFT),
+    KEY_LEFT_ALT(VK_ALT),
+    KEY_LEFT_CONTROL(VK_CONTROL),
+    KEY_RIGHT_META(0x80000000.toInt() or VK_META),
+    KEY_RIGHT_SHIFT(0x80000000.toInt() or VK_SHIFT),
+    KEY_RIGHT_ALT(VK_ALT_GRAPH),
+    KEY_RIGHT_CONTROL(0x80000000.toInt() or VK_CONTROL),
+    KEY_MENU(VK_CONTEXT_MENU),
+    KEY_UP(VK_UP),
+    KEY_DOWN(VK_DOWN),
+    KEY_LEFT(VK_LEFT),
+    KEY_RIGHT(VK_RIGHT),
+    KEY_F1(VK_F1),
+    KEY_F2(VK_F2),
+	KEY_F3(VK_F3),
+    KEY_F4(VK_F4),
+    KEY_F5(VK_F5),
+	KEY_F6(VK_F6),
+	KEY_F7(VK_F7),
+	KEY_F8(VK_F8),
+	KEY_F9(VK_F9),
+    KEY_F10(VK_F10),
+	KEY_F11(VK_F11),
+	KEY_F12(VK_F12),
+	KEY_PRINTSCEEN(VK_PRINTSCREEN),
+	KEY_SCROLL_LOCK(VK_SCROLL_LOCK),
+	KEY_PAUSE(VK_PAUSE),
+    KEY_INSERT(VK_INSERT),
+    KEY_HOME(VK_HOME),
+	KEY_PGUP(VK_PAGE_UP),
+    KEY_DELETE(VK_DELETE),
+    KEY_END(VK_END),
+    KEY_PGDOWN(VK_PAGE_DOWN),
+    KEY_NUM_LOCK(VK_NUM_LOCK),
+    KEY_NUMPAD_0(VK_NUMPAD0),
+    KEY_NUMPAD_1(VK_NUMPAD1),
+    KEY_NUMPAD_2(VK_NUMPAD2),
+    KEY_NUMPAD_3(VK_NUMPAD3),
+    KEY_NUMPAD_4(VK_NUMPAD4),
+    KEY_NUMPAD_5(VK_NUMPAD5),
+    KEY_NUMPAD_6(VK_NUMPAD6),
+    KEY_NUMPAD_7(VK_NUMPAD7),
+    KEY_NUMPAD_8(VK_NUMPAD8),
+    KEY_NUMPAD_9(VK_NUMPAD9),
+    KEY_NUMPAD_ENTER(0x80000000.toInt() or VK_ENTER),
+    KEY_NUMPAD_ADD(VK_ADD),
+    KEY_NUMPAD_SUBTRACT(VK_SUBTRACT),
+    KEY_NUMPAD_MULTIPLY(VK_MULTIPLY),
+    KEY_NUMPAD_DIVIDE(VK_DIVIDE),
+    KEY_NUMPAD_DECIMAL(VK_DECIMAL);
+
+    companion object {
+        fun valueOf(value: Int): SkikoKey {
+            val key = SkikoKey.values().firstOrNull { it.value == value }
+            return if (key == null) SkikoKey.KEY_UNKNOWN else key
+        }
+    }
+}
\ No newline at end of file

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

@@ -29,117 +29,3 @@ actual typealias SkikoGesturePlatformEvent = Any
 actual typealias SkikoPlatformInputEvent = Any
 actual typealias SkikoPlatformKeyboardEvent = Any
 actual typealias SkikoPlatformPointerEvent = Any
-
-actual enum class SkikoKey(val value: Int) {
-    KEY_UNKNOWN(-1),
-    KEY_A(0),
-    KEY_S(1),
-    KEY_D(2),
-    KEY_F(3),
-    KEY_H(4),
-    KEY_G(5),
-    KEY_Z(6),
-    KEY_X(7),
-    KEY_C(8),
-    KEY_V(9),
-    KEY_B(11),
-    KEY_Q(12),
-    KEY_W(13),
-    KEY_E(14),
-    KEY_R(15),
-    KEY_Y(16),
-    KEY_T(17),
-    KEY_U(32),
-    KEY_I(34),
-    KEY_P(35),
-    KEY_L(37),
-    KEY_J(38),
-    KEY_K(40),
-    KEY_N(45),
-    KEY_M(46),
-    KEY_O(31),
-    KEY_1(18),
-    KEY_2(19),
-    KEY_3(20),
-    KEY_4(21),
-    KEY_5(23),
-    KEY_6(22),
-    KEY_7(26),
-    KEY_8(28),
-    KEY_9(25),
-    KEY_0(29),
-    KEY_CLOSE_BRACKET(30),
-    KEY_OPEN_BRACKET(33),
-    KEY_QUOTE(39),
-    KEY_SEMICOLON(41),
-    KEY_SLASH(42),
-    KEY_COMMA(43),
-    KEY_BACKSLASH(44),
-    KEY_PERIOD(47),
-    KEY_BACK_QUOTE(50),
-    KEY_EQUALS(24),
-    KEY_MINUS(27),
-    KEY_ENTER(36),
-    KEY_ESCAPE(53),
-    KEY_TAB(48),
-    KEY_BACKSPACE(51),
-    KEY_SPACE(49),
-    KEY_CAPSLOCK(57),
-    KEY_LEFT_META(55),
-    KEY_LEFT_SHIFT(56),
-    KEY_LEFT_ALT(58),
-    KEY_LEFT_CONTROL(59),
-    KEY_RIGHT_META(54),
-    KEY_RIGHT_SHIFT(60),
-    KEY_RIGHT_ALT(61),
-    KEY_RIGHT_CONTROL(62),
-    KEY_UP(126),
-    KEY_DOWN(125),
-    KEY_LEFT(123),
-    KEY_RIGHT(124),
-    KEY_F1(122),
-    KEY_F2(120),
-	KEY_F3(99),
-    KEY_F4(118),
-    KEY_F5(96),
-	KEY_F6(97),
-	KEY_F7(98),
-	KEY_F8(100),
-	KEY_F9(101),
-    KEY_F10(109),
-	KEY_F11(103),
-	KEY_F12(111),
-	KEY_PRINTSCEEN(105),
-	KEY_SCROLL_LOCK(107),
-	KEY_PAUSE(113),
-    KEY_INSERT(114),
-    KEY_HOME(115),
-	KEY_PGUP(116),
-    KEY_DELETE(117),
-    KEY_END(119),
-    KEY_PGDOWN(121),
-    KEY_NUM_LOCK(71),
-    KEY_NUMPAD_0(82),
-    KEY_NUMPAD_1(83),
-    KEY_NUMPAD_2(84),
-    KEY_NUMPAD_3(85),
-    KEY_NUMPAD_4(86),
-    KEY_NUMPAD_5(87),
-    KEY_NUMPAD_6(88),
-    KEY_NUMPAD_7(88),
-    KEY_NUMPAD_8(91),
-    KEY_NUMPAD_9(92),
-    KEY_NUMPAD_ENTER(76),
-    KEY_NUMPAD_ADD(69),
-    KEY_NUMPAD_SUBTRACT(78),
-    KEY_NUMPAD_MULTIPLY(67),
-    KEY_NUMPAD_DIVIDE(75),
-    KEY_NUMPAD_DECIMAC(65);
-
-    companion object {
-        fun valueOf(value: Int): SkikoKey {
-            val key = SkikoKey.values().firstOrNull { it.value == value }
-            return if (key == null) SkikoKey.KEY_UNKNOWN else key
-        }
-    }
-}
\ No newline at end of file

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

+package org.jetbrains.skiko
+
+actual enum class SkikoKey(val value: Int) {
+    KEY_UNKNOWN(-1),
+    KEY_A(0),
+    KEY_S(1),
+    KEY_D(2),
+    KEY_F(3),
+    KEY_H(4),
+    KEY_G(5),
+    KEY_Z(6),
+    KEY_X(7),
+    KEY_C(8),
+    KEY_V(9),
+    KEY_B(11),
+    KEY_Q(12),
+    KEY_W(13),
+    KEY_E(14),
+    KEY_R(15),
+    KEY_Y(16),
+    KEY_T(17),
+    KEY_U(32),
+    KEY_I(34),
+    KEY_P(35),
+    KEY_L(37),
+    KEY_J(38),
+    KEY_K(40),
+    KEY_N(45),
+    KEY_M(46),
+    KEY_O(31),
+    KEY_1(18),
+    KEY_2(19),
+    KEY_3(20),
+    KEY_4(21),
+    KEY_5(23),
+    KEY_6(22),
+    KEY_7(26),
+    KEY_8(28),
+    KEY_9(25),
+    KEY_0(29),
+    KEY_CLOSE_BRACKET(30),
+    KEY_OPEN_BRACKET(33),
+    KEY_QUOTE(39),
+    KEY_SEMICOLON(41),
+    KEY_SLASH(42),
+    KEY_COMMA(43),
+    KEY_BACKSLASH(44),
+    KEY_PERIOD(47),
+    KEY_BACK_QUOTE(50),
+    KEY_EQUALS(24),
+    KEY_MINUS(27),
+    KEY_ENTER(36),
+    KEY_ESCAPE(53),
+    KEY_TAB(48),
+    KEY_BACKSPACE(51),
+    KEY_SPACE(49),
+    KEY_CAPSLOCK(57),
+    KEY_LEFT_META(55),
+    KEY_LEFT_SHIFT(56),
+    KEY_LEFT_ALT(58),
+    KEY_LEFT_CONTROL(59),
+    KEY_RIGHT_META(54),
+    KEY_RIGHT_SHIFT(60),
+    KEY_RIGHT_ALT(61),
+    KEY_RIGHT_CONTROL(62),
+    KEY_MENU(110),
+    KEY_UP(126),
+    KEY_DOWN(125),
+    KEY_LEFT(123),
+    KEY_RIGHT(124),
+    KEY_F1(122),
+    KEY_F2(120),
+	KEY_F3(99),
+    KEY_F4(118),
+    KEY_F5(96),
+	KEY_F6(97),
+	KEY_F7(98),
+	KEY_F8(100),
+	KEY_F9(101),
+    KEY_F10(109),
+	KEY_F11(103),
+	KEY_F12(111),
+	KEY_PRINTSCEEN(105),
+	KEY_SCROLL_LOCK(107),
+	KEY_PAUSE(113),
+    KEY_INSERT(114),
+    KEY_HOME(115),
+	KEY_PGUP(116),
+    KEY_DELETE(117),
+    KEY_END(119),
+    KEY_PGDOWN(121),
+    KEY_NUM_LOCK(71),
+    KEY_NUMPAD_0(82),
+    KEY_NUMPAD_1(83),
+    KEY_NUMPAD_2(84),
+    KEY_NUMPAD_3(85),
+    KEY_NUMPAD_4(86),
+    KEY_NUMPAD_5(87),
+    KEY_NUMPAD_6(88),
+    KEY_NUMPAD_7(88),
+    KEY_NUMPAD_8(91),
+    KEY_NUMPAD_9(92),
+    KEY_NUMPAD_ENTER(76),
+    KEY_NUMPAD_ADD(69),
+    KEY_NUMPAD_SUBTRACT(78),
+    KEY_NUMPAD_MULTIPLY(67),
+    KEY_NUMPAD_DIVIDE(75),
+    KEY_NUMPAD_DECIMAL(65);
+
+    companion object {
+        fun valueOf(value: Int): SkikoKey {
+            val key = SkikoKey.values().firstOrNull { it.value == value }
+            return if (key == null) SkikoKey.KEY_UNKNOWN else key
+        }
+    }
+}
\ No newline at end of file

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

@@ -81,6 +81,17 @@ fun toSkikoEvent(
     )
 }
 
+fun toSkikoTypeEvent(
+    character: String,
+    event: NSEvent,
+): SkikoInputEvent {
+    return SkikoInputEvent(
+        character,
+        SkikoKeyboardEventKind.TYPE,
+        event
+    )
+}
+
 private val actionAllKeyUpFlag = 256.toULong() // MacOS specific
 private var modifierKeyUpFlag = actionAllKeyUpFlag
 fun toSkikoEvent(

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

@@ -2,11 +2,22 @@ package org.jetbrains.skiko
 
 import kotlinx.cinterop.ObjCAction
 import kotlinx.cinterop.useContents
+import kotlinx.cinterop.CValue
+import kotlinx.cinterop.COpaquePointer
+import kotlinx.cinterop.convert
 import org.jetbrains.skia.*
 import org.jetbrains.skiko.redrawer.MacOsOpenGLRedrawer
 import org.jetbrains.skiko.redrawer.Redrawer
 import platform.AppKit.*
+import platform.Foundation.NSAttributedString
+import platform.Foundation.NSMutableAttributedString
 import platform.Foundation.NSMakeRect
+import platform.Foundation.NSMakeRange
+import platform.Foundation.NSRange
+import platform.Foundation.NSRangePointer
+import platform.Foundation.NSPoint
+import platform.Foundation.NSRect
+import platform.Foundation.NSNotFound
 import platform.Foundation.NSNotification
 import platform.Foundation.NSNotificationCenter
 import platform.Foundation.NSSelectorFromString
@@ -51,14 +62,10 @@ actual open class SkiaLayer() {
         val (width, height) = window.contentLayoutRect.useContents {
             this.size.width to this.size.height
         }
-        nsView = object : NSView(NSMakeRect(0.0, 0.0, width, height)) {
+        nsView = object : NSView(NSMakeRect(0.0, 0.0, width, height)), NSTextInputClientProtocol {
             private var trackingArea : NSTrackingArea? = null
-            override fun wantsUpdateLayer(): Boolean {
-                return true
-            }
-            override fun acceptsFirstResponder(): Boolean {
-                return true
-            }
+            override fun wantsUpdateLayer() = true
+            override fun acceptsFirstResponder() = true
             override fun viewWillMoveToWindow(newWindow: NSWindow?) {
                 updateTrackingAreas()
             }
@@ -105,6 +112,8 @@ actual open class SkiaLayer() {
             }
             override fun keyDown(event: NSEvent) {
                 skikoView?.onKeyboardEvent(toSkikoEvent(event, SkikoKeyboardEventKind.DOWN))
+                keyEvent = event
+                interpretKeyEvents(listOf(event))
             }
             override fun flagsChanged(event: NSEvent) {
                 skikoView?.onKeyboardEvent(toSkikoEvent(event))
@@ -113,6 +122,51 @@ actual open class SkiaLayer() {
                 skikoView?.onKeyboardEvent(toSkikoEvent(event, SkikoKeyboardEventKind.UP))
             }
             
+            private var keyEvent: NSEvent? = null
+            private var markedText: String = ""
+            private val kEmptyRange = NSMakeRange(NSNotFound.convert(), 0)
+            override fun attributedSubstringForProposedRange(range: CValue<NSRange>, actualRange: NSRangePointer?) = null
+            override fun hasMarkedText(): Boolean {
+                return markedText.length > 0
+            }
+            override fun markedRange(): CValue<NSRange> {
+                if (markedText.length > 0) {
+                    return NSMakeRange(0, (markedText.length - 1).convert())
+                }
+                return kEmptyRange
+            }
+            override fun selectedRange() = kEmptyRange
+            override fun characterIndexForPoint(point: CValue<NSPoint>) = 0.toULong()
+            override fun doCommandBySelector(selector: COpaquePointer?) {}
+            override fun firstRectForCharacterRange(range: CValue<NSRange>, actualRange: NSRangePointer?): CValue<NSRect> {
+                val (x, y) = window.frame.useContents {
+                    origin.x to origin.y
+                }
+                return NSMakeRect(x, y, 0.0, 0.0)
+            }
+            override fun insertText(string: Any, replacementRange: CValue<NSRange>) {
+                var character = ""
+                if (string is NSAttributedString) {
+                    character = string.string
+                } else {
+                    character = string as String
+                }
+                skikoView?.onInputEvent(toSkikoTypeEvent(character, keyEvent!!))
+            }
+            override fun setMarkedText(string: Any, selectedRange: CValue<NSRange>, replacementRange: CValue<NSRange>) {
+                if (string is NSAttributedString) {
+                    markedText = string.string
+                } else {
+                    markedText = string as String
+                }
+            }
+            override fun unmarkText() {
+                markedText = ""
+            }
+            override fun validAttributesForMarkedText(): List<*> {
+                return listOf<Any?>()
+            }
+
             @ObjCAction
             open fun onWindowClose(arg: NSObject?) {
                 detach()
@@ -182,117 +236,3 @@ actual typealias SkikoGesturePlatformEvent = NSEvent
 actual typealias SkikoPlatformInputEvent = NSEvent
 actual typealias SkikoPlatformKeyboardEvent = NSEvent
 actual typealias SkikoPlatformPointerEvent = NSEvent
-
-actual enum class SkikoKey(val value: Int) {
-    KEY_UNKNOWN(-1),
-    KEY_A(0),
-    KEY_S(1),
-    KEY_D(2),
-    KEY_F(3),
-    KEY_H(4),
-    KEY_G(5),
-    KEY_Z(6),
-    KEY_X(7),
-    KEY_C(8),
-    KEY_V(9),
-    KEY_B(11),
-    KEY_Q(12),
-    KEY_W(13),
-    KEY_E(14),
-    KEY_R(15),
-    KEY_Y(16),
-    KEY_T(17),
-    KEY_U(32),
-    KEY_I(34),
-    KEY_P(35),
-    KEY_L(37),
-    KEY_J(38),
-    KEY_K(40),
-    KEY_N(45),
-    KEY_M(46),
-    KEY_O(31),
-    KEY_1(18),
-    KEY_2(19),
-    KEY_3(20),
-    KEY_4(21),
-    KEY_5(23),
-    KEY_6(22),
-    KEY_7(26),
-    KEY_8(28),
-    KEY_9(25),
-    KEY_0(29),
-    KEY_CLOSE_BRACKET(30),
-    KEY_OPEN_BRACKET(33),
-    KEY_QUOTE(39),
-    KEY_SEMICOLON(41),
-    KEY_SLASH(42),
-    KEY_COMMA(43),
-    KEY_BACKSLASH(44),
-    KEY_PERIOD(47),
-    KEY_BACK_QUOTE(50),
-    KEY_EQUALS(24),
-    KEY_MINUS(27),
-    KEY_ENTER(36),
-    KEY_ESCAPE(53),
-    KEY_TAB(48),
-    KEY_BACKSPACE(51),
-    KEY_SPACE(49),
-    KEY_CAPSLOCK(57),
-    KEY_LEFT_META(55),
-    KEY_LEFT_SHIFT(56),
-    KEY_LEFT_ALT(58),
-    KEY_LEFT_CONTROL(59),
-    KEY_RIGHT_META(54),
-    KEY_RIGHT_SHIFT(60),
-    KEY_RIGHT_ALT(61),
-    KEY_RIGHT_CONTROL(62),
-    KEY_UP(126),
-    KEY_DOWN(125),
-    KEY_LEFT(123),
-    KEY_RIGHT(124),
-    KEY_F1(122),
-    KEY_F2(120),
-	KEY_F3(99),
-    KEY_F4(118),
-    KEY_F5(96),
-	KEY_F6(97),
-	KEY_F7(98),
-	KEY_F8(100),
-	KEY_F9(101),
-    KEY_F10(109),
-	KEY_F11(103),
-	KEY_F12(111),
-	KEY_PRINTSCEEN(105),
-	KEY_SCROLL_LOCK(107),
-	KEY_PAUSE(113),
-    KEY_INSERT(114),
-    KEY_HOME(115),
-	KEY_PGUP(116),
-    KEY_DELETE(117),
-    KEY_END(119),
-    KEY_PGDOWN(121),
-    KEY_NUM_LOCK(71),
-    KEY_NUMPAD_0(82),
-    KEY_NUMPAD_1(83),
-    KEY_NUMPAD_2(84),
-    KEY_NUMPAD_3(85),
-    KEY_NUMPAD_4(86),
-    KEY_NUMPAD_5(87),
-    KEY_NUMPAD_6(88),
-    KEY_NUMPAD_7(88),
-    KEY_NUMPAD_8(91),
-    KEY_NUMPAD_9(92),
-    KEY_NUMPAD_ENTER(76),
-    KEY_NUMPAD_ADD(69),
-    KEY_NUMPAD_SUBTRACT(78),
-    KEY_NUMPAD_MULTIPLY(67),
-    KEY_NUMPAD_DIVIDE(75),
-    KEY_NUMPAD_DECIMAC(65);
-
-    companion object {
-        fun valueOf(value: Int): SkikoKey {
-            val key = SkikoKey.values().firstOrNull { it.value == value }
-            return if (key == null) SkikoKey.KEY_UNKNOWN else key
-        }
-    }
-}
\ No newline at end of file

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

+package org.jetbrains.skiko
+
+actual enum class SkikoKey(val value: Int) {
+    KEY_UNKNOWN(-1),
+    KEY_A(0),
+    KEY_S(1),
+    KEY_D(2),
+    KEY_F(3),
+    KEY_H(4),
+    KEY_G(5),
+    KEY_Z(6),
+    KEY_X(7),
+    KEY_C(8),
+    KEY_V(9),
+    KEY_B(11),
+    KEY_Q(12),
+    KEY_W(13),
+    KEY_E(14),
+    KEY_R(15),
+    KEY_Y(16),
+    KEY_T(17),
+    KEY_U(32),
+    KEY_I(34),
+    KEY_P(35),
+    KEY_L(37),
+    KEY_J(38),
+    KEY_K(40),
+    KEY_N(45),
+    KEY_M(46),
+    KEY_O(31),
+    KEY_1(18),
+    KEY_2(19),
+    KEY_3(20),
+    KEY_4(21),
+    KEY_5(23),
+    KEY_6(22),
+    KEY_7(26),
+    KEY_8(28),
+    KEY_9(25),
+    KEY_0(29),
+    KEY_CLOSE_BRACKET(30),
+    KEY_OPEN_BRACKET(33),
+    KEY_QUOTE(39),
+    KEY_SEMICOLON(41),
+    KEY_SLASH(42),
+    KEY_COMMA(43),
+    KEY_BACKSLASH(44),
+    KEY_PERIOD(47),
+    KEY_BACK_QUOTE(50),
+    KEY_EQUALS(24),
+    KEY_MINUS(27),
+    KEY_ENTER(36),
+    KEY_ESCAPE(53),
+    KEY_TAB(48),
+    KEY_BACKSPACE(51),
+    KEY_SPACE(49),
+    KEY_CAPSLOCK(57),
+    KEY_LEFT_META(55),
+    KEY_LEFT_SHIFT(56),
+    KEY_LEFT_ALT(58),
+    KEY_LEFT_CONTROL(59),
+    KEY_RIGHT_META(54),
+    KEY_RIGHT_SHIFT(60),
+    KEY_RIGHT_ALT(61),
+    KEY_RIGHT_CONTROL(62),
+    KEY_MENU(110),
+    KEY_UP(126),
+    KEY_DOWN(125),
+    KEY_LEFT(123),
+    KEY_RIGHT(124),
+    KEY_F1(122),
+    KEY_F2(120),
+	KEY_F3(99),
+    KEY_F4(118),
+    KEY_F5(96),
+	KEY_F6(97),
+	KEY_F7(98),
+	KEY_F8(100),
+	KEY_F9(101),
+    KEY_F10(109),
+	KEY_F11(103),
+	KEY_F12(111),
+	KEY_PRINTSCEEN(105),
+	KEY_SCROLL_LOCK(107),
+	KEY_PAUSE(113),
+    KEY_INSERT(114),
+    KEY_HOME(115),
+	KEY_PGUP(116),
+    KEY_DELETE(117),
+    KEY_END(119),
+    KEY_PGDOWN(121),
+    KEY_NUM_LOCK(71),
+    KEY_NUMPAD_0(82),
+    KEY_NUMPAD_1(83),
+    KEY_NUMPAD_2(84),
+    KEY_NUMPAD_3(85),
+    KEY_NUMPAD_4(86),
+    KEY_NUMPAD_5(87),
+    KEY_NUMPAD_6(88),
+    KEY_NUMPAD_7(88),
+    KEY_NUMPAD_8(91),
+    KEY_NUMPAD_9(92),
+    KEY_NUMPAD_ENTER(76),
+    KEY_NUMPAD_ADD(69),
+    KEY_NUMPAD_SUBTRACT(78),
+    KEY_NUMPAD_MULTIPLY(67),
+    KEY_NUMPAD_DIVIDE(75),
+    KEY_NUMPAD_DECIMAL(65);
+
+    companion object {
+        fun valueOf(value: Int): SkikoKey {
+            val key = SkikoKey.values().firstOrNull { it.value == value }
+            return if (key == null) SkikoKey.KEY_UNKNOWN else key
+        }
+    }
+}
\ No newline at end of file