pythonnative 0.40.0__cp313-cp313-win_amd64.whl

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

@@ -0,0 +1,250 @@
+package com.pythonnative.runtime.components
+
+import com.pythonnative.runtime.PNBridge
+
+import android.content.Context
+import android.os.Build
+import android.text.Editable
+import android.text.InputFilter
+import android.text.InputType
+import android.text.TextWatcher
+import android.view.MotionEvent
+import android.view.View
+import android.view.inputmethod.EditorInfo
+import android.view.inputmethod.InputMethodManager
+import android.widget.EditText
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.PNLog
+import com.pythonnative.runtime.bridge.num
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import com.pythonnative.runtime.views.PNEditText
+import org.json.JSONObject
+import kotlin.math.max
+import kotlin.math.min
+
+/**
+ * `TextInput` element: an `EditText` reporting `on_change`, `on_submit`,
+ * `on_focus`, `on_blur`, and `on_selection_change`, with keyboard type,
+ * secure entry, return key, autofill, and clear-button props.
+ */
+class TextInputManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val et = PNEditText(context)
+        // Default to single-line so Enter triggers the IME action instead of a newline.
+        if (!JsonUtil.truthy(props.value("multiline"))) et.setSingleLine(true)
+        bindListeners(et)
+        return et
+    }
+
+    private fun bindListeners(et: PNEditText) {
+        et.addTextChangedListener(object : TextWatcher {
+            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
+            override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
+            override fun afterTextChanged(s: Editable?) {
+                if (stateOf(et)["suppress"] == true) return
+                fire(et, "on_change", s?.toString() ?: "")
+                PNBridge.registry.tagOf(et)?.let { com.pythonnative.runtime.layout.NativeLayout.invalidate(it) }
+            }
+        })
+        et.setOnFocusChangeListener { v, hasFocus -> fire(v, if (hasFocus) "on_focus" else "on_blur") }
+        et.onSelectionChangedListener = { start, end ->
+            if (hasEvent(et, "on_selection_change")) {
+                fire(et, "on_selection_change", mapOf("start" to start, "end" to end))
+            }
+        }
+        installEditorAction(et)
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val et = view as EditText
+        val state = stateOf(et)
+        val merged = propsOf(et)
+        if (props.has("value")) {
+            val incoming = props.str("value") ?: ""
+            val acknowledged = props.optLong("_pn_edit_revision", 0)
+            val edited = (state["edit_revision"] as? Number)?.toLong() ?: 0L
+            if (et.text.toString() != incoming && acknowledged >= edited && android.view.inputmethod.BaseInputConnection.getComposingSpanStart(et.text) < 0) {
+                val selStart = et.selectionStart
+                val selEnd = et.selectionEnd
+                state["suppress"] = true
+                try {
+                    et.setText(incoming)
+                    val maxPos = incoming.length
+                    val start = max(0, min(selStart, maxPos))
+                    val end = max(0, min(selEnd, maxPos))
+                    if (start == end) et.setSelection(start) else et.setSelection(start, end)
+                } catch (e: Exception) {
+                    PNLog.swallowed("TextInputManager.value", e)
+                } finally {
+                    state["suppress"] = false
+                }
+            }
+        }
+        if (props.has("placeholder")) et.hint = props.str("placeholder") ?: ""
+        PNColor.parse(props.value("placeholder_color"))?.let { et.setHintTextColor(it) }
+        props.num("font_size")?.let { et.textSize = it.toFloat() }
+        PNColor.parse(props.value("color"))?.let { et.setTextColor(it) }
+        if (listOf("font_family", "font_weight", "italic", "bold").any { props.has(it) }) {
+            TextStyle.applyTypeface(et, merged)
+        }
+        if (listOf("multiline", "secure", "secure_text_entry", "keyboard_type", "auto_capitalize", "auto_correct").any { props.has(it) }) {
+            applyInputType(et, merged)
+        }
+        if (props.has("max_length")) {
+            val limit = props.num("max_length")
+            et.filters = if (limit != null) arrayOf<InputFilter>(InputFilter.LengthFilter(limit.toInt())) else arrayOf()
+        }
+        if (JsonUtil.truthy(props.value("auto_focus"))) et.requestFocus()
+        if (props.has("editable")) {
+            // Only present when False (read-only); removal restores editing.
+            val editable = props.value("editable") != false
+            et.isFocusable = editable
+            et.isFocusableInTouchMode = editable
+            et.isCursorVisible = editable
+            et.isLongClickable = editable
+        }
+        PNColor.parse(props.value("selection_color"))?.let { et.highlightColor = it }
+        props.str("text_content_type")?.let { applyAutofill(et, it) }
+        if (props.has("clear_button")) applyClearButton(et, JsonUtil.truthy(props.value("clear_button")))
+        props.str("return_key_type")?.let { et.imeOptions = imeAction(it) }
+        if (props.has("text_align")) {
+            et.gravity = when (props.str("text_align")) {
+                "center" -> android.view.Gravity.CENTER_HORIZONTAL or (et.gravity and android.view.Gravity.VERTICAL_GRAVITY_MASK)
+                "right", "end" -> android.view.Gravity.END or (et.gravity and android.view.Gravity.VERTICAL_GRAVITY_MASK)
+                else -> android.view.Gravity.START or (et.gravity and android.view.Gravity.VERTICAL_GRAVITY_MASK)
+            }
+        }
+        ViewStyler.apply(et, props)
+    }
+
+    private fun applyInputType(et: EditText, merged: JSONObject) {
+        var base = InputType.TYPE_CLASS_TEXT
+        val secure = JsonUtil.truthy(merged.value("secure")) || JsonUtil.truthy(merged.value("secure_text_entry"))
+        if (secure) {
+            base = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD
+        } else {
+            when (merged.str("keyboard_type")) {
+                "email_address", "email" -> base = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS
+                "number_pad", "numeric" -> base = InputType.TYPE_CLASS_NUMBER
+                "decimal_pad", "decimal" -> base = InputType.TYPE_CLASS_NUMBER or InputType.TYPE_NUMBER_FLAG_DECIMAL
+                "phone_pad", "phone" -> base = InputType.TYPE_CLASS_PHONE
+                "url" -> base = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_URI
+            }
+            when (merged.str("auto_capitalize")) {
+                "sentences" -> base = base or InputType.TYPE_TEXT_FLAG_CAP_SENTENCES
+                "words" -> base = base or InputType.TYPE_TEXT_FLAG_CAP_WORDS
+                "characters" -> base = base or InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS
+            }
+            if (merged.value("auto_correct") == false) base = base or InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS
+        }
+        if (JsonUtil.truthy(merged.value("multiline"))) {
+            base = base or InputType.TYPE_TEXT_FLAG_MULTI_LINE
+            et.setSingleLine(false)
+        } else {
+            et.setSingleLine(true)
+        }
+        et.inputType = base
+    }
+
+    private fun imeAction(type: String): Int = when (type) {
+        "default" -> EditorInfo.IME_ACTION_UNSPECIFIED
+        "go" -> EditorInfo.IME_ACTION_GO
+        "next" -> EditorInfo.IME_ACTION_NEXT
+        "search" -> EditorInfo.IME_ACTION_SEARCH
+        "send" -> EditorInfo.IME_ACTION_SEND
+        "previous" -> EditorInfo.IME_ACTION_PREVIOUS
+        else -> EditorInfo.IME_ACTION_DONE // done, google, join, route, yahoo
+    }
+
+    /**
+     * Single-line inputs always dismiss the keyboard on the action key and
+     * fire `on_submit` first. Multi-line inputs only consume the action
+     * when an `on_submit` handler exists; otherwise Enter inserts a newline.
+     */
+    private fun installEditorAction(et: EditText) {
+        et.setOnEditorActionListener { v, _, _ ->
+            val multiline = JsonUtil.truthy(propsOf(v).value("multiline"))
+            val hasSubmit = hasEvent(v, "on_submit")
+            if (multiline && !hasSubmit) return@setOnEditorActionListener false
+            if (hasSubmit) fire(v, "on_submit", v.text.toString())
+            if (!multiline && propsOf(v).value("blur_on_submit") != false) blur(v)
+            true
+        }
+    }
+
+    private fun applyAutofill(et: EditText, contentType: String) {
+        if (Build.VERSION.SDK_INT < 26) return
+        val hint = when (contentType) {
+            "username" -> View.AUTOFILL_HINT_USERNAME
+            "password" -> View.AUTOFILL_HINT_PASSWORD
+            "new_password" -> "newPassword"
+            "email", "email_address" -> View.AUTOFILL_HINT_EMAIL_ADDRESS
+            "name" -> View.AUTOFILL_HINT_NAME
+            "given_name" -> "personGivenName"
+            "family_name" -> "personFamilyName"
+            "telephone", "phone", "phone_number" -> View.AUTOFILL_HINT_PHONE
+            "postal_code" -> View.AUTOFILL_HINT_POSTAL_CODE
+            "street_address" -> View.AUTOFILL_HINT_POSTAL_ADDRESS
+            "credit_card_number" -> View.AUTOFILL_HINT_CREDIT_CARD_NUMBER
+            "one_time_code" -> "smsOTPCode"
+            else -> null
+        } ?: return
+        et.setAutofillHints(hint)
+    }
+
+    private fun applyClearButton(et: EditText, enabled: Boolean) {
+        val state = stateOf(et)
+        if (!enabled) {
+            et.setCompoundDrawablesWithIntrinsicBounds(0, 0, 0, 0)
+            return
+        }
+        et.setCompoundDrawablesWithIntrinsicBounds(0, 0, android.R.drawable.ic_menu_close_clear_cancel, 0)
+        if (state["clear_bound"] == true) return
+        state["clear_bound"] = true
+        et.setOnTouchListener { v, event ->
+            if (event.action == MotionEvent.ACTION_UP) {
+                val right = (v as EditText).compoundDrawables.getOrNull(2)
+                if (right != null) {
+                    val threshold = v.width - v.paddingRight - right.bounds.width()
+                    if (event.x >= threshold) {
+                        v.setText("")
+                        v.performClick()
+                        return@setOnTouchListener true
+                    }
+                }
+            }
+            false
+        }
+    }
+
+    override fun command(view: View, name: String, args: JSONObject): Any? {
+        val et = view as? EditText ?: return null
+        when (name) {
+            "focus" -> {
+                et.requestFocus()
+                imm(et)?.showSoftInput(et, InputMethodManager.SHOW_IMPLICIT)
+            }
+            "blur" -> blur(et)
+            "clear" -> et.setText("")
+            "select_all" -> et.selectAll()
+            "set_selection" -> {
+                val start = JsonUtil.toInt(args.opt("start"))
+                val end = JsonUtil.toInt(args.opt("end"), start)
+                val len = et.text.length
+                et.setSelection(start.coerceIn(0, len), end.coerceIn(0, len))
+            }
+            "is_focused" -> return et.isFocused
+            "get_value" -> return et.text.toString()
+        }
+        return null
+    }
+
+    private fun blur(view: View) {
+        view.clearFocus()
+        imm(view)?.hideSoftInputFromWindow(view.windowToken, 0)
+    }
+
+    private fun imm(view: View): InputMethodManager? =
+        view.context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
+}

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

