pythonnative 0.40.0__cp314-cp314-win_amd64.whl

pythonnative/native/android/src/main/java/com/pythonnative/runtime/components/ModalManager.kt

@@ -0,0 +1,134 @@
+package com.pythonnative.runtime.components
+
+import android.app.Dialog
+import android.content.Context
+import android.graphics.drawable.ColorDrawable
+import android.view.View
+import android.view.ViewGroup
+import android.view.WindowManager
+import android.widget.FrameLayout
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONObject
+
+/**
+ * `Modal` element: real modal presentation backed by a `Dialog`.
+ *
+ * The on-tree placeholder is a hidden `View`. When `visible` flips to
+ * `true`, a `Dialog` hosting a `FrameLayout` is shown and the
+ * reconciler's child inserts are forwarded into that content view.
+ */
+class ModalManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val placeholder = View(context)
+        placeholder.visibility = View.GONE
+        return placeholder
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val state = stateOf(view)
+        // Only react when `visible` itself changed; a re-render while the
+        // dialog is open must not tear it down.
+        if (props.has("visible")) {
+            val visible = JsonUtil.truthy(props.value("visible"))
+            if (visible && state["dialog"] == null) present(view)
+            else if (!visible && state["dialog"] != null) dismiss(view, fromUser = false)
+        }
+        val dialog = state["dialog"] as? Dialog
+        if (dialog != null && props.has("dismiss_on_backdrop")) {
+            dialog.setCanceledOnTouchOutside(props.value("dismiss_on_backdrop") != false)
+        }
+    }
+
+    override fun insertChild(parent: View, child: View, index: Int) {
+        val state = stateOf(parent)
+        val content = state["content_view"] as? FrameLayout
+        if (content != null) {
+            ViewChildren.insert(content, child, index)
+        } else {
+            @Suppress("UNCHECKED_CAST")
+            val pending = state.getOrPut("pending") { ArrayList<View>() } as ArrayList<View>
+            pending.remove(child)
+            pending.add(index.coerceIn(0, pending.size), child)
+        }
+    }
+
+    override fun removeChild(parent: View, child: View) {
+        val state = stateOf(parent)
+        val content = state["content_view"] as? FrameLayout
+        if (content != null) {
+            content.removeView(child)
+        } else {
+            @Suppress("UNCHECKED_CAST")
+            (state["pending"] as? ArrayList<View>)?.remove(child)
+        }
+    }
+
+    override fun setFrame(view: View, x: Double, y: Double, width: Double, height: Double) {
+        // The dialog owns its own window; the layout engine frames only the children.
+    }
+
+    override fun teardown(view: View) {
+        if (stateOf(view)["dialog"] != null) dismiss(view, fromUser = false)
+    }
+
+    private fun present(placeholder: View) {
+        val state = stateOf(placeholder)
+        val props = propsOf(placeholder)
+        val ctx = placeholder.context
+        val dialog = Dialog(ctx)
+        val content = FrameLayout(ctx)
+        val presentation = props.str("presentation_style") ?: "page_sheet"
+        val isOverlay = presentation == "overlay" || JsonUtil.truthy(props.value("transparent"))
+        content.setBackgroundColor(if (isOverlay) 0x00FFFFFF else 0xFFFFFFFF.toInt())
+        dialog.setContentView(content, ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+        dialog.window?.let { window ->
+            if (isOverlay) {
+                window.setBackgroundDrawable(ColorDrawable(0x00000000))
+                window.setDimAmount(0.5f)
+                window.setLayout(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.MATCH_PARENT)
+            } else {
+                window.setLayout(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.MATCH_PARENT)
+            }
+            val animation = props.str("animation_type") ?: props.str("animation")
+            when (animation) {
+                "none" -> window.setWindowAnimations(0)
+                "fade" -> window.setWindowAnimations(android.R.style.Animation_Toast)
+                "slide" -> window.setWindowAnimations(android.R.style.Animation_InputMethod)
+            }
+            PNColor.parse(props.value("status_bar_color"))?.let { window.statusBarColor = it }
+        }
+        dialog.setCanceledOnTouchOutside(props.value("dismiss_on_backdrop") != false)
+        dialog.setCancelable(props.value("dismissable") != false)
+        state["dialog"] = dialog
+        state["content_view"] = content
+        @Suppress("UNCHECKED_CAST")
+        val pending = state.remove("pending") as? ArrayList<View>
+        pending?.forEach { child ->
+            (child.parent as? ViewGroup)?.removeView(child)
+            content.addView(child)
+        }
+        dialog.setOnShowListener { fire(placeholder, "on_show") }
+        dialog.setOnDismissListener {
+            // Programmatic dismiss (visible=false) also lands here; the
+            // Python side expects on_dismiss only for user-driven closes,
+            // but android.py fired it unconditionally, so keep that.
+            if (stateOf(placeholder)["dialog"] === dialog) {
+                stateOf(placeholder).remove("dialog")
+                stateOf(placeholder).remove("content_view")
+            }
+            fire(placeholder, "on_dismiss")
+            if (hasEvent(placeholder, "on_request_close")) fire(placeholder, "on_request_close")
+        }
+        dialog.show()
+    }
+
+    private fun dismiss(placeholder: View, fromUser: Boolean) {
+        val state = stateOf(placeholder)
+        val dialog = state.remove("dialog") as? Dialog
+        state.remove("content_view")
+        if (!fromUser) dialog?.setOnDismissListener(null)
+        dialog?.dismiss()
+    }
+}

