fun onKeyDown()

in sample/src/main/kotlin/org/jetbrains/desktop/sample/linux/SkikoSampleLinux.kt [393:563]
150 lines of code
13 McCabe index (conditional complexity)

    fun onKeyDown(
        event: Event.KeyDown,
        app: Application,
        window: Window,
        windowState: WindowState,
        modifiers: Set<KeyModifiers>,
        clipboardHandler: ClipboardHandler,
    ): EventHandlerResult {
        val shortcutModifiers = modifiers.shortcutModifiers()
        when (shortcutModifiers) {
            setOf(KeyModifiers.Logo) -> EventHandlerResult.Continue
            setOf(KeyModifiers.Control, KeyModifiers.Shift) -> when (event.keyCode.value) {
                KeyCode.V -> {
                    clipboardHandler.paste(listOf(PNG_MIME_TYPE, URI_LIST_MIME_TYPE, TEXT_MIME_TYPE))
                    EventHandlerResult.Stop
                }

                KeyCode.C -> {
                    clipboardHandler.copy(DataTransferContentType.UriList(EXAMPLE_FILES))
                    EventHandlerResult.Stop
                }

                KeyCode.O -> {
                    window.showOpenFileDialog(
                        commonParams = FileDialog.CommonDialogParams(
                            modal = false,
                            title = "Open Directory",
                            acceptLabel = null,
                            currentFolder = null,
                        ),
                        openParams = FileDialog.OpenDialogParams(
                            allowsMultipleSelections = false,
                            selectDirectories = true,
                        ),
                    )
                    EventHandlerResult.Stop
                }

                else -> EventHandlerResult.Continue
            }

            setOf(KeyModifiers.Control) -> when (event.keyCode.value) {
                KeyCode.V -> {
                    clipboardHandler.paste(listOf(PNG_MIME_TYPE, TEXT_MIME_TYPE, URI_LIST_MIME_TYPE))
                    EventHandlerResult.Stop
                }

                KeyCode.C -> {
                    getCurrentSelection()?.let { selection ->
                        clipboardHandler.copy(DataTransferContentType.Text(selection))
                        EventHandlerResult.Stop
                    } ?: EventHandlerResult.Continue
                }

                KeyCode.O -> {
                    window.showOpenFileDialog(
                        commonParams = FileDialog.CommonDialogParams(
                            modal = true,
                            title = "Open Files",
                            acceptLabel = null,
                            currentFolder = null,
                        ),
                        openParams = FileDialog.OpenDialogParams(
                            allowsMultipleSelections = true,
                            selectDirectories = false,
                        ),
                    )
                    EventHandlerResult.Stop
                }

                KeyCode.M -> {
                    window.startMove()
                    EventHandlerResult.Stop
                }

                KeyCode.Tab -> {
                    window.requestInternalActivationToken()
                    EventHandlerResult.Stop
                }

                else -> EventHandlerResult.Continue
            }
            setOf(KeyModifiers.Shift) -> when (event.keyCode.value) {
                KeyCode.Up -> {
                    if (selectionStartOffset == null) {
                        selectionStartOffset = cursorOffset
                    }
                    selectionEndOffset = 0
                    cursorOffset = 0
                }

                KeyCode.Down -> {
                    if (selectionStartOffset == null) {
                        selectionStartOffset = cursorOffset
                    }
                    val end = text.length
                    selectionEndOffset = end
                    cursorOffset = end
                }

                KeyCode.Left -> {
                    if (selectionStartOffset == null) {
                        selectionStartOffset = cursorOffset
                    }
                    cursorOffset = getPreviousGlyphOffset(text.toString(), cursorOffset)
                    selectionEndOffset = cursorOffset
                }

                KeyCode.Right -> {
                    if (selectionStartOffset == null) {
                        selectionStartOffset = cursorOffset
                    }
                    cursorOffset = getNextGlyphOffset(text.toString(), cursorOffset)
                    selectionEndOffset = cursorOffset
                }

                else -> {
                    event.characters?.also(::typeIn)
                }
            }
            else -> when (event.keyCode.value) {
                KeyCode.BackSpace -> {
                    if (!deleteSelection() && cursorOffset > 0) {
                        val newCursorOffset = getPreviousGlyphOffset(text.toString(), cursorOffset)
                        text.delete(newCursorOffset, cursorOffset)
                        cursorOffset = newCursorOffset
                    }
                }

                KeyCode.F11 -> {
                    if (windowState.fullscreen) {
                        window.unsetFullScreen()
                    } else {
                        window.setFullScreen()
                    }
                }

                KeyCode.Up -> {
                    cursorOffset = 0
                }

                KeyCode.Down -> {
                    cursorOffset = text.length
                }

                KeyCode.Left -> {
                    cursorOffset = getPreviousGlyphOffset(text.toString(), cursorOffset)
                }

                KeyCode.Right -> {
                    cursorOffset = getNextGlyphOffset(text.toString(), cursorOffset)
                }

                else -> {
                    event.characters?.also(::typeIn)
                }
            }
        }

        if (shortcutModifiers.all { it != KeyModifiers.Shift && it != KeyModifiers.Control && it != KeyModifiers.Logo } &&
            !event.keyCode.isModifierKey()
        ) {
            selectionStartOffset = null
            selectionEndOffset = null
        }

        if (textInputEnabled) {
            app.textInputUpdate(createTextInputContext(changeCausedByInputMethod = false))
        }
        return EventHandlerResult.Stop
    }