@@ -0,0 +1,233 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.graphics.Paint
+import android.graphics.Typeface
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.text.TextUtils
+import android.text.style.AbsoluteSizeSpan
+import android.text.style.BackgroundColorSpan
+import android.text.style.ForegroundColorSpan
+import android.text.style.StrikethroughSpan
+import android.text.style.StyleSpan
+import android.text.style.TypefaceSpan
+import android.text.style.UnderlineSpan
+import android.view.Gravity
+import android.view.View
+import android.widget.TextView
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.PNLog
+import com.pythonnative.runtime.bridge.num
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONArray
+import org.json.JSONObject
+import kotlin.math.max
+
+/** Text helpers shared by `Text`, `Button`, and `TextInput`. */
+object TextStyle {
+    private val boldWords = setOf("bold", "semibold", "black", "heavy", "extrabold", "extra_bold", "semi_bold")
+
+    /** Whether `weight` (a name or a numeric weight) implies bold. */
+    fun isBold(weight: Any?): Boolean {
+        return when (weight) {
+            is String -> weight.lowercase() in boldWords || (weight.toIntOrNull()?.let { it >= 600 } ?: false)
+            is Number -> weight.toDouble() >= 600
+            else -> false
+        }
+    }
+
+    /** `Typeface` style constant for `weight` / `italic`. */
+    fun typefaceStyle(weight: Any?, italic: Boolean): Int {
+        val bold = isBold(weight)
+        return when {
+            bold && italic -> Typeface.BOLD_ITALIC
+            bold -> Typeface.BOLD
+            italic -> Typeface.ITALIC
+            else -> Typeface.NORMAL
+        }
+    }
+
+    /** Apply `text_transform` to `text`; `capitalize` upper-cases each word's first letter. */
+    fun transform(text: String?, mode: String?): String {
+        val s = text ?: ""
+        return when (mode) {
+            "uppercase" -> s.uppercase()
+            "lowercase" -> s.lowercase()
+            "capitalize" -> {
+                val sb = StringBuilder(s.length)
+                var atWordStart = true
+                for (ch in s) {
+                    if (ch.isWhitespace()) {
+                        atWordStart = true
+                        sb.append(ch)
+                    } else {
+                        sb.append(if (atWordStart) ch.uppercaseChar() else ch)
+                        atWordStart = false
+                    }
+                }
+                sb.toString()
+            }
+            else -> s
+        }
+    }
+
+    /** Coerce a `shadow_offset` value (`{width, height}` or `[dx, dy]`) to `(dx, dy)`. */
+    fun shadowOffset(value: Any?): Pair<Double, Double> {
+        return when (value) {
+            is JSONObject -> Pair(value.num("width") ?: 0.0, value.num("height") ?: 0.0)
+            is JSONArray -> if (value.length() >= 2) Pair(JsonUtil.toDouble(value.opt(0)), JsonUtil.toDouble(value.opt(1))) else Pair(0.0, 0.0)
+            else -> Pair(0.0, 0.0)
+        }
+    }
+
+    /** Build a spannable from a rich-text span list, applying `transform` per span. */
+    fun buildSpannable(spans: JSONArray, transform: String?): SpannableStringBuilder {
+        val builder = SpannableStringBuilder()
+        for (i in 0 until spans.length()) {
+            val span = spans.optJSONObject(i) ?: continue
+            val text = transform(span.str("text"), transform)
+            if (text.isEmpty()) continue
+            val start = builder.length
+            builder.append(text)
+            val end = builder.length
+            fun set(obj: Any) = builder.setSpan(obj, start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+            try {
+                PNColor.parse(span.value("color"))?.let { set(ForegroundColorSpan(it)) }
+                PNColor.parse(span.value("background_color"))?.let { set(BackgroundColorSpan(it)) }
+                span.num("font_size")?.let { set(AbsoluteSizeSpan(it.toInt(), true)) }
+                var bold = JsonUtil.truthy(span.value("bold"))
+                val weight = span.value("font_weight")
+                if (!bold && weight != null) bold = isBold(weight)
+                val italic = JsonUtil.truthy(span.value("italic"))
+                if (bold || italic) set(StyleSpan(typefaceStyle(if (bold) "bold" else null, italic)))
+                span.str("font_family")?.takeIf { it.isNotEmpty() }?.let { set(TypefaceSpan(it)) }
+                when (span.str("text_decoration")) {
+                    "underline" -> set(UnderlineSpan())
+                    "line_through" -> set(StrikethroughSpan())
+                }
+            } catch (e: Exception) {
+                PNLog.swallowed("TextStyle.buildSpannable", e)
+            }
+        }
+        return builder
+    }
+
+    /** Apply font props (`font_family`, `font_weight`, `bold`, `italic`) from merged props. */
+    fun applyTypeface(tv: TextView, merged: JSONObject) {
+        val family = merged.str("font_family")
+        val weight = merged.value("font_weight") ?: if (JsonUtil.truthy(merged.value("bold"))) "bold" else null
+        val italic = JsonUtil.truthy(merged.value("italic"))
+        val style = typefaceStyle(weight, italic)
+        if (!family.isNullOrEmpty()) {
+            tv.setTypeface(Typeface.create(family, style))
+        } else {
+            tv.setTypeface(tv.typeface, style)
+        }
+    }
+}
+
+/** `Text` element: a `TextView` with rich spans, transforms, shadows, and line limits. */
+class TextManager : ComponentManager() {
+    private val shadowKeys = listOf("text_shadow_color", "text_shadow_offset", "text_shadow_radius")
+
+    override fun createView(context: Context, tag: Long, props: JSONObject): View = TextView(context)
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val tv = view as TextView
+        val merged = propsOf(tv)
+        if (props.has("spans") || props.has("text") || props.has("text_transform")) {
+            val transform = merged.str("text_transform")
+            val spans = merged.value("spans") as? JSONArray
+            if (spans != null && spans.length() > 0) {
+                try {
+                    tv.text = TextStyle.buildSpannable(spans, transform)
+                } catch (e: Exception) {
+                    tv.text = TextStyle.transform(merged.str("text"), transform)
+                }
+            } else {
+                tv.text = TextStyle.transform(merged.str("text"), transform)
+            }
+        }
+        props.num("font_size")?.let { tv.textSize = it.toFloat() }
+        PNColor.parse(props.value("color"))?.let { tv.setTextColor(it) }
+        if (listOf("font_family", "font_weight", "italic", "bold").any { props.has(it) }) {
+            try {
+                TextStyle.applyTypeface(tv, merged)
+            } catch (e: Exception) {
+                PNLog.swallowed("TextManager.typeface", e)
+            }
+        }
+        if (props.has("max_lines") || props.has("number_of_lines")) {
+            val lines = merged.num("number_of_lines") ?: merged.num("max_lines")
+            if (lines != null && lines > 0) {
+                tv.maxLines = lines.toInt()
+                tv.ellipsize = ellipsizeMode(merged.str("ellipsize_mode") ?: merged.str("ellipsize"))
+            } else {
+                tv.maxLines = Int.MAX_VALUE
+                tv.ellipsize = null
+            }
+        }
+        if (props.has("ellipsize_mode") || props.has("ellipsize")) {
+            if (tv.maxLines != Int.MAX_VALUE) tv.ellipsize = ellipsizeMode(merged.str("ellipsize_mode") ?: merged.str("ellipsize"))
+        }
+        if (props.has("selectable")) tv.setTextIsSelectable(JsonUtil.truthy(props.value("selectable")))
+        if (props.has("text_align")) {
+            tv.gravity = when (props.str("text_align")) {
+                "center" -> Gravity.CENTER
+                "right", "end" -> Gravity.END
+                "justify" -> Gravity.START
+                else -> Gravity.START
+            }
+        }
+        props.num("letter_spacing")?.let {
+            // Android takes letter spacing in ems (a ratio of the font size).
+            val size = merged.num("font_size") ?: 16.0
+            tv.letterSpacing = (it / max(size, 1.0)).toFloat()
+        }
+        props.num("line_height")?.let {
+            val size = merged.num("font_size") ?: 16.0
+            tv.setLineSpacing(0f, (it / max(size, 1.0)).toFloat())
+        }
+        if (props.has("text_decoration")) {
+            var flags = tv.paintFlags and Paint.UNDERLINE_TEXT_FLAG.inv() and Paint.STRIKE_THRU_TEXT_FLAG.inv()
+            when (props.str("text_decoration")) {
+                "underline" -> flags = flags or Paint.UNDERLINE_TEXT_FLAG
+                "line_through" -> flags = flags or Paint.STRIKE_THRU_TEXT_FLAG
+            }
+            tv.paintFlags = flags
+        }
+        if (shadowKeys.any { props.has(it) }) applyTextShadow(tv, merged)
+        ViewStyler.apply(tv, props)
+    }
+
+    private fun ellipsizeMode(mode: String?): TextUtils.TruncateAt = when (mode) {
+        "head" -> TextUtils.TruncateAt.START
+        "middle" -> TextUtils.TruncateAt.MIDDLE
+        "clip" -> TextUtils.TruncateAt.END
+        "marquee" -> TextUtils.TruncateAt.MARQUEE
+        else -> TextUtils.TruncateAt.END
+    }
+
+    private fun applyTextShadow(tv: TextView, merged: JSONObject) {
+        if (shadowKeys.none { merged.value(it) != null }) {
+            tv.setShadowLayer(0f, 0f, 0f, 0)
+            return
+        }
+        val argb = PNColor.parseOr(merged.value("text_shadow_color") ?: "#000000", 0xFF000000.toInt())
+        val (dx, dy) = TextStyle.shadowOffset(merged.value("text_shadow_offset"))
+        var radiusPx = merged.num("text_shadow_radius")?.let { pxF(it) } ?: 0f
+        // A zero radius with an offset hides the shadow on some renderers; use a hairline blur.
+        if (radiusPx <= 0f && (dx != 0.0 || dy != 0.0)) radiusPx = 0.01f
+        tv.setShadowLayer(radiusPx, pxF(dx), pxF(dy), argb)
+    }
+
+    override fun setAnimatedProperty(view: View, prop: String, value: Any?) {
+        if (prop == "color" && view is TextView) {
+            PNColor.parse(value)?.let { view.setTextColor(it) }
+            return
+        }
+        super.setAnimatedProperty(view, prop, value)
+    }
+}