pythonnative/native/android/src/main/java/com/pythonnative/runtime/components/PNColor.kt

@@ -0,0 +1,201 @@
+package com.pythonnative.runtime.components
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Color parsing shared by every manager.
+ *
+ * Accepts `#RGB`, `#RGBA`, `#RRGGBB`, `#AARRGGBB` (the Android/Python
+ * convention used by `parse_color_int`), `rgb(r, g, b)`,
+ * `rgba(r, g, b, a)` with `a` in `0..1`, CSS named colors, packed
+ * integers (`0xRRGGBB` gains full alpha), and `[r, g, b(, a)]` arrays.
+ * Results are signed 32-bit ARGB ints suitable for Android APIs.
+ */
+object PNColor {
+    private val named: Map<String, Int> = mapOf(
+        "transparent" to 0x00000000,
+        "clear" to 0x00000000,
+        "black" to 0xFF000000.toInt(),
+        "white" to 0xFFFFFFFF.toInt(),
+        "red" to 0xFFFF0000.toInt(),
+        "green" to 0xFF008000.toInt(),
+        "lime" to 0xFF00FF00.toInt(),
+        "blue" to 0xFF0000FF.toInt(),
+        "yellow" to 0xFFFFFF00.toInt(),
+        "cyan" to 0xFF00FFFF.toInt(),
+        "aqua" to 0xFF00FFFF.toInt(),
+        "magenta" to 0xFFFF00FF.toInt(),
+        "fuchsia" to 0xFFFF00FF.toInt(),
+        "gray" to 0xFF808080.toInt(),
+        "grey" to 0xFF808080.toInt(),
+        "darkgray" to 0xFFA9A9A9.toInt(),
+        "darkgrey" to 0xFFA9A9A9.toInt(),
+        "lightgray" to 0xFFD3D3D3.toInt(),
+        "lightgrey" to 0xFFD3D3D3.toInt(),
+        "dimgray" to 0xFF696969.toInt(),
+        "dimgrey" to 0xFF696969.toInt(),
+        "silver" to 0xFFC0C0C0.toInt(),
+        "maroon" to 0xFF800000.toInt(),
+        "olive" to 0xFF808000.toInt(),
+        "navy" to 0xFF000080.toInt(),
+        "teal" to 0xFF008080.toInt(),
+        "purple" to 0xFF800080.toInt(),
+        "orange" to 0xFFFFA500.toInt(),
+        "pink" to 0xFFFFC0CB.toInt(),
+        "brown" to 0xFFA52A2A.toInt(),
+        "gold" to 0xFFFFD700.toInt(),
+        "indigo" to 0xFF4B0082.toInt(),
+        "violet" to 0xFFEE82EE.toInt(),
+        "coral" to 0xFFFF7F50.toInt(),
+        "salmon" to 0xFFFA8072.toInt(),
+        "tomato" to 0xFFFF6347.toInt(),
+        "crimson" to 0xFFDC143C.toInt(),
+        "khaki" to 0xFFF0E68C.toInt(),
+        "beige" to 0xFFF5F5DC.toInt(),
+        "ivory" to 0xFFFFFFF0.toInt(),
+        "tan" to 0xFFD2B48C.toInt(),
+        "turquoise" to 0xFF40E0D0.toInt(),
+        "skyblue" to 0xFF87CEEB.toInt(),
+        "steelblue" to 0xFF4682B4.toInt(),
+        "royalblue" to 0xFF4169E1.toInt(),
+        "dodgerblue" to 0xFF1E90FF.toInt(),
+        "slategray" to 0xFF708090.toInt(),
+        "slategrey" to 0xFF708090.toInt(),
+        "whitesmoke" to 0xFFF5F5F5.toInt(),
+        "snow" to 0xFFFFFAFA.toInt(),
+        "seagreen" to 0xFF2E8B57.toInt(),
+        "forestgreen" to 0xFF228B22.toInt(),
+        "darkgreen" to 0xFF006400.toInt(),
+        "lightblue" to 0xFFADD8E6.toInt(),
+        "lightgreen" to 0xFF90EE90.toInt(),
+        "darkblue" to 0xFF00008B.toInt(),
+        "darkred" to 0xFF8B0000.toInt(),
+        "orangered" to 0xFFFF4500.toInt(),
+        "hotpink" to 0xFFFF69B4.toInt(),
+        "deeppink" to 0xFFFF1493.toInt(),
+        "chocolate" to 0xFFD2691E.toInt(),
+        "plum" to 0xFFDDA0DD.toInt(),
+        "lavender" to 0xFFE6E6FA.toInt(),
+        "mintcream" to 0xFFF5FFFA.toInt(),
+        "gainsboro" to 0xFFDCDCDC.toInt(),
+    )
+
+    /** Parse `value` into a signed ARGB int, or `null` when unparseable. */
+    fun parse(value: Any?): Int? {
+        return when (value) {
+            null, JSONObject.NULL -> null
+            is Boolean -> null
+            is Int -> if (value ushr 24 == 0) value or 0xFF000000.toInt() else value
+            is Long -> parseLong(value)
+            is Number -> {
+                val d = value.toDouble()
+                if (d.isNaN() || d.isInfinite()) null else parseLong(d.toLong())
+            }
+            is String -> parseString(value)
+            is JSONArray -> parseArray((0 until value.length()).map { value.opt(it) })
+            is List<*> -> parseArray(value)
+            else -> null
+        }
+    }
+
+    /** Parse `value`, falling back to `default` when unparseable. */
+    fun parseOr(value: Any?, default: Int): Int = parse(value) ?: default
+
+    /** Replace the alpha channel of `color` with `alpha` in `0..1`. */
+    fun withAlpha(color: Int, alpha: Double): Int {
+        val a = (alpha.coerceIn(0.0, 1.0) * 255.0).toInt()
+        return (color and 0x00FFFFFF) or (a shl 24)
+    }
+
+    private fun parseLong(raw: Long): Int {
+        val masked = raw and 0xFFFFFFFFL
+        val withAlpha = if (masked ushr 24 == 0L) masked or 0xFF000000L else masked
+        return withAlpha.toInt()
+    }
+
+    private fun parseArray(items: List<Any?>): Int? {
+        if (items.size < 3) return null
+        val r = channel(items[0]) ?: return null
+        val g = channel(items[1]) ?: return null
+        val b = channel(items[2]) ?: return null
+        val a = if (items.size >= 4) alphaChannel(items[3]) ?: return null else 255
+        return argb(a, r, g, b)
+    }
+
+    private fun parseString(raw: String): Int? {
+        val s = raw.trim()
+        if (s.isEmpty()) return null
+        if (s.startsWith("#")) return parseHex(s.substring(1))
+        val lower = s.lowercase()
+        named[lower]?.let { return it }
+        if (lower.startsWith("rgb")) return parseFunctional(lower)
+        if (lower.startsWith("0x")) return s.substring(2).toLongOrNull(16)?.let { parseLong(it) }
+        return s.toLongOrNull(16)?.takeIf { s.length == 6 || s.length == 8 }?.let {
+            parseHexDigits(s)
+        }
+    }
+
+    private fun parseHex(digits: String): Int? {
+        if (digits.isEmpty() || !digits.all { it.isLetterOrDigit() }) return null
+        val expanded = when (digits.length) {
+            3 -> "FF" + digits.map { "$it$it" }.joinToString("")
+            4 -> {
+                // CSS #RGBA: alpha is the last digit.
+                val rgb = digits.substring(0, 3).map { "$it$it" }.joinToString("")
+                val a = "${digits[3]}${digits[3]}"
+                a + rgb
+            }
+            6 -> "FF$digits"
+            8 -> digits
+            else -> return null
+        }
+        return expanded.toLongOrNull(16)?.toInt()
+    }
+
+    private fun parseHexDigits(digits: String): Int? = parseHex(digits)
+
+    private fun parseFunctional(lower: String): Int? {
+        val open = lower.indexOf('(')
+        val close = lower.lastIndexOf(')')
+        if (open < 0 || close < open) return null
+        val parts = lower.substring(open + 1, close).split(',', '/', ' ').map { it.trim() }.filter { it.isNotEmpty() }
+        if (parts.size < 3) return null
+        val r = channel(parts[0]) ?: return null
+        val g = channel(parts[1]) ?: return null
+        val b = channel(parts[2]) ?: return null
+        val a = if (parts.size >= 4) alphaChannel(parts[3]) ?: return null else 255
+        return argb(a, r, g, b)
+    }
+
+    private fun channel(value: Any?): Int? {
+        val d = when (value) {
+            is Number -> value.toDouble()
+            is String -> {
+                val t = value.trim()
+                if (t.endsWith("%")) (t.dropLast(1).toDoubleOrNull() ?: return null) * 2.55
+                else t.toDoubleOrNull() ?: return null
+            }
+            else -> return null
+        }
+        return d.toInt().coerceIn(0, 255)
+    }
+
+    private fun alphaChannel(value: Any?): Int? {
+        val d = when (value) {
+            is Number -> value.toDouble()
+            is String -> {
+                val t = value.trim()
+                if (t.endsWith("%")) (t.dropLast(1).toDoubleOrNull() ?: return null) / 100.0
+                else t.toDoubleOrNull() ?: return null
+            }
+            else -> return null
+        }
+        // Values above 1 are taken as 0..255 bytes.
+        val a = if (d > 1.0) d / 255.0 else d
+        return (a.coerceIn(0.0, 1.0) * 255.0 + 0.5).toInt()
+    }
+
+    private fun argb(a: Int, r: Int, g: Int, b: Int): Int =
+        (a shl 24) or (r shl 16) or (g shl 8) or b
+}

