Broken

2025-09-16 07:24:50 +02:00 · 2024-09-03 00:49:17 +02:00
15 changed files with 125 additions and 229 deletions
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -8,7 +8,7 @@ plugins {
 }

 group = "org.acejump"
-version = "chylex-25"
+version = "chylex-21"

 repositories {
  mavenCentral()
@@ -18,12 +18,12 @@ intellij {
  version.set("2024.2")
  updateSinceUntilBuild.set(false)
  
-  plugins.add("IdeaVIM:chylex-41")
-  plugins.add("com.intellij.classic.ui:242.20224.159")
+  // plugins.add("IdeaVIM:chylex-40")
+  // plugins.add("com.intellij.classic.ui:242.20224.159")
  
  pluginsRepositories {
-    custom("https://intellij.chylex.com")
-    marketplace()
+    // custom("https://intellij.chylex.com")
+    // marketplace()
  }
 }

--- a/src/main/kotlin/org/acejump/action/AceVimAction.kt
+++ b/src/main/kotlin/org/acejump/action/AceVimAction.kt
@@ -1,6 +1,5 @@
 package org.acejump.action

-import com.intellij.openapi.actionSystem.ActionUpdateThread
 import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.CommonDataKeys
 import com.intellij.openapi.application.ApplicationManager
@@ -16,7 +15,7 @@ import com.maddyhome.idea.vim.group.visual.vimSetSelection
 import com.maddyhome.idea.vim.helper.inVisualMode
 import com.maddyhome.idea.vim.helper.vimSelectionStart
 import com.maddyhome.idea.vim.newapi.vim
-import com.maddyhome.idea.vim.state.mode.Mode.OP_PENDING
+import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.state.mode.SelectionType
 import org.acejump.boundaries.StandardBoundaries.AFTER_CARET
 import org.acejump.boundaries.StandardBoundaries.BEFORE_CARET
@@ -52,8 +51,8 @@ sealed class AceVimAction : DumbAwareAction() {
          }
          else {
            val vim = editor.vim
-            if (vim.mode is OP_PENDING) {
-              val keyHandler = KeyHandler.getInstance()
+            val keyHandler = KeyHandler.getInstance()
+            if (keyHandler.isOperatorPending(vim.mode, keyHandler.keyHandlerState)) {
              val key = keyHandler.keyHandlerState.commandBuilder.keys.singleOrNull()?.keyChar
              
              keyHandler.fullReset(vim)
@@ -71,10 +70,10 @@ sealed class AceVimAction : DumbAwareAction() {
              if (action != null) {
                ApplicationManager.getApplication().invokeLater {
                  WriteAction.run<Nothing> {
-                    keyHandler.keyHandlerState.commandBuilder.addAction(action)
+                    keyHandler.keyHandlerState.commandBuilder.pushCommandPart(action)
                    
                    val cmd = keyHandler.keyHandlerState.commandBuilder.buildCommand()
-                    val operatorArguments = OperatorArguments(vim.mode is OP_PENDING, cmd.rawCount, injector.vimState.mode)
+                    val operatorArguments = OperatorArguments(vim.mode is Mode.OP_PENDING, cmd.rawCount, injector.vimState.mode)
                    
                    injector.vimState.executingCommand = cmd
                    injector.actionExecutor.executeVimAction(vim, action, context, operatorArguments)
@@ -168,10 +167,6 @@ sealed class AceVimAction : DumbAwareAction() {
      action.presentation.isEnabled = action.getData(CommonDataKeys.EDITOR) != null
    }
    
-    override fun getActionUpdateThread(): ActionUpdateThread {
-      return ActionUpdateThread.BGT
-    }
-    
    override fun actionPerformed(e: AnActionEvent) {
      val editor = e.getData(CommonDataKeys.EDITOR) ?: return
      val session = SessionManager.start(editor, AceVimMode.JumpAllEditors.getJumpEditors(editor))
--- a/src/main/kotlin/org/acejump/boundaries/EditorOffsetCache.kt
+++ b/src/main/kotlin/org/acejump/boundaries/EditorOffsetCache.kt
@@ -18,11 +18,6 @@ sealed class EditorOffsetCache {
   */
  abstract fun visibleArea(editor: Editor): Pair<Point, Point>
  
-  /**
-   * Returns whether the offset is in the visible area rectangle.
-   */
-  abstract fun isVisible(editor: Editor, offset: Int): Boolean
-  
  /**
   * Returns the editor offset at the provided pixel coordinate.
   */
@@ -41,7 +36,6 @@ sealed class EditorOffsetCache {
  
  private class Cache : EditorOffsetCache() {
    private var visibleArea: Pair<Point, Point>? = null
-    private val lineToVisibleOffsetRange = Int2ObjectOpenHashMap<IntRange>()
    private val pointToOffset = Object2IntOpenHashMap<Point>().apply { defaultReturnValue(-1) }
    private val offsetToPoint = Int2ObjectOpenHashMap<Point>()
    
@@ -49,24 +43,6 @@ sealed class EditorOffsetCache {
      return visibleArea ?: Uncached.visibleArea(editor).also { visibleArea = it }
    }
    
-    override fun isVisible(editor: Editor, offset: Int): Boolean {
-      val visualLine = editor.offsetToVisualLine(offset, false)
-      
-      var visibleRange = lineToVisibleOffsetRange.get(visualLine)
-      if (visibleRange == null) {
-        val (topLeft, bottomRight) = visibleArea(editor)
-        val lineY = editor.visualLineToY(visualLine)
-        
-        val firstVisibleOffset = xyToOffset(editor, Point(topLeft.x, lineY))
-        val lastVisibleOffset = xyToOffset(editor, Point(bottomRight.x, lineY))
-        
-        visibleRange = firstVisibleOffset..lastVisibleOffset
-        lineToVisibleOffsetRange.put(visualLine, visibleRange)
-      }
-      
-      return offset in visibleRange
-    }
-    
    override fun xyToOffset(editor: Editor, pos: Point): Int {
      val offset = pointToOffset.getInt(pos)
      
@@ -75,6 +51,7 @@ sealed class EditorOffsetCache {
      }
      
      return Uncached.xyToOffset(editor, pos).also {
+        @Suppress("ReplacePutWithAssignment")
        pointToOffset.put(pos, it)
      }
    }
@@ -87,6 +64,7 @@ sealed class EditorOffsetCache {
      }
      
      return Uncached.offsetToXY(editor, offset).also {
+        @Suppress("ReplacePutWithAssignment")
        offsetToPoint.put(offset, it)
      }
    }
@@ -102,15 +80,6 @@ sealed class EditorOffsetCache {
      )
    }
    
-    override fun isVisible(editor: Editor, offset: Int): Boolean {
-      val (topLeft, bottomRight) = visibleArea(editor)
-      val pos = offsetToXY(editor, offset)
-      val x = pos.x
-      val y = pos.y
-      
-      return x >= topLeft.x && y >= topLeft.y && x <= bottomRight.x && y <= bottomRight.y
-    }
-    
    override fun xyToOffset(editor: Editor, pos: Point): Int {
      return editor.logicalPositionToOffset(editor.xyToLogicalPosition(pos))
    }
--- a/src/main/kotlin/org/acejump/boundaries/StandardBoundaries.kt
+++ b/src/main/kotlin/org/acejump/boundaries/StandardBoundaries.kt
@@ -13,7 +13,23 @@ enum class StandardBoundaries : Boundaries {
    }
    
    override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache): Boolean {
-      return cache.isVisible(editor, offset)
+      
+      // If we are not using a cache, calling getOffsetRange will cause additional 1-2 pixel coordinate -> offset lookups, which is a lot
+      // more expensive than one lookup compared against the visible area.
+      
+      // However, if we are using a cache, it's likely that the topmost and bottommost positions are already cached whereas the provided
+      // offset isn't, so we save a lookup for every offset outside the range.
+      
+      if (cache !== EditorOffsetCache.Uncached && offset !in getOffsetRange(editor, cache)) {
+        return false
+      }
+      
+      val (topLeft, bottomRight) = cache.visibleArea(editor)
+      val pos = cache.offsetToXY(editor, offset)
+      val x = pos.x
+      val y = pos.y
+      
+      return x >= topLeft.x && y >= topLeft.y && x <= bottomRight.x && y <= bottomRight.y
    }
  },
  
--- a/src/main/kotlin/org/acejump/config/AceConfigurable.kt
+++ b/src/main/kotlin/org/acejump/config/AceConfigurable.kt
@@ -13,6 +13,7 @@ class AceConfigurable : Configurable {
  
  override fun isModified() =
    panel.allowedChars != settings.allowedChars ||
+      panel.prefixChars != settings.prefixChars ||
      panel.keyboardLayout != settings.layout ||
      panel.minQueryLengthInt != settings.minQueryLength ||
      panel.editorFadeOpacityPercent != settings.editorFadeOpacity ||
@@ -23,6 +24,7 @@ class AceConfigurable : Configurable {
  
  override fun apply() {
    settings.allowedChars = panel.allowedChars
+    settings.prefixChars = panel.prefixChars
    settings.layout = panel.keyboardLayout
    settings.minQueryLength = panel.minQueryLengthInt ?: settings.minQueryLength
    settings.editorFadeOpacity = panel.editorFadeOpacityPercent
--- a/src/main/kotlin/org/acejump/config/AceSettings.kt
+++ b/src/main/kotlin/org/acejump/config/AceSettings.kt
@@ -8,6 +8,7 @@ import java.awt.Color
 data class AceSettings(
  var layout: KeyLayout = QWERTY,
  var allowedChars: String = layout.allChars,
+  var prefixChars: String = ";",
  var minQueryLength: Int = 1,
  var editorFadeOpacity: Int = 70,
  
--- a/src/main/kotlin/org/acejump/config/AceSettingsPanel.kt
+++ b/src/main/kotlin/org/acejump/config/AceSettingsPanel.kt
@@ -5,16 +5,16 @@ import com.intellij.ui.ColorPanel
 import com.intellij.ui.components.JBSlider
 import com.intellij.ui.components.JBTextArea
 import com.intellij.ui.components.JBTextField
-import com.intellij.ui.dsl.builder.COLUMNS_LARGE
-import com.intellij.ui.dsl.builder.COLUMNS_SHORT
-import com.intellij.ui.dsl.builder.columns
-import com.intellij.ui.dsl.builder.panel
+import com.intellij.ui.layout.Cell
+import com.intellij.ui.layout.GrowPolicy.MEDIUM_TEXT
+import com.intellij.ui.layout.GrowPolicy.SHORT_TEXT
+import com.intellij.ui.layout.panel
 import org.acejump.input.KeyLayout
 import java.awt.Color
-import java.awt.Dimension
 import java.awt.Font
 import java.util.Hashtable
 import javax.swing.JCheckBox
+import javax.swing.JComponent
 import javax.swing.JLabel
 import javax.swing.JPanel
 import javax.swing.JSlider
@@ -27,6 +27,7 @@ import kotlin.reflect.KProperty
@Suppress("UsePropertyAccessSyntax")
 internal class AceSettingsPanel {
  private val tagAllowedCharsField = JBTextField()
+  private val tagPrefixCharsField = JBTextField()
  private val keyboardLayoutCombo = ComboBox<KeyLayout>()
  private val keyboardLayoutArea = JBTextArea().apply { isEditable = false }
  private val minQueryLengthField = JBTextField()
@@ -37,7 +38,6 @@ internal class AceSettingsPanel {
    paintTicks = true
    minorTickSpacing = 1
    majorTickSpacing = 1
-    minimumSize = Dimension(275, minimumSize.height)
  }
  private val jumpModeColorWheel = ColorPanel()
  private val tagForeground1ColorWheel = ColorPanel()
@@ -46,40 +46,52 @@ internal class AceSettingsPanel {
  
  init {
    tagAllowedCharsField.apply { font = Font("monospaced", font.style, font.size) }
+    tagPrefixCharsField.apply { font = Font("monospaced", font.style, font.size) }
    keyboardLayoutArea.apply { font = Font("monospaced", font.style, font.size) }
    keyboardLayoutCombo.setupEnumItems { keyChars = it.rows.joinToString("\n") }
  }
  
  internal val rootPanel: JPanel = panel {
-    group("Characters and Layout") {
-      row("Allowed characters in tags:") { cell(tagAllowedCharsField).columns(COLUMNS_LARGE) }
-      row("Keyboard layout:") { cell(keyboardLayoutCombo).columns(COLUMNS_SHORT) }
-      row("Keyboard design:") { cell(keyboardLayoutArea).columns(COLUMNS_SHORT) }
+    fun Cell.short(component: JComponent) = component(growPolicy = SHORT_TEXT)
+    fun Cell.medium(component: JComponent) = component(growPolicy = MEDIUM_TEXT)
+    
+    titledRow("Characters and Layout") {
+      row("Allowed characters in tags:") { medium(tagAllowedCharsField) }
+      row("Allowed prefix characters in tags:") { medium(tagPrefixCharsField) }
+      row("Keyboard layout:") { short(keyboardLayoutCombo) }
+      row("Keyboard design:") { short(keyboardLayoutArea) }
    }
    
-    group("Behavior") {
-      row("Minimum typed characters (1-10):") { cell(minQueryLengthField).columns(COLUMNS_SHORT) }
+    titledRow("Behavior") {
+      row("Minimum typed characters (1-10):") { short(minQueryLengthField) }
    }
    
-    group("Colors") {
+    titledRow("Colors") {
      row("Caret background:") {
-        cell(jumpModeColorWheel)
+        cell {
+          component(jumpModeColorWheel)
+        }
      }
      row("Tag foreground:") {
-        cell(tagForeground1ColorWheel)
-        cell(tagForeground2ColorWheel)
+        cell {
+          component(tagForeground1ColorWheel)
+          component(tagForeground2ColorWheel)
+        }
      }
      row("Search highlight:") {
-        cell(searchHighlightColorWheel)
+        cell {
+          component(searchHighlightColorWheel)
+        }
      }
      row("Editor fade opacity (%):") {
-        cell(editorFadeOpacitySlider)
+        medium(editorFadeOpacitySlider)
      }
    }
  }
  
  // Property-to-property delegation: https://stackoverflow.com/q/45074596/1772342
  internal var allowedChars by tagAllowedCharsField
+  internal var prefixChars by tagPrefixCharsField
  internal var keyboardLayout by keyboardLayoutCombo
  internal var keyChars by keyboardLayoutArea
  internal var minQueryLength by minQueryLengthField
@@ -99,6 +111,7 @@ internal class AceSettingsPanel {
  
  fun reset(settings: AceSettings) {
    allowedChars = settings.allowedChars
+    prefixChars = settings.prefixChars
    keyboardLayout = settings.layout
    minQueryLength = settings.minQueryLength.toString()
    editorFadeOpacityPercent = settings.editorFadeOpacity
@@ -110,7 +123,7 @@ internal class AceSettingsPanel {
  
  // Removal pending support for https://youtrack.jetbrains.com/issue/KT-8575
  
-  private operator fun JTextComponent.getValue(a: AceSettingsPanel, p: KProperty<*>) = text.lowercase()
+  private operator fun JTextComponent.getValue(a: AceSettingsPanel, p: KProperty<*>) = text.toLowerCase()
  private operator fun JTextComponent.setValue(a: AceSettingsPanel, p: KProperty<*>, s: String) = setText(s)
  
  private operator fun ColorPanel.getValue(a: AceSettingsPanel, p: KProperty<*>) = selectedColor
--- a/src/main/kotlin/org/acejump/input/EditorKeyListener.kt
+++ b/src/main/kotlin/org/acejump/input/EditorKeyListener.kt
@@ -10,6 +10,7 @@ import com.intellij.openapi.editor.actionSystem.TypedActionHandler
 * sessions' own handlers.
 */
 internal object EditorKeyListener : TypedActionHandler {
+  private val action = TypedAction.getInstance()
  private val attached = mutableMapOf<Editor, TypedActionHandler>()
  private var originalHandler: TypedActionHandler? = null
  
@@ -19,9 +20,8 @@ internal object EditorKeyListener : TypedActionHandler {
  
  fun attach(editor: Editor, callback: TypedActionHandler) {
    if (attached.isEmpty()) {
-      val typedAction = TypedAction.getInstance()
-      originalHandler = typedAction.rawHandler
-      typedAction.setupRawHandler(this)
+      originalHandler = action.rawHandler
+      action.setupRawHandler(this)
    }
    
    attached[editor] = callback
@@ -31,7 +31,7 @@ internal object EditorKeyListener : TypedActionHandler {
    attached.remove(editor)
    
    if (attached.isEmpty()) {
-      originalHandler?.let(TypedAction.getInstance()::setupRawHandler)
+      originalHandler?.let(action::setupRawHandler)
      originalHandler = null
    }
  }
--- a/src/main/kotlin/org/acejump/input/KeyLayout.kt
+++ b/src/main/kotlin/org/acejump/input/KeyLayout.kt
@@ -5,18 +5,13 @@ package org.acejump.input
 * ergonomically difficult they are to press.
 */
@Suppress("unused", "SpellCheckingInspection")
-enum class KeyLayout(
-  internal val rows: Array<String>,
-  priority: String,
-  private val characterSides: Pair<Set<Char>, Set<Char>> = Pair(emptySet(), emptySet()),
-  internal val characterRemapping: Map<Char, Char> = emptyMap(),
-) {
+enum class KeyLayout(internal val rows: Array<String>, priority: String, internal val characterRemapping: Map<Char, Char> = emptyMap()) {
  COLEMK(arrayOf("1234567890", "qwfpgjluy", "arstdhneio", "zxcvbkm"), priority = "tndhseriaovkcmbxzgjplfuwyq5849673210"),
  WORKMN(arrayOf("1234567890", "qdrwbjfup", "ashtgyneoi", "zxmcvkl"), priority = "tnhegysoaiclvkmxzwfrubjdpq5849673210"),
  DVORAK(arrayOf("1234567890", "pyfgcrl", "aoeuidhtns", "qjkxbmwvz"), priority = "uhetidonasxkbjmqwvzgfycprl5849673210"),
-  QWERTY(arrayOf("1234567890", "qwertyuiop", "asdfghjkl", "zxcvbnm"), priority = "fjghdkslavncmbxzrutyeiwoqp5849673210", characterSides = sides(listOf("123456", "qwert", "asdfg", "zxcvb"), listOf("7890", "yuiop", "hjkl", "nm"))),
-  QWERTZ(arrayOf("1234567890", "qwertzuiop", "asdfghjkl", "yxcvbnm"), priority = "fjghdkslavncmbxyrutzeiwoqp5849673210", characterSides = sides(listOf("123456", "qwert", "asdfg", "yxcvb"), listOf("7890", "zuiop", "hjkl", "nm"))),
-  QWERTZ_CZ(arrayOf("1234567890", "qwertzuiop", "asdfghjkl", "yxcvbnm"), priority = "fjghdkslavncmbxyrutzeiwoqp5849673210", characterSides = sides(listOf("123456", "qwert", "asdfg", "yxcvb"), listOf("7890", "zuiop", "hjkl", "nm")), characterRemapping = mapOf(
+  QWERTY(arrayOf("1234567890", "qwertyuiop", "asdfghjkl", "zxcvbnm"), priority = "fjghdkslavncmbxzrutyeiwoqp5849673210"),
+  QWERTZ(arrayOf("1234567890", "qwertzuiop", "asdfghjkl", "yxcvbnm"), priority = "fjghdkslavncmbxyrutzeiwoqp5849673210"),
+  QWERTZ_CZ(arrayOf("1234567890", "qwertzuiop", "asdfghjkl", "yxcvbnm"), priority = "fjghdkslavncmbxyrutzeiwoqp5849673210", characterRemapping =  mapOf(
    '+' to '1',
    'ě' to '2',
    'š' to '3',
@@ -33,20 +28,9 @@ enum class KeyLayout(
  NORMAN(arrayOf("1234567890", "qwdfkjurl", "asetgynioh", "zxcvbpm"), priority = "tneigysoahbvpcmxzjkufrdlwq5849673210");
  
  internal val allChars = rows.joinToString("").toCharArray().apply(CharArray::sort).joinToString("")
-  private val allPriorities = priority.mapIndexed { index, char -> char to index }.toMap()
+  internal val allPriorities = priority.mapIndexed { index, char -> char to index }.toMap()
  
-  fun priority(char: Char): Int {
-    return allPriorities[char] ?: allChars.length
-  }
-  
-  fun areOnSameSide(c1: Char, c2: Char): Boolean {
-    return (c1 in characterSides.first && c2 in characterSides.first) || (c1 in characterSides.second && c2 in characterSides.second)
+  internal inline fun priority(crossinline tagToChar: (String) -> Char): (String) -> Int {
+    return { allPriorities.getOrDefault(tagToChar(it), Int.MAX_VALUE) }
  }
 }
-
-private fun sides(left: List<String>, right: List<String>): Pair<Set<Char>, Set<Char>> {
-  return Pair(
-    left.flatMapTo(mutableSetOf()) { it.toCharArray().toSet() },
-    right.flatMapTo(mutableSetOf()) { it.toCharArray().toSet() }
-  )
-}
--- a/src/main/kotlin/org/acejump/input/KeyLayoutCache.kt
+++ b/src/main/kotlin/org/acejump/input/KeyLayoutCache.kt
@@ -1,22 +1,23 @@
 package org.acejump.input

 import org.acejump.config.AceSettings
-import kotlin.math.pow
-import kotlin.math.roundToInt

 /**
 * Stores data specific to the selected keyboard layout. We want to assign tags with easily reachable keys first, and ideally have tags
 * with repeated keys (ex. FF, JJ) or adjacent keys (ex. GH, UJ).
 */
 internal object KeyLayoutCache {
-  lateinit var allowedTagsSorted: List<String>
+  /**
+   * Returns all possible two key tags, pre-sorted according to [tagOrder].
+   */
+  lateinit var allPossibleTagsLowercase: List<String>
    private set
  
  /**
   * Called before any lazily initialized properties are used, to ensure that they are initialized even if the settings are missing.
   */
  fun ensureInitialized(settings: AceSettings) {
-    if (!::allowedTagsSorted.isInitialized) {
+    if (!::allPossibleTagsLowercase.isInitialized) {
      reset(settings)
    }
  }
@@ -25,38 +26,22 @@ internal object KeyLayoutCache {
   * Re-initializes cached data according to updated settings.
   */
  fun reset(settings: AceSettings) {
-    val allowedChars = processCharList(settings.allowedChars).ifEmpty { processCharList(settings.layout.allChars) }
-    val allowedTags = mutableSetOf<String>()
+    @Suppress("ConvertLambdaToReference")
+    val allSuffixChars = processCharList(settings.allowedChars).ifEmpty { processCharList(settings.layout.allChars).toList() }
+    val allPrefixChars = processCharList(settings.prefixChars).filterNot(allSuffixChars::contains).plus("")
    
-    for (c1 in allowedChars) {
-      allowedTags.add("$c1")
-      
-      for (c2 in allowedChars) {
-        if (c1 != c2) {
-          allowedTags.add("$c1$c2")
-        }
-      }
-    }
+    val tagOrder = compareBy(
+      String::length,
+      { if (it.length == 1) Int.MIN_VALUE else allPrefixChars.indexOf(it.first().toString()) },
+      settings.layout.priority(String::last)
+    )
    
-    allowedTagsSorted = allowedTags.sortedBy { rankPriority(settings.layout, it) }
+    allPossibleTagsLowercase = allSuffixChars
+      .flatMap { suffix -> allPrefixChars.map { prefix -> "$prefix$suffix" } }
+      .sortedWith(tagOrder)
  }
  
-  private fun processCharList(charList: String): List<Char> {
-    return charList.toCharArray().map(Char::lowercaseChar).distinct()
-  }
-  
-  private fun rankPriority(layout: KeyLayout, tag: String): Int {
-    val c1 = tag.first()
-    val p1 = (1.0 + layout.priority(c1)).pow(3)
-    
-    if (tag.length == 1) {
-      return p1.roundToInt()
-    }
-    
-    val c2 = tag.last()
-    val p2 = (1.0 + layout.priority(c2)).pow(3)
-    
-    val multiplier = if (layout.areOnSameSide(c1, c2)) 2 else 1
-    return (((p1 * 50) + p2 + 1000) * multiplier).roundToInt()
+  private fun processCharList(charList: String): Set<String> {
+    return charList.toCharArray().map(Char::lowercase).toSet()
  }
 }
--- a/src/main/kotlin/org/acejump/search/SearchProcessor.kt
+++ b/src/main/kotlin/org/acejump/search/SearchProcessor.kt
@@ -3,7 +3,6 @@ package org.acejump.search
 import com.intellij.openapi.editor.Editor
 import it.unimi.dsi.fastutil.ints.IntArrayList
 import org.acejump.boundaries.Boundaries
-import org.acejump.boundaries.EditorOffsetCache
 import org.acejump.clone
 import org.acejump.config.AceConfig
 import org.acejump.immutableText
@@ -18,10 +17,9 @@ class SearchProcessor private constructor(query: SearchQuery, val boundaries: Bo
    
    if (regex != null) {
      for (editor in editors) {
-        val cache = EditorOffsetCache.new()
        val offsets = IntArrayList()
        
-        val offsetRange = boundaries.getOffsetRange(editor, cache)
+        val offsetRange = boundaries.getOffsetRange(editor)
        var result = regex.find(editor.immutableText, offsetRange.first)
        
        while (result != null) {
@@ -31,7 +29,7 @@ class SearchProcessor private constructor(query: SearchQuery, val boundaries: Bo
          if (highlightEnd > offsetRange.last) {
            break
          }
-          else if (boundaries.isOffsetInside(editor, index, cache) && !editor.foldingModel.isOffsetCollapsed(index)) {
+          else if (boundaries.isOffsetInside(editor, index) && !editor.foldingModel.isOffsetCollapsed(index)) {
            offsets.add(index)
          }
          
--- a/src/main/kotlin/org/acejump/search/SearchQuery.kt
+++ b/src/main/kotlin/org/acejump/search/SearchQuery.kt
@@ -28,13 +28,13 @@ internal sealed class SearchQuery {
   * If the first character of the query is lowercase, then the entire query will be case-insensitive,
   * and only beginnings of words and camel humps will be matched.
   */
-  class Literal(override val rawText: String) : SearchQuery() {
+  class Literal(override val rawText: String, val excludeMiddlesOfWords: Boolean) : SearchQuery() {
    init {
      require(rawText.isNotEmpty())
    }
    
    override fun refine(char: Char): SearchQuery {
-      return Literal(rawText + char)
+      return Literal(rawText + char, excludeMiddlesOfWords)
    }
    
    override fun getHighlightLength(text: CharSequence, offset: Int): Int {
@@ -44,14 +44,19 @@ internal sealed class SearchQuery {
    override fun toRegex(): Regex {
      val firstChar = rawText.first()
      val pattern = if (firstChar.isLowerCase()) {
-        val fullPattern = Regex.escape(rawText)
-        "(?i)$fullPattern"
+        if (excludeMiddlesOfWords) {
+          val firstCharUppercasePattern = Regex.escape(firstChar.uppercaseChar().toString())
+          val firstCharPattern = Regex.escape(firstChar.toString())
+          val remainingPattern = if (rawText.length > 1) Regex.escape(rawText.drop(1)) else ""
+          "(?:$firstCharUppercasePattern|(?<![a-zA-Z])$firstCharPattern)$remainingPattern"
+        }
+        else {
+          val fullPattern = Regex.escape(rawText)
+          "(?i)$fullPattern"
+        }
      }
      else {
-        val firstCharUppercasePattern = Regex.escape(firstChar.toString())
-        val firstCharLowercasePattern = Regex.escape(firstChar.lowercase())
-        val remainingPattern = if (rawText.length > 1) Regex.escape(rawText.drop(1)) else ""
-        "(?:$firstCharUppercasePattern|(?<![a-zA-Z])$firstCharLowercasePattern)$remainingPattern"
+        Regex.escape(rawText)
      }
      
      return Regex(pattern, setOf(RegexOption.MULTILINE))
@@ -65,7 +70,7 @@ internal sealed class SearchQuery {
    override val rawText = ""
    
    override fun refine(char: Char): SearchQuery {
-      return Literal(char.toString())
+      return Literal(char.toString(), excludeMiddlesOfWords = false)
    }
    
    override fun getHighlightLength(text: CharSequence, offset: Int): Int {
--- a/src/main/kotlin/org/acejump/search/Tagger.kt
+++ b/src/main/kotlin/org/acejump/search/Tagger.kt
@@ -3,7 +3,6 @@ package org.acejump.search
 import com.google.common.collect.ArrayListMultimap
 import com.intellij.openapi.editor.Editor
 import it.unimi.dsi.fastutil.ints.IntList
-import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap
 import org.acejump.boundaries.EditorOffsetCache
 import org.acejump.boundaries.StandardBoundaries.VISIBLE_ON_SCREEN
 import org.acejump.input.KeyLayoutCache
@@ -41,7 +40,7 @@ class Tagger(private val editors: List<Editor>, results: Map<Editor, IntList>) {
      .flatMap { (editor, sites) -> sites.map { site -> Tag(editor, site) } }
      .sortedWith(siteOrder(editors, caches))
    
-    tagMap = generateTags(tagSites.size).zip(tagSites).toMap()
+    tagMap = KeyLayoutCache.allPossibleTagsLowercase.zip(tagSites).toMap()
  }
  
  internal fun type(char: Char): TaggingResult {
@@ -62,68 +61,6 @@ class Tagger(private val editors: List<Editor>, results: Map<Editor, IntList>) {
  }
  
  private companion object {
-    private fun generateTags(tagCount: Int): List<String> {
-      val allowedTagsSorted = KeyLayoutCache.allowedTagsSorted
-      val tags = mutableListOf<String>()
-      
-      val containedSingleCharTags = mutableSetOf<Char>()
-      val blockedSingleCharTags = mutableSetOf<Char>()
-      val doubleCharTagCountsByFirstChar = Object2IntOpenHashMap<Char>()
-      
-      for (tag in allowedTagsSorted) {
-        val firstChar = tag.first()
-        
-        if (tag.length == 1) {
-          if (firstChar in blockedSingleCharTags) {
-            continue
-          }
-          
-          containedSingleCharTags.add(firstChar)
-        }
-        else {
-          if (containedSingleCharTags.remove(firstChar)) {
-            tags.remove(firstChar.toString())
-          }
-          
-          blockedSingleCharTags.add(firstChar)
-          doubleCharTagCountsByFirstChar.addTo(firstChar, 1)
-        }
-        
-        tags.add(tag)
-        
-        if (tags.size >= tagCount) {
-          break
-        }
-      }
-      
-      // In rare cases, the final tag list may contain a double character tag that is the only tag starting with its first character,
-      // so we replace it with the single character tag.
-      for (entry in doubleCharTagCountsByFirstChar.object2IntEntrySet()) {
-        if (entry.intValue != 1) {
-          continue
-        }
-        
-        tags.removeAt(tags.indexOfFirst { it.first() == entry.key })
-        
-        val tag = entry.key.toString()
-        var previousTagIndex = -1
-        
-        // The implementation of searching where to place the single character tag is theoretically slow,
-        // but getting here is so rare it doesn't matter.
-        for (i in allowedTagsSorted.indexOf(tag) - 1 downTo 0) {
-          previousTagIndex = tags.indexOf(allowedTagsSorted[i])
-          
-          if (previousTagIndex != -1) {
-            break
-          }
-        }
-        
-        tags.add(previousTagIndex + 1, tag)
-      }
-      
-      return tags
-    }
-    
    private fun sortResults(results: Map<Editor, IntList>, caches: Map<Editor, EditorOffsetCache>) {
      for ((editor, offsets) in results) {
        val cache = caches.getValue(editor)
@@ -162,11 +99,12 @@ class Tagger(private val editors: List<Editor>, results: Map<Editor, IntList>) {
        return@Comparator if (aIsVisible) -1 else 1
      }
      
-      val firstEditor = editorPriority[0]
-      val caretPosition = caches.getValue(firstEditor).offsetToXY(firstEditor, firstEditor.caretModel.offset)
+      val aPosition = aCaches.offsetToXY(aEditor, a.offset)
+      val bPosition = bCaches.offsetToXY(bEditor, b.offset)
      
-      val aDistance = aCaches.offsetToXY(aEditor, a.offset).distanceSq(caretPosition)
-      val bDistance = bCaches.offsetToXY(bEditor, b.offset).distanceSq(caretPosition)
+      val caretPosition = editorPriority[0].offsetToXY(editorPriority[0].caretModel.offset)
+      val aDistance = aPosition.distanceSq(caretPosition)
+      val bDistance = bPosition.distanceSq(caretPosition)
      
      return@Comparator aDistance.compareTo(bDistance)
    }
--- a/src/main/kotlin/org/acejump/session/SessionState.kt
+++ b/src/main/kotlin/org/acejump/session/SessionState.kt
@@ -2,7 +2,6 @@ package org.acejump.session

 import com.intellij.openapi.editor.Editor
 import org.acejump.boundaries.Boundaries
-import org.acejump.boundaries.StandardBoundaries
 import org.acejump.config.AceConfig
 import org.acejump.search.SearchProcessor
 import org.acejump.search.SearchQuery
@@ -18,7 +17,7 @@ sealed interface SessionState {
    private val defaultBoundary: Boundaries,
  ) : SessionState {
    override fun type(char: Char): TypeResult {
-      val searchProcessor = SearchProcessor(jumpEditors, SearchQuery.Literal(char.toString()), defaultBoundary)
+      val searchProcessor = SearchProcessor(jumpEditors, SearchQuery.Literal(char.toString(), excludeMiddlesOfWords = true), defaultBoundary)
      
      return if (searchProcessor.isQueryFinished) {
        TypeResult.ChangeState(SelectTag(actions, jumpEditors, searchProcessor))
@@ -64,15 +63,9 @@ sealed interface SessionState {
    override fun type(char: Char): TypeResult {
      if (char == ' ') {
        val query = searchProcessor.query
-        if (query is SearchQuery.Literal) {
-          val newBoundaries = when (searchProcessor.boundaries) {
-            StandardBoundaries.VISIBLE_ON_SCREEN -> StandardBoundaries.AFTER_CARET
-            StandardBoundaries.AFTER_CARET       -> StandardBoundaries.BEFORE_CARET
-            StandardBoundaries.BEFORE_CARET      -> StandardBoundaries.VISIBLE_ON_SCREEN
-            else                                 -> searchProcessor.boundaries
-          }
-          
-          val newSearchProcessor = SearchProcessor(jumpEditors, query, newBoundaries)
+        if (query is SearchQuery.Literal && query.excludeMiddlesOfWords) {
+          val newQuery = SearchQuery.Literal(query.rawText, excludeMiddlesOfWords = false)
+          val newSearchProcessor = SearchProcessor(jumpEditors, newQuery, searchProcessor.boundaries)
          return TypeResult.ChangeState(SelectTag(actions, jumpEditors, newSearchProcessor))
        }
      }
--- a/src/main/kotlin/org/acejump/view/TagMarker.kt
+++ b/src/main/kotlin/org/acejump/view/TagMarker.kt
@@ -12,13 +12,10 @@ import java.awt.Rectangle
 * Describes a 1 or 2 character shortcut that points to a specific character in the editor.
 */
 internal class TagMarker(
-  private val firstChar: String,
-  private val secondChar: String,
+  private val tag: CharArray,
  val offset: Int
 ) {
-  private constructor(tag: String, offset: Int) : this(tag.first().toString(), tag.drop(1), offset)
-  
-  private val length = firstChar.length + secondChar.length
+  private val length = tag.size
  
  companion object {
    /**
@@ -31,7 +28,7 @@ internal class TagMarker(
     * character ([typedTag]) matches the first [tag] character, only the second [tag] character is displayed.
     */
    fun create(tag: String, offset: Int, typedTag: String): TagMarker {
-      return TagMarker(tag.drop(typedTag.length), offset)
+      return TagMarker(tag.drop(typedTag.length).toCharArray(), offset)
    }
  }
  
@@ -68,11 +65,11 @@ internal class TagMarker(
    
    g.font = font.tagFont
    g.color = font.foregroundColor1
-    g.drawString(firstChar, x, y)
+    g.drawChars(tag, 0, 1, x, y)
    
-    if (secondChar.isNotEmpty()) {
+    if (tag.size > 1) {
      g.color = font.foregroundColor2
-      g.drawString(secondChar, x + font.tagCharWidth, y)
+      g.drawChars(tag, 1, length - 1, x + font.tagCharWidth, y)
    }
  }