Release version 0.6.2

build.gradle.kts

@@ -8,7 +8,7 @@ plugins {
 }
 
 group = "com.chylex.intellij.keyboardmaster"
-version = "0.5.6"
+version = "0.6.2"
 
 repositories {
 	mavenCentral()
@@ -16,7 +16,7 @@ repositories {
 
 intellij {
 	type.set("IU")
-	version.set("2024.1.1")
+	version.set("2024.2")
 	updateSinceUntilBuild.set(false)
 	
 	plugins.add("com.intellij.java")
@@ -35,7 +35,7 @@ dependencies {
 }
 
 tasks.patchPluginXml {
-	sinceBuild.set("241")
+	sinceBuild.set("242")
 }
 
 tasks.test {

src/main/kotlin/com/chylex/intellij/keyboardmaster/feature/action/gotoError/GotoNextErrorInOtherModeAction.kt

@@ -2,9 +2,10 @@ package com.chylex.intellij.keyboardmaster.feature.action.gotoError
 
 import com.intellij.codeInsight.CodeInsightActionHandler
 import com.intellij.codeInsight.daemon.impl.actions.GotoNextErrorAction
+import com.intellij.openapi.actionSystem.DataContext
 
 class GotoNextErrorInOtherModeAction : GotoNextErrorAction() {
-	override fun getHandler(): CodeInsightActionHandler {
+	override fun getHandler(dataContext: DataContext): CodeInsightActionHandler {
 		return GotoErrorInOtherModeHandler(forward = true)
 	}
 }

src/main/kotlin/com/chylex/intellij/keyboardmaster/feature/action/gotoError/GotoPreviousErrorInOtherModeAction.kt

@@ -2,9 +2,10 @@ package com.chylex.intellij.keyboardmaster.feature.action.gotoError
 
 import com.intellij.codeInsight.CodeInsightActionHandler
 import com.intellij.codeInsight.daemon.impl.actions.GotoPreviousErrorAction
+import com.intellij.openapi.actionSystem.DataContext
 
 class GotoPreviousErrorInOtherModeAction : GotoPreviousErrorAction() {
-	override fun getHandler(): CodeInsightActionHandler {
+	override fun getHandler(dataContext: DataContext): CodeInsightActionHandler {
 		return GotoErrorInOtherModeHandler(forward = false)
 	}
 }

src/main/kotlin/com/chylex/intellij/keyboardmaster/feature/action/gotoType/GotoTypeInFileHandler.kt

@@ -52,7 +52,7 @@ class GotoTypeInFileHandler(private val forward: Boolean) : CodeInsightActionHan
 	
 	private companion object {
 		fun getNavigationOffsets(file: PsiFile, searchedOffsetRange: IntRange): IntArray {
-			val structureViewBuilder = LanguageStructureViewBuilder.INSTANCE.getStructureViewBuilder(file)
+			val structureViewBuilder = LanguageStructureViewBuilder.getInstance().getStructureViewBuilder(file)
 			if (structureViewBuilder !is TreeBasedStructureViewBuilder) {
 				return intArrayOf()
 			}

src/main/kotlin/com/chylex/intellij/keyboardmaster/feature/codeCompletion/CodeCompletionPopupConfiguration.kt

@@ -1,13 +1,13 @@
 package com.chylex.intellij.keyboardmaster.feature.codeCompletion
 
-import com.intellij.util.containers.IntIntHashMap
+import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap
 
 object CodeCompletionPopupConfiguration {
 	const val SHORTCUT_NONE = -1
 	const val SHORTCUT_NEXT_PAGE = -2
 	const val SHORTCUT_PREV_PAGE = -3
 	
-	private val charToShortcutMap = IntIntHashMap(16, SHORTCUT_NONE)
+	private val charToShortcutMap = Int2IntOpenHashMap(16).also { it.defaultReturnValue(SHORTCUT_NONE) }
 	private var hintTexts = mutableListOf<String>()
 	
 	val itemShortcutCount

src/main/kotlin/com/chylex/intellij/keyboardmaster/feature/vimNavigation/KeyStrokeNode.kt

@@ -59,7 +59,7 @@ internal interface KeyStrokeNode<T> {
 		override fun performAction(holder: T, actionEvent: AnActionEvent, keyEvent: KeyEvent) {
 			val action = actionEvent.actionManager.getAction(name) ?: return
 			
-			val dataContext = CustomizedDataContext.create(actionEvent.dataContext) {
+			val dataContext = CustomizedDataContext.withProvider(actionEvent.dataContext) {
 				when {
 					PlatformDataKeys.CONTEXT_COMPONENT.`is`(it) -> holder.component
 					else                                        -> null

src/main/kotlin/com/chylex/intellij/keyboardmaster/feature/vimNavigation/VimNavigation.kt

@@ -27,7 +27,7 @@ object VimNavigation {
 	fun register() {
 		val disposable = ApplicationManager.getApplication().getService(PluginDisposableService::class.java)
 		
-		StartupUiUtil.addAwtListener(::handleEvent, AWTEvent.FOCUS_EVENT_MASK, disposable)
+		StartupUiUtil.addAwtListener(AWTEvent.FOCUS_EVENT_MASK, disposable, ::handleEvent)
 		UiInterceptors.registerPersistent(disposable, PopupInterceptor)
 	}
 	

src/main/kotlin/com/chylex/intellij/keyboardmaster/feature/vimNavigation/VimNavigationDispatcher.kt

@@ -1,7 +1,7 @@
 package com.chylex.intellij.keyboardmaster.feature.vimNavigation
 
-import com.chylex.intellij.keyboardmaster.PluginDisposableService
 import com.chylex.intellij.keyboardmaster.feature.vimNavigation.VimNavigationDispatcher.WrappedAction.ForKeyListener
+import com.intellij.openapi.Disposable
 import com.intellij.openapi.actionSystem.ActionUpdateThread
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
@@ -26,10 +26,8 @@ import javax.swing.Action
 import javax.swing.JComponent
 import javax.swing.KeyStroke
 
-internal open class VimNavigationDispatcher<T : JComponent>(final override val component: T, private val rootNode: KeyStrokeNode.Parent<VimNavigationDispatcher<T>>) : DumbAwareAction(), ComponentHolder {
+internal open class VimNavigationDispatcher<T : JComponent>(final override val component: T, private val rootNode: KeyStrokeNode.Parent<VimNavigationDispatcher<T>>, disposable: Disposable? = null) : DumbAwareAction(), ComponentHolder {
 	companion object {
-		private val DISPOSABLE = ApplicationManager.getApplication().getService(PluginDisposableService::class.java)
-		
 		@JvmStatic
 		protected val ENTER_KEY: KeyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0)
 		
@@ -73,7 +71,7 @@ internal open class VimNavigationDispatcher<T : JComponent>(final override val c
 	var isSearching = AtomicBoolean(false)
 	
 	init {
-		registerCustomShortcutSet(KeyStrokeNode.getAllShortcuts(getAllKeyStrokes()), component, DISPOSABLE)
+		registerCustomShortcutSet(KeyStrokeNode.getAllShortcuts(getAllKeyStrokes()), component, disposable)
 		SpeedSearchSupply.getSupply(component, true)?.addChangeListener(::handleSpeedSearchChange)
 	}
 	

src/main/kotlin/com/chylex/intellij/keyboardmaster/feature/vimNavigation/components/VimListNavigation.kt

@@ -60,7 +60,7 @@ internal object VimListNavigation {
 	}
 	
 	@Suppress("serial")
-	private class VimPopupListNavigationDispatcher(component: JList<*>, override val popup: WizardPopup) : VimNavigationDispatcher<JList<*>>(component, POPUP_LIST_ROOT_NODE) {
+	private class VimPopupListNavigationDispatcher(component: JList<*>, override val popup: WizardPopup) : VimNavigationDispatcher<JList<*>>(component, POPUP_LIST_ROOT_NODE, popup.parent) {
 		init {
 			val speedSearch = SpeedSearchSupply.getSupply(component, true) as? SpeedSearch
 			if (speedSearch != null) {

src/main/kotlin/com/chylex/intellij/keyboardmaster/feature/vimNavigation/components/VimTreeNavigation.kt

@@ -8,9 +8,12 @@ import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.ui.getUserData
 import com.intellij.openapi.ui.putUserData
 import com.intellij.openapi.util.Key
+import com.intellij.ui.ClientProperty
+import com.intellij.ui.tree.ui.DefaultTreeUI
 import java.awt.event.KeyEvent
 import javax.swing.JTree
 import javax.swing.KeyStroke
+import javax.swing.tree.TreePath
 
 internal object VimTreeNavigation {
 	private val KEY = Key.create<VimNavigationDispatcher<JTree>>("KeyboardMaster-VimTreeNavigation")
@@ -22,21 +25,26 @@ internal object VimTreeNavigation {
 					KeyStroke.getKeyStroke('g') to IdeaAction("Tree-selectFirst"),
 					KeyStroke.getKeyStroke('j') to SelectLastSibling,
 					KeyStroke.getKeyStroke('k') to SelectFirstSibling,
+					KeyStroke.getKeyStroke('o') to ExpandChildrenToNextLevel,
 				)
 			),
 			KeyStroke.getKeyStroke('G') to IdeaAction("Tree-selectLast"),
+			KeyStroke.getKeyStroke('h') to CollapseSelfOrMoveToParentNode,
+			KeyStroke.getKeyStroke('H') to CollapseUntilRootNode,
 			KeyStroke.getKeyStroke('j') to IdeaAction("Tree-selectNext"),
 			KeyStroke.getKeyStroke('j', KeyEvent.ALT_DOWN_MASK) to IdeaAction("Tree-selectNextSibling"),
 			KeyStroke.getKeyStroke('J') to IdeaAction("Tree-selectNextExtendSelection"),
 			KeyStroke.getKeyStroke('k') to IdeaAction("Tree-selectPrevious"),
 			KeyStroke.getKeyStroke('k', KeyEvent.ALT_DOWN_MASK) to IdeaAction("Tree-selectPreviousSibling"),
 			KeyStroke.getKeyStroke('K') to IdeaAction("Tree-selectPreviousExtendSelection"),
+			KeyStroke.getKeyStroke('l') to ExpandSelfOrMoveToFirstChildNode,
+			KeyStroke.getKeyStroke('L') to ExpandUntilFirstLeafNode,
 			KeyStroke.getKeyStroke('o') to ExpandOrCollapseTreeNode,
 			KeyStroke.getKeyStroke('O') to IdeaAction("FullyExpandTreeNode"),
 			KeyStroke.getKeyStroke('p') to IdeaAction("Tree-selectParentNoCollapse"),
 			KeyStroke.getKeyStroke('P') to IdeaAction("Tree-selectFirst"),
 			KeyStroke.getKeyStroke('x') to CollapseSelfOrParentNode,
-			KeyStroke.getKeyStroke('X') to IdeaAction("CollapseTreeNode"),
+			KeyStroke.getKeyStroke('X') to CollapseAll,
 		)
 	)
 	
@@ -55,7 +63,51 @@ internal object VimTreeNavigation {
 				tree.collapsePath(path)
 			}
 			else {
-				tree.expandPath(path)
+				runWithoutAutoExpand(tree) { tree.expandPath(path) }
+			}
+		}
+	}
+	
+	private data object ExpandSelfOrMoveToFirstChildNode : ActionNode<VimNavigationDispatcher<JTree>> {
+		override fun performAction(holder: VimNavigationDispatcher<JTree>, actionEvent: AnActionEvent, keyEvent: KeyEvent) {
+			val tree = holder.component
+			val path = tree.selectionPath?.takeUnless { isLeaf(tree, it) } ?: return
+			
+			if (tree.isExpanded(path)) {
+				selectRow(tree, getFirstChild(tree, path))
+			}
+			else {
+				runWithoutAutoExpand(tree) { tree.expandPath(path) }
+			}
+		}
+	}
+	
+	private data object ExpandUntilFirstLeafNode : ActionNode<VimNavigationDispatcher<JTree>> {
+		override fun performAction(holder: VimNavigationDispatcher<JTree>, actionEvent: AnActionEvent, keyEvent: KeyEvent) {
+			val tree = holder.component
+			val path = tree.selectionPath ?: return
+			
+			var firstChildPath = path
+			
+			while (!isLeaf(tree, firstChildPath)) {
+				tree.expandPath(firstChildPath)
+				firstChildPath = getFirstChild(tree, firstChildPath)
+			}
+			
+			selectRow(tree, firstChildPath)
+		}
+	}
+	
+	private data object CollapseSelfOrMoveToParentNode : ActionNode<VimNavigationDispatcher<JTree>> {
+		override fun performAction(holder: VimNavigationDispatcher<JTree>, actionEvent: AnActionEvent, keyEvent: KeyEvent) {
+			val tree = holder.component
+			val path = tree.selectionPath ?: return
+			
+			if (tree.isExpanded(path)) {
+				collapseAndScroll(tree, path)
+			}
+			else {
+				withParentPath(tree, path) { selectRow(tree, it) }
 			}
 		}
 	}
@@ -66,17 +118,76 @@ internal object VimTreeNavigation {
 			val path = tree.selectionPath ?: return
 			
 			if (tree.isExpanded(path)) {
-				tree.collapsePath(path)
+				collapseAndScroll(tree, path)
 			}
 			else {
-				val parentPath = path.parentPath
+				withParentPath(tree, path) { collapseAndScroll(tree, it) }
-				if (parentPath.parentPath != null || tree.isRootVisible) {
-					tree.collapsePath(parentPath)
-				}
 			}
 		}
 	}
 	
+	private data object CollapseUntilRootNode : ActionNode<VimNavigationDispatcher<JTree>> {
+		override fun performAction(holder: VimNavigationDispatcher<JTree>, actionEvent: AnActionEvent, keyEvent: KeyEvent) {
+			val tree = holder.component
+			val path = tree.selectionPath ?: return
+			
+			var parentPath = path
+			
+			while (true) {
+				parentPath = parentPath.parentPath.takeUnless { isInvisibleRoot(tree, it) } ?: break
+			}
+			
+			collapseAndScroll(tree, parentPath)
+		}
+	}
+	
+	private data object CollapseAll : ActionNode<VimNavigationDispatcher<JTree>> {
+		override fun performAction(holder: VimNavigationDispatcher<JTree>, actionEvent: AnActionEvent, keyEvent: KeyEvent) {
+			val tree = holder.component
+			
+			CollapseUntilRootNode.performAction(holder, actionEvent, keyEvent)
+			
+			var row = 0
+			
+			while (row < tree.rowCount) {
+				tree.collapseRow(row)
+				row++
+			}
+		}
+	}
+	
+	private data object ExpandChildrenToNextLevel : ActionNode<VimNavigationDispatcher<JTree>> {
+		override fun performAction(holder: VimNavigationDispatcher<JTree>, actionEvent: AnActionEvent, keyEvent: KeyEvent) {
+			val tree = holder.component
+			val model = tree.model
+			val path = tree.selectionPath?.takeUnless { isLeaf(tree, it) } ?: return
+			
+			var pathsToExpand = mutableListOf(path)
+			
+			do {
+				if (pathsToExpand.any(tree::isCollapsed)) {
+					runWithoutAutoExpand(tree) { pathsToExpand.forEach(tree::expandPath) }
+					break
+				}
+				
+				val nextPathsToExpand = mutableListOf<TreePath>()
+				
+				for (parentPath in pathsToExpand) {
+					val lastPathComponent = parentPath.lastPathComponent
+					
+					for (i in 0 until model.getChildCount(lastPathComponent)) {
+						val child = model.getChild(lastPathComponent, i)
+						if (!model.isLeaf(child)) {
+							nextPathsToExpand.add(parentPath.pathByAddingChild(child))
+						}
+					}
+				}
+				
+				pathsToExpand = nextPathsToExpand
+			} while (pathsToExpand.isNotEmpty())
+		}
+	}
+	
 	private data object SelectFirstSibling : ActionNode<VimNavigationDispatcher<JTree>> {
 		override fun performAction(holder: VimNavigationDispatcher<JTree>, actionEvent: AnActionEvent, keyEvent: KeyEvent) {
 			val tree = holder.component
@@ -115,8 +226,46 @@ internal object VimTreeNavigation {
 		}
 	}
 	
+	private inline fun runWithoutAutoExpand(tree: JTree, action: () -> Unit) {
+		val previousAutoExpandValue = ClientProperty.get(tree, DefaultTreeUI.AUTO_EXPAND_ALLOWED)
+		ClientProperty.put(tree, DefaultTreeUI.AUTO_EXPAND_ALLOWED, false)
+		try {
+			action()
+		} finally {
+			ClientProperty.put(tree, DefaultTreeUI.AUTO_EXPAND_ALLOWED, previousAutoExpandValue)
+		}
+	}
+	
 	private fun selectRow(tree: JTree, row: Int) {
 		tree.setSelectionRow(row)
 		tree.scrollRowToVisible(row)
 	}
+	
+	private fun selectRow(tree: JTree, path: TreePath) {
+		selectRow(tree, tree.getRowForPath(path))
+	}
+	
+	private fun collapseAndScroll(tree: JTree, path: TreePath) {
+		tree.collapsePath(path)
+		tree.scrollRowToVisible(tree.getRowForPath(path))
+	}
+	
+	private inline fun withParentPath(tree: JTree, path: TreePath, action: (TreePath) -> Unit) {
+		val parentPath = path.parentPath
+		if (!isInvisibleRoot(tree, parentPath)) {
+			action(parentPath)
+		}
+	}
+	
+	private fun isInvisibleRoot(tree: JTree, parentPath: TreePath): Boolean {
+		return parentPath.parentPath == null && !tree.isRootVisible
+	}
+	
+	private fun getFirstChild(tree: JTree, path: TreePath): TreePath {
+		return path.pathByAddingChild(tree.model.getChild(path.lastPathComponent, 0))
+	}
+	
+	private fun isLeaf(tree: JTree, firstChildPath: TreePath): Boolean {
+		return tree.model.isLeaf(firstChildPath.lastPathComponent)
+	}
 }