pythonnative/native/android/src/main/java/com/pythonnative/runtime/components/PickerManager.kt

@@ -0,0 +1,86 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.view.View
+import android.widget.AdapterView
+import android.widget.ArrayAdapter
+import android.widget.Spinner
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONArray
+import org.json.JSONObject
+
+/** `Picker` element: a native `Spinner` dropdown over `items` of `{label, value}`. */
+class PickerManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val spinner = Spinner(context)
+        spinner.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
+            override fun onItemSelected(parent: AdapterView<*>, view: View?, position: Int, id: Long) {
+                if (stateOf(parent)["suppress"] == true) return
+                val items = propsOf(parent).value("items") as? JSONArray ?: return
+                if (position < 0 || position >= items.length()) return
+                fire(parent, "on_change", itemValue(items.opt(position)))
+            }
+
+            override fun onNothingSelected(parent: AdapterView<*>) {}
+        }
+        return spinner
+    }
+
+    private fun itemValue(item: Any?): Any? = when (item) {
+        is JSONObject -> item.value("value")
+        JSONObject.NULL -> null
+        else -> item
+    }
+
+    private fun itemLabel(item: Any?): String = when (item) {
+        is JSONObject -> item.str("label") ?: item.str("value") ?: ""
+        null, JSONObject.NULL -> ""
+        else -> item.toString()
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val spinner = view as Spinner
+        val state = stateOf(spinner)
+        val merged = propsOf(spinner)
+        val items = merged.value("items") as? JSONArray ?: JSONArray()
+        if (props.has("items") || initial) {
+            val labels = (0 until items.length()).map { itemLabel(items.opt(it)) }
+            val adapter = ArrayAdapter(spinner.context, android.R.layout.simple_spinner_item, labels)
+            adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
+            state["suppress"] = true
+            try {
+                spinner.adapter = adapter
+            } finally {
+                state["suppress"] = false
+            }
+        }
+        if (props.has("value") || props.has("selected_value") || initial) {
+            val value = merged.value("value") ?: merged.value("selected_value")
+            var target = -1
+            for (i in 0 until items.length()) {
+                if (valuesEqual(itemValue(items.opt(i)), value)) {
+                    target = i
+                    break
+                }
+            }
+            if (target >= 0 && spinner.selectedItemPosition != target) {
+                state["suppress"] = true
+                try {
+                    spinner.setSelection(target, false)
+                } finally {
+                    state["suppress"] = false
+                }
+            }
+        }
+        if (props.has("disabled")) spinner.isEnabled = !JsonUtil.truthy(props.value("disabled"))
+        ViewStyler.apply(spinner, props)
+    }
+
+    private fun valuesEqual(a: Any?, b: Any?): Boolean {
+        if (a == b) return true
+        if (a is Number && b is Number) return a.toDouble() == b.toDouble()
+        return a != null && b != null && a.toString() == b.toString()
+    }
+}

