search bar in resources

loerting · loerting · commit 9cc1e9a1048d · 2025-07-31T15:45:18.000+02:00
diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml
@@ -115,4 +115,6 @@
     <string name="lookup_popup_current_class">This is the current class.</string>
     <string name="lookup_popup_runtime">Likely an Android or Java runtime class.</string>
 
+    <string name="resources_search_placeholder">Filter by id or name</string>
+
 </resources>
diff --git a/composeApp/src/commonMain/kotlin/me/lkl/dalvikus/tree/TreeSearch.kt b/composeApp/src/commonMain/kotlin/me/lkl/dalvikus/tree/TreeSearch.kt
@@ -17,11 +17,8 @@ import kotlinx.coroutines.flow.flow
 import me.lkl.dalvikus.icons.FamilyHistory
 import me.lkl.dalvikus.icons.ThreadUnread
 import me.lkl.dalvikus.tree.dex.DexEntryClassNode
-
-data class SearchOptions(
-    val caseSensitive: Boolean = false,
-    val useRegex: Boolean = false
-)
+import me.lkl.dalvikus.util.SearchOptions
+import me.lkl.dalvikus.util.createSearchMatcher
 
 enum class TreeSearchResultType {
     TREE_NODE,
@@ -53,22 +50,7 @@ fun searchTreeBFS(
     maxResults: Int = 500
 ): Flow<TreeSearchResult> = flow {
     // TODO search for resources by resource name, not by literal
-    val matcher: (String) -> Boolean = if (options.useRegex) {
-        // Compile regex with case option
-        val regex = try {
-            Regex(
-                query,
-                if (options.caseSensitive) setOf() else setOf(RegexOption.IGNORE_CASE)
-            )
-        } catch (_: Exception) {
-            return@flow // Invalid regex: skip search
-        }
-        { input -> regex.containsMatchIn(input) }
-    } else {
-        { input ->
-            input.contains(query, ignoreCase = !options.caseSensitive)
-        }
-    }
+    val matcher: (String) -> Boolean = createSearchMatcher(query, options) ?: return@flow
 
     val queue = ArrayDeque<Node>()
     queue.add(root)
@@ -94,7 +76,6 @@ fun searchTreeBFS(
                 }
             }
 
-            // Search method references
             classDef.methods.forEach { method ->
                 method.implementation?.instructions?.forEach { instruction ->
                     if (instruction is ReferenceInstruction) {
@@ -115,9 +96,10 @@ fun searchTreeBFS(
                         }
                     } else if (instruction is WideLiteralInstruction) {
                         val value = instruction.wideLiteral.toString()
-                        val hexValue = "0x${instruction.wideLiteral.toString(16).lowercase()}"
+                        val sign = if (value.startsWith("-")) "-" else ""
+                        val hexValue = "${sign}0x${instruction.wideLiteral.toString(16).removePrefix(sign)}"
                         if (matcher(value) || matcher(hexValue)) {
-                            emit(TreeSearchResult(current, "$value ($hexValue)", TreeSearchResultType.LITERAL))
+                            emit(TreeSearchResult(current, "$value (dec) / $hexValue (hex)", TreeSearchResultType.LITERAL))
                             resultsFound++
                         }
                     }
@@ -132,6 +114,7 @@ fun searchTreeBFS(
     }
 }
 
+
 fun ClassDef.getStringPool(): List<String> {
     val stringPool = mutableSetOf<String>()
 
diff --git a/composeApp/src/commonMain/kotlin/me/lkl/dalvikus/ui/editor/suggestions/Popups.kt b/composeApp/src/commonMain/kotlin/me/lkl/dalvikus/ui/editor/suggestions/Popups.kt
@@ -130,7 +130,7 @@ fun HexPopup(
 
         when (cleanedHex.length) {
             8 -> {
-                if(cleanedHex.startsWith("7e") || cleanedHex.startsWith("7f")) {
+                if(!isNegative && (cleanedHex.startsWith("7e") || cleanedHex.startsWith("7f"))) {
                     "$cleanedHex (resource ID) = ${viewModel.tryResolveResIdText(unsignedValue)} (resolved) "
                 } else {
                     val floatValue = Float.fromBits(signedValue.toInt())
diff --git a/composeApp/src/commonMain/kotlin/me/lkl/dalvikus/ui/resources/ResourcesView.kt b/composeApp/src/commonMain/kotlin/me/lkl/dalvikus/ui/resources/ResourcesView.kt
@@ -8,9 +8,15 @@ import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
 import androidx.compose.foundation.lazy.grid.rememberLazyGridState
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.rememberScrollbarAdapter
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.input.TextFieldState
+import androidx.compose.foundation.text.input.rememberTextFieldState
+import androidx.compose.foundation.text.input.setTextAndPlaceCursorAtEnd
 import androidx.compose.foundation.text.selection.SelectionContainer
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Clear
 import androidx.compose.material.icons.filled.QuestionMark
+import androidx.compose.material.icons.filled.Search
 import androidx.compose.material.icons.outlined.*
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
@@ -19,28 +25,91 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
+import dalvikus.composeapp.generated.resources.Res
+import dalvikus.composeapp.generated.resources.all_elements
+import dalvikus.composeapp.generated.resources.resources_search_placeholder
+import io.github.composegears.valkyrie.MatchCase
+import io.github.composegears.valkyrie.RegularExpression
 import me.lkl.dalvikus.tree.archive.ApkNode
 import me.lkl.dalvikus.ui.uiTreeRoot
 import me.lkl.dalvikus.util.CollapseCard
+import me.lkl.dalvikus.util.SearchOptions
+import me.lkl.dalvikus.util.createSearchMatcher
+import me.lkl.dalvikus.util.to0xHex
+import org.jetbrains.compose.resources.stringResource
 
+@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun ResourcesView() {
     val scope = rememberCoroutineScope()
+    val searchBarState = rememberSearchBarState()
+    val searchFieldState = rememberTextFieldState()
+    var searchOptions by remember { mutableStateOf(SearchOptions()) }
+
+    val searchField =
+        @Composable {
+            SearchBarDefaults.InputField(
+                searchBarState = searchBarState,
+                textFieldState = searchFieldState,
+                onSearch = {},
+                placeholder = {
+                    Text(
+                        stringResource(Res.string.resources_search_placeholder),
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis
+                    )
+                },
+                leadingIcon = {
+                    Icon(Icons.Default.Search, contentDescription = null)
+                },
+                trailingIcon = {
+                    Row {
+                        if (searchFieldState.text.isNotEmpty()) {
+                            IconToggleButton(
+                                checked = searchOptions.useRegex,
+                                onCheckedChange = { searchOptions = searchOptions.copy(useRegex = it) }) {
+                                Icon(Icons.Filled.RegularExpression, contentDescription = "Regular expression")
+                            }
+                            IconToggleButton(
+                                checked = searchOptions.caseSensitive,
+                                onCheckedChange = { searchOptions = searchOptions.copy(caseSensitive = it) }) {
+                                Icon(Icons.Filled.MatchCase, contentDescription = "Case sensitive")
+                            }
+                            IconButton(onClick = {
+                                searchFieldState.setTextAndPlaceCursorAtEnd("")
+                            }) {
+                                Icon(Icons.Default.Clear, contentDescription = "Clear")
+                            }
+                        }
+                    }
+                }
+            )
+        }
 
     Scaffold(
-        containerColor = Color.Transparent
+        containerColor = Color.Transparent,
+        topBar = {
+            TopSearchBar(
+                state = searchBarState,
+                inputField = searchField,
+                shape = RoundedCornerShape(16.dp),
+                tonalElevation = 4.dp,
+                shadowElevation = 0.dp,
+                windowInsets = SearchBarDefaults.windowInsets,
+                modifier = Modifier.fillMaxWidth().padding(top = 8.dp),
+                scrollBehavior = null
+            )
+        }
     ) { innerPadding ->
         Column(
             modifier = Modifier.fillMaxSize().padding(innerPadding)
         ) {
-            ApkResourceCards()
+            ApkResourceCards(searchFieldState, searchOptions)
         }
     }
 }
 
 val resourceTypesIcons = mapOf(
-    "all" to Icons.Outlined.Android,
-
     "anim" to Icons.Outlined.PlayArrow,
     "animator" to Icons.Outlined.Movie,
     "attr" to Icons.Outlined.Tune,
@@ -63,22 +132,31 @@ val resourceTypesIcons = mapOf(
 )
 
 @Composable
-private fun ApkResourceCards() {
-    // TODO add search bar for resource ids in base 16, base 10, and resource name.
+private fun ApkResourceCards(searchFieldState: TextFieldState, searchOptions: SearchOptions) {
     val treeRootChildren by uiTreeRoot.childrenFlow.collectAsState()
     val apks = treeRootChildren.filterIsInstance<ApkNode>()
 
     val gridState = rememberLazyGridState()
     var selectedResType by remember { mutableStateOf("all") }
 
+    val searchMatcher by remember(searchFieldState.text, searchOptions) {
+        derivedStateOf { createSearchMatcher(searchFieldState.text.toString().replace(" ", ""), searchOptions) }
+    }
+
     Column(modifier = Modifier.fillMaxSize()) {
-        // Filter chips row
         FlowRow(
             modifier = Modifier
                 .fillMaxWidth()
                 .padding(8.dp),
             horizontalArrangement = Arrangement.spacedBy(8.dp)
         ) {
+            FilterChip(
+                // TODO remove elevation = null when https://youtrack.jetbrains.com/issue/CMP-2868 is fixed.
+                elevation = null,
+                selected = selectedResType == "all",
+                onClick = { selectedResType = "all" },
+                label = { Text(stringResource(Res.string.all_elements)) }
+            )
             resourceTypesIcons.forEach { (type, icon) ->
                 FilterChip(
                     // TODO remove elevation = null when https://youtrack.jetbrains.com/issue/CMP-2868 is fixed.
@@ -118,6 +196,8 @@ private fun ApkResourceCards() {
                             if (resSpecList == null) return@CollapseCard
                             val resourceSpecs = resSpecList.filter { resourceSpec ->
                                 resourceSpec != null && (selectedResType == "all" || resourceSpec.type.name == selectedResType)
+                                        && (searchMatcher == null || searchMatcher!!(resourceSpec.name)
+                                        || searchMatcher!!(resourceSpec.id.toLong().toString()) || searchMatcher!!(resourceSpec.id.toLong().to0xHex()))
                             }
 
                             val innerListState = rememberLazyListState()
@@ -134,9 +214,9 @@ private fun ApkResourceCards() {
                                     items(resourceSpecs.size) { index ->
                                         val resourceSpec = resourceSpecs[index]
                                         val resId = resourceSpec!!.id
-                                        val resIdPkg = String.format("%02X", resId.packageId)
-                                        val resIdTypeId = String.format("%02X", resId.type)
-                                        val resIdEntryNumber = String.format("%04X", resId.entry)
+                                        val resIdPkg = String.format("%02x", resId.packageId)
+                                        val resIdTypeId = String.format("%02x", resId.type)
+                                        val resIdEntryNumber = String.format("%04x", resId.entry)
 
                                         ListItem(
                                             headlineContent = {
diff --git a/composeApp/src/commonMain/kotlin/me/lkl/dalvikus/ui/tabs/WelcomeView.kt b/composeApp/src/commonMain/kotlin/me/lkl/dalvikus/ui/tabs/WelcomeView.kt
@@ -39,7 +39,7 @@ fun WelcomeView() {
     Box(
         modifier = Modifier
             .fillMaxSize()
-            .background(MaterialTheme.colorScheme.surfaceContainer)
+            .background(MaterialTheme.colorScheme.surfaceContainerLow)
             .padding(24.dp),
         contentAlignment = Alignment.Center
     ) {
@@ -79,7 +79,7 @@ fun WelcomeView() {
                         modifier = Modifier.padding(horizontal = 8.dp)
                     )
 
-                    Row(
+                    FlowRow(
                         horizontalArrangement = Arrangement.spacedBy(12.dp),
                         modifier = Modifier.padding(top = 8.dp)
                     ) {
diff --git a/composeApp/src/commonMain/kotlin/me/lkl/dalvikus/util/Hex.kt b/composeApp/src/commonMain/kotlin/me/lkl/dalvikus/util/Hex.kt
@@ -0,0 +1,16 @@
+package me.lkl.dalvikus.util
+
+import org.stringtemplate.v4.ST
+
+fun String.is0xHex(): Boolean {
+    return this.startsWith("0x") && this.drop(2).all { it.isDigit() || (it in 'a'..'f') || (it in 'A'..'F') }
+}
+
+fun Long.to0xHex(): String {
+    val sign = if (this < 0) "-" else ""
+    return "${sign}0x${this.toString(16).lowercase()}"
+}
+
+fun String.base10To0xOrNull(): String? {
+    return this.toLongOrNull()?.to0xHex()
+}
diff --git a/composeApp/src/commonMain/kotlin/me/lkl/dalvikus/util/SearchOptions.kt b/composeApp/src/commonMain/kotlin/me/lkl/dalvikus/util/SearchOptions.kt
@@ -0,0 +1,23 @@
+package me.lkl.dalvikus.util
+
+data class SearchOptions(
+    val caseSensitive: Boolean = false,
+    val useRegex: Boolean = false
+)
+
+fun createSearchMatcher(query: String, options: SearchOptions): ((String) -> Boolean)? {
+    return if (options.useRegex) {
+        try {
+            val regex = if (options.caseSensitive) {
+                Regex(query)
+            } else {
+                Regex(query, RegexOption.IGNORE_CASE)
+            }
+            { input -> regex.containsMatchIn(input) }
+        } catch (e: Exception) {
+            null // Invalid regex
+        }
+    } else {
+        { input -> input.contains(query, ignoreCase = !options.caseSensitive) }
+    }
+}
diff --git a/composeApp/src/jvmMain/kotlin/me/lkl/dalvikus/lexer/JavaLexerHighlight.jvm.kt b/composeApp/src/jvmMain/kotlin/me/lkl/dalvikus/lexer/JavaLexerHighlight.jvm.kt
@@ -11,6 +11,8 @@ import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.withStyle
 import me.lkl.dalvikus.ui.editor.highlight.CodeHighlightColors
+import me.lkl.dalvikus.util.base10To0xOrNull
+import me.lkl.dalvikus.util.is0xHex
 
 actual fun highlightJavaCode(code: String, colors: CodeHighlightColors): AnnotatedString {
     val lexer = Java20Lexer(CharStreams.fromString(code))
@@ -29,11 +31,11 @@ actual fun highlightJavaCode(code: String, colors: CodeHighlightColors): Annotat
             val end = token.stopIndex + 1
 
             if (token.type == Java20Lexer.IntegerLiteral) {
-                if (token.text.startsWith("0x") || token.text.startsWith("-0x")) {
+                if (token.text.is0xHex()) {
                     addStringAnnotation("hex", token.text, start, end)
                 } else {
-                    token.text.toLongOrNull()?.let {
-                        addStringAnnotation("hex", "0x${it.toString(16).uppercase()}", start, end)
+                    token.text.base10To0xOrNull()?.let {
+                        addStringAnnotation("hex", it, start, end)
                     }
                 }
             }