pythonnative/native/android/src/main/java/com/pythonnative/runtime/components/PortalManager.kt

@@ -0,0 +1,55 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import com.pythonnative.runtime.screens.ScreenRegistry
+import org.json.JSONObject
+
+/**
+ * `Portal` element: floats its children over the screen in a full-size,
+ * non-clickable overlay added directly to the screen's fragment
+ * container (the same parent as the screen root, so portal coordinates
+ * equal viewport coordinates). The overlay attaches lazily on the first
+ * child insert and re-homes itself if the container changed.
+ */
+class PortalManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val overlay = FrameLayout(context)
+        overlay.isClickable = false
+        return overlay
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        ViewStyler.apply(view, props)
+        if (!initial) ensureAttached(view)
+    }
+
+    private fun ensureAttached(overlay: View) {
+        val container = ScreenRegistry.activeContainer() ?: return
+        val parent = overlay.parent as? ViewGroup
+        if (parent === container) {
+            overlay.bringToFront()
+            return
+        }
+        parent?.removeView(overlay)
+        container.addView(
+            overlay,
+            ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT),
+        )
+    }
+
+    override fun insertChild(parent: View, child: View, index: Int) {
+        ensureAttached(parent)
+        ViewChildren.insert(parent as ViewGroup, child, index)
+    }
+
+    override fun setFrame(view: View, x: Double, y: Double, width: Double, height: Double) {
+        // The overlay fills its container; the engine frames only the portal's children.
+    }
+
+    override fun teardown(view: View) {
+        (view.parent as? ViewGroup)?.removeView(view)
+    }
+}

pythonnative/native/android/src/main/java/com/pythonnative/runtime/components/PressableManager.kt

@@ -0,0 +1,122 @@
+package com.pythonnative.runtime.components
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.drawable.RippleDrawable
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewConfiguration
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.MainThread
+import com.pythonnative.runtime.bridge.num
+import com.pythonnative.runtime.bridge.value
+import com.pythonnative.runtime.gestures.GestureCoordinator
+import com.pythonnative.runtime.views.PNFrameLayout
+import org.json.JSONObject
+import kotlin.math.hypot
+
+/**
+ * `Pressable` element: a container dispatching press events from one
+ * touch stream. `on_press_in` at finger-down (plus an opacity dip),
+ * `on_long_press` after the long-press timeout, `on_press` on a clean
+ * release, and `on_press_out` when the finger lifts or the touch
+ * cancels. The same stream feeds the gesture coordinator so press
+ * feedback and pan/pinch recognition coexist on one view.
+ */
+class PressableManager : ViewManager() {
+    private class Press(val downX: Double, val downY: Double, val seq: Int) {
+        var moved = false
+        var longFired = false
+    }
+
+    @SuppressLint("ClickableViewAccessibility")
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val view = PNFrameLayout(context)
+        view.isClickable = true
+        view.isFocusable = true
+        view.setOnTouchListener { v, event -> onTouch(v, event) }
+        return view
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        // Press handling owns the touch listener; gesture specs are fed from inside it.
+        stateOf(view)["gestures_bound"] = true
+        super.applyProps(view, props, initial)
+        if (props.has("ripple") || props.has("android_ripple")) applyRipple(view, props)
+        if (props.has("disabled")) view.isEnabled = !JsonUtil.truthy(props.value("disabled"))
+    }
+
+    private fun applyRipple(view: View, props: JSONObject) {
+        val spec = props.value("android_ripple") ?: props.value("ripple")
+        if (spec == null || spec == false) {
+            view.foreground = null
+            return
+        }
+        val color = when (spec) {
+            is JSONObject -> PNColor.parse(spec.value("color"))
+            else -> PNColor.parse(spec)
+        } ?: 0x33000000
+        val borderless = (spec as? JSONObject)?.let { JsonUtil.truthy(it.value("borderless")) } ?: false
+        val mask = if (borderless) null else android.graphics.drawable.ColorDrawable(0xFFFFFFFF.toInt())
+        view.foreground = RippleDrawable(ColorStateList.valueOf(color), null, mask)
+    }
+
+    private fun onTouch(view: View, event: MotionEvent): Boolean {
+        if (ViewStyler.pointerEventsBlocked(view)) return false
+        val record = recordOf(view) ?: return false
+        GestureCoordinator.feed(record, event)
+        if (!view.isEnabled) return true
+        val state = record.state
+        val merged = record.props
+        val density = view.resources.displayMetrics.density
+        val x = event.x / density
+        val y = event.y / density
+        when (event.actionMasked) {
+            MotionEvent.ACTION_DOWN -> {
+                val seq = ((state["press_seq"] as? Int) ?: 0) + 1
+                val press = Press(x.toDouble(), y.toDouble(), seq)
+                state["press"] = press
+                state["press_seq"] = seq
+                fire(view, "on_press_in")
+                val opacity = merged.num("pressed_opacity") ?: merged.num("active_opacity") ?: 0.6
+                if (opacity < 1.0) view.animate().alpha(opacity.toFloat()).setDuration(50).start()
+                if (hasEvent(view, "on_long_press")) {
+                    val delay = merged.num("delay_long_press")?.toLong() ?: ViewConfiguration.getLongPressTimeout().toLong().coerceAtLeast(500L)
+                    MainThread.postDelayed({
+                        val live = recordOf(view)?.state?.get("press") as? Press ?: return@postDelayed
+                        if (live.seq != seq || live.moved || live.longFired) return@postDelayed
+                        live.longFired = true
+                        fire(view, "on_long_press")
+                    }, delay)
+                }
+                view.isPressed = true
+                return true
+            }
+            MotionEvent.ACTION_MOVE -> {
+                val press = state["press"] as? Press ?: return true
+                val slop = merged.num("tap_slop") ?: TAP_SLOP_DP
+                if (hypot(x - press.downX, y - press.downY) > slop) press.moved = true
+                return true
+            }
+            MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+                val press = state["press"] as? Press
+                state["press"] = null
+                view.isPressed = false
+                if (press == null) return true
+                fire(view, "on_press_out")
+                view.animate().alpha(1f).setDuration(100).start()
+                if (event.actionMasked == MotionEvent.ACTION_UP && !press.moved && !press.longFired) {
+                    view.performClick()
+                    fire(view, "on_press")
+                }
+                return true
+            }
+        }
+        return true
+    }
+
+    private companion object {
+        const val TAP_SLOP_DP = 12.0
+    }
+}