From bfa4006b8f22ea2940d9e8ef6d7aea12d08b7ec3 Mon Sep 17 00:00:00 2001 From: chylex Date: Tue, 24 Nov 2020 15:59:21 +0100 Subject: [PATCH] Major AceJump refactoring! See https://github.com/acejump/AceJump/issues/348 for information on what's changed and what more needs to be done. --- .editorconfig | 12 +- .gitattributes | 1 + build.gradle.kts | 5 +- src/main/kotlin/org/acejump/AceUtil.kt | 82 +++++ .../kotlin/org/acejump/action/AceAction.kt | 61 ++++ .../org/acejump/action/AceEditorAction.kt | 62 ++++ .../kotlin/org/acejump/action/TagJumper.kt | 108 ++++++ .../kotlin/org/acejump/action/TagVisitor.kt | 73 ++++ .../org/acejump/boundaries/Boundaries.kt | 44 +++ .../acejump/boundaries/EditorOffsetCache.kt | 91 +++++ .../acejump/boundaries/StandardBoundaries.kt | 65 ++++ .../kotlin/org/acejump/config/AceConfig.kt | 125 ++----- .../org/acejump/config/AceConfigurable.kt | 50 +-- .../kotlin/org/acejump/config/AceSettings.kt | 35 +- .../org/acejump/config/AceSettingsPanel.kt | 124 +++---- .../org/acejump/config/ColorConverter.kt | 6 +- .../kotlin/org/acejump/control/AceAction.kt | 90 ----- .../org/acejump/control/AceSearchSession.kt | 22 -- .../kotlin/org/acejump/control/Handler.kt | 207 ------------ .../kotlin/org/acejump/control/Listener.kt | 92 ----- .../kotlin/org/acejump/control/Scroller.kt | 101 ------ .../kotlin/org/acejump/control/Selector.kt | 31 -- .../kotlin/org/acejump/control/Trigger.kt | 41 --- .../org/acejump/input/EditorKeyListener.kt | 38 +++ src/main/kotlin/org/acejump/input/JumpMode.kt | 68 ++++ .../org/acejump/input/JumpModeTracker.kt | 48 +++ .../kotlin/org/acejump/input/KeyLayout.kt | 24 ++ .../org/acejump/input/KeyLayoutCache.kt | 93 +++++ src/main/kotlin/org/acejump/label/Pattern.kt | 72 ---- src/main/kotlin/org/acejump/label/Solver.kt | 210 ------------ src/main/kotlin/org/acejump/label/Tagger.kt | 319 ------------------ .../kotlin/org/acejump/search/AceFindModel.kt | 26 -- src/main/kotlin/org/acejump/search/AceUtil.kt | 294 ---------------- src/main/kotlin/org/acejump/search/Finder.kt | 229 ------------- .../kotlin/org/acejump/search/JumpMode.kt | 89 ----- src/main/kotlin/org/acejump/search/Jumper.kt | 132 -------- src/main/kotlin/org/acejump/search/Pattern.kt | 9 + src/main/kotlin/org/acejump/search/Scanner.kt | 76 ----- .../org/acejump/search/SearchProcessor.kt | 122 +++++++ .../kotlin/org/acejump/search/SearchQuery.kt | 62 ++++ src/main/kotlin/org/acejump/search/Solver.kt | 186 ++++++++++ src/main/kotlin/org/acejump/search/Tagger.kt | 195 +++++++++++ .../org/acejump/search/TaggingResult.kt | 8 + .../org/acejump/session/EditorSettings.kt | 29 ++ .../kotlin/org/acejump/session/Session.kt | 195 +++++++++++ .../org/acejump/session/SessionManager.kt | 41 +++ src/main/kotlin/org/acejump/view/Boundary.kt | 69 ---- src/main/kotlin/org/acejump/view/Canvas.kt | 65 ---- src/main/kotlin/org/acejump/view/Marker.kt | 230 ------------- src/main/kotlin/org/acejump/view/Model.kt | 73 ---- src/main/kotlin/org/acejump/view/Tag.kt | 139 ++++++++ src/main/kotlin/org/acejump/view/TagCanvas.kt | 101 ++++++ src/main/kotlin/org/acejump/view/TagFont.kt | 20 ++ .../org/acejump/view/TextHighlighter.kt | 139 ++++++++ src/main/resources/AceResources.properties | 26 -- src/main/resources/META-INF/plugin.xml | 71 ++-- src/test/kotlin/AceTest.kt | 156 ++------- src/test/kotlin/LatencyTest.kt | 45 +++ .../kotlin/org/acejump/test/util/BaseTest.kt | 75 ++++ 59 files changed, 2407 insertions(+), 2895 deletions(-) create mode 100644 .gitattributes create mode 100644 src/main/kotlin/org/acejump/AceUtil.kt create mode 100644 src/main/kotlin/org/acejump/action/AceAction.kt create mode 100644 src/main/kotlin/org/acejump/action/AceEditorAction.kt create mode 100644 src/main/kotlin/org/acejump/action/TagJumper.kt create mode 100644 src/main/kotlin/org/acejump/action/TagVisitor.kt create mode 100644 src/main/kotlin/org/acejump/boundaries/Boundaries.kt create mode 100644 src/main/kotlin/org/acejump/boundaries/EditorOffsetCache.kt create mode 100644 src/main/kotlin/org/acejump/boundaries/StandardBoundaries.kt delete mode 100755 src/main/kotlin/org/acejump/control/AceAction.kt delete mode 100644 src/main/kotlin/org/acejump/control/AceSearchSession.kt delete mode 100755 src/main/kotlin/org/acejump/control/Handler.kt delete mode 100644 src/main/kotlin/org/acejump/control/Listener.kt delete mode 100644 src/main/kotlin/org/acejump/control/Scroller.kt delete mode 100644 src/main/kotlin/org/acejump/control/Selector.kt delete mode 100644 src/main/kotlin/org/acejump/control/Trigger.kt create mode 100644 src/main/kotlin/org/acejump/input/EditorKeyListener.kt create mode 100644 src/main/kotlin/org/acejump/input/JumpMode.kt create mode 100644 src/main/kotlin/org/acejump/input/JumpModeTracker.kt create mode 100644 src/main/kotlin/org/acejump/input/KeyLayout.kt create mode 100644 src/main/kotlin/org/acejump/input/KeyLayoutCache.kt delete mode 100644 src/main/kotlin/org/acejump/label/Pattern.kt delete mode 100644 src/main/kotlin/org/acejump/label/Solver.kt delete mode 100755 src/main/kotlin/org/acejump/label/Tagger.kt delete mode 100644 src/main/kotlin/org/acejump/search/AceFindModel.kt delete mode 100755 src/main/kotlin/org/acejump/search/AceUtil.kt delete mode 100644 src/main/kotlin/org/acejump/search/Finder.kt delete mode 100644 src/main/kotlin/org/acejump/search/JumpMode.kt delete mode 100755 src/main/kotlin/org/acejump/search/Jumper.kt create mode 100644 src/main/kotlin/org/acejump/search/Pattern.kt delete mode 100644 src/main/kotlin/org/acejump/search/Scanner.kt create mode 100644 src/main/kotlin/org/acejump/search/SearchProcessor.kt create mode 100644 src/main/kotlin/org/acejump/search/SearchQuery.kt create mode 100644 src/main/kotlin/org/acejump/search/Solver.kt create mode 100644 src/main/kotlin/org/acejump/search/Tagger.kt create mode 100644 src/main/kotlin/org/acejump/search/TaggingResult.kt create mode 100644 src/main/kotlin/org/acejump/session/EditorSettings.kt create mode 100644 src/main/kotlin/org/acejump/session/Session.kt create mode 100644 src/main/kotlin/org/acejump/session/SessionManager.kt delete mode 100644 src/main/kotlin/org/acejump/view/Boundary.kt delete mode 100755 src/main/kotlin/org/acejump/view/Canvas.kt delete mode 100644 src/main/kotlin/org/acejump/view/Marker.kt delete mode 100644 src/main/kotlin/org/acejump/view/Model.kt create mode 100644 src/main/kotlin/org/acejump/view/Tag.kt create mode 100644 src/main/kotlin/org/acejump/view/TagCanvas.kt create mode 100644 src/main/kotlin/org/acejump/view/TagFont.kt create mode 100644 src/main/kotlin/org/acejump/view/TextHighlighter.kt delete mode 100644 src/main/resources/AceResources.properties create mode 100644 src/test/kotlin/LatencyTest.kt create mode 100644 src/test/kotlin/org/acejump/test/util/BaseTest.kt diff --git a/.editorconfig b/.editorconfig index b47e5f21..8a100bc9 100644 --- a/.editorconfig +++ b/.editorconfig @@ -1,7 +1,7 @@ [*] -charset=utf-8 -end_of_line=lf -insert_final_newline=false -indent_style=space -indent_size=2 -max_line_length=80 \ No newline at end of file +charset = utf-8 +end_of_line = lf +insert_final_newline = true +indent_style = space +indent_size = 2 +max_line_length = 140 \ No newline at end of file diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..6313b56c --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +* text=auto eol=lf diff --git a/build.gradle.kts b/build.gradle.kts index 17489768..1c9166db 100755 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,7 +1,8 @@ import org.jetbrains.changelog.closure -import org.jetbrains.intellij.tasks.* -import org.jetbrains.kotlin.gradle.tasks.KotlinCompile import org.jetbrains.intellij.tasks.PatchPluginXmlTask +import org.jetbrains.intellij.tasks.PublishTask +import org.jetbrains.intellij.tasks.RunIdeTask +import org.jetbrains.kotlin.gradle.tasks.KotlinCompile plugins { idea apply true diff --git a/src/main/kotlin/org/acejump/AceUtil.kt b/src/main/kotlin/org/acejump/AceUtil.kt new file mode 100644 index 00000000..6f2ceb4d --- /dev/null +++ b/src/main/kotlin/org/acejump/AceUtil.kt @@ -0,0 +1,82 @@ +package org.acejump + +import com.intellij.openapi.editor.Editor + +annotation class ExternalUsage + +/** + * Returns an immutable version of the currently edited document. + */ +val Editor.immutableText + get() = this.document.immutableCharSequence + +/** + * Returns true if [this] contains [otherText] at the specified offset. + */ +fun CharSequence.matchesAt(selfOffset: Int, otherText: String, ignoreCase: Boolean): Boolean { + return this.regionMatches(selfOffset, otherText, 0, otherText.length, ignoreCase) +} + +/** + * Calculates the length of a common prefix in [this] starting at index [selfOffset], and [otherText] starting at index 0. + */ +fun CharSequence.countMatchingCharacters(selfOffset: Int, otherText: String): Int { + var i = 0 + var o = selfOffset + i + + while (i < otherText.length && o < this.length && otherText[i].equals(this[o], ignoreCase = true)) { + i++ + o++ + } + + return i +} + +/** + * Determines which characters form a "word" for the purposes of functions below. + */ +val Char.isWordPart + get() = this.isJavaIdentifierPart() + +/** + * Finds index of the first character in a word. + */ +inline fun CharSequence.wordStart(pos: Int, isPartOfWord: (Char) -> Boolean = Char::isWordPart): Int { + var start = pos + + while (start > 0 && isPartOfWord(this[start - 1])) { + --start + } + + return start +} + +/** + * Finds index of the last character in a word. + */ +inline fun CharSequence.wordEnd(pos: Int, isPartOfWord: (Char) -> Boolean = Char::isWordPart): Int { + var end = pos + + while (end < length - 1 && isPartOfWord(this[end + 1])) { + ++end + } + + return end +} + +/** + * Finds index of the first word character following a sequence of non-word characters following the end of a word. + */ +inline fun CharSequence.wordEndPlus(pos: Int, isPartOfWord: (Char) -> Boolean = Char::isWordPart): Int { + var end = this.wordEnd(pos, isPartOfWord) + + while (end < length - 1 && !isPartOfWord(this[end + 1])) { + ++end + } + + if (end < length - 1 && isPartOfWord(this[end + 1])) { + ++end + } + + return end +} diff --git a/src/main/kotlin/org/acejump/action/AceAction.kt b/src/main/kotlin/org/acejump/action/AceAction.kt new file mode 100644 index 00000000..bf0e9840 --- /dev/null +++ b/src/main/kotlin/org/acejump/action/AceAction.kt @@ -0,0 +1,61 @@ +package org.acejump.action + +import com.intellij.openapi.actionSystem.AnActionEvent +import com.intellij.openapi.actionSystem.CommonDataKeys.EDITOR +import com.intellij.openapi.project.DumbAwareAction +import org.acejump.boundaries.Boundaries +import org.acejump.boundaries.StandardBoundaries +import org.acejump.input.JumpMode +import org.acejump.search.Pattern +import org.acejump.session.Session +import org.acejump.session.SessionManager + +/** + * Base class for keyboard-activated actions that create or update an AceJump [Session]. + */ +sealed class AceAction : DumbAwareAction() { + final override fun update(action: AnActionEvent) { + action.presentation.isEnabled = action.getData(EDITOR) != null + } + + final override fun actionPerformed(e: AnActionEvent) { + invoke(SessionManager.start(e.getData(EDITOR) ?: return)) + } + + abstract operator fun invoke(session: Session) + + /** + * Generic action type that toggles a specific [JumpMode]. + */ + abstract class BaseToggleJumpModeAction(private val mode: JumpMode) : AceAction() { + final override fun invoke(session: Session) = session.toggleJumpMode(mode) + } + + /** + * Generic action type that starts a regex search. + */ + abstract class BaseRegexSearchAction(private val pattern: Pattern, private val boundaries: Boundaries) : AceAction() { + override fun invoke(session: Session) = session.startRegexSearch(pattern, boundaries) + } + + /** + * Initiates an AceJump session in the first [JumpMode], or cycles to the next [JumpMode] as defined in configuration. + */ + object ActivateOrCycleMode : AceAction() { + override fun invoke(session: Session) = session.cycleJumpMode() + } + + // @formatter:off + + object ToggleJumpMode : BaseToggleJumpModeAction(JumpMode.JUMP) + object ToggleJumpEndMode : BaseToggleJumpModeAction(JumpMode.JUMP_END) + object ToggleTargetMode : BaseToggleJumpModeAction(JumpMode.TARGET) + object ToggleDeclarationMode : BaseToggleJumpModeAction(JumpMode.DEFINE) + + object ToggleAllLinesMode : BaseRegexSearchAction(Pattern.LINE_MARK, StandardBoundaries.WHOLE_FILE) + object ToggleAllWordsMode : BaseRegexSearchAction(Pattern.ALL_WORDS, StandardBoundaries.WHOLE_FILE) + object ToggleAllWordsBackwardsMode : BaseRegexSearchAction(Pattern.ALL_WORDS, StandardBoundaries.BEFORE_CARET) + object ToggleAllWordsForwardMode : BaseRegexSearchAction(Pattern.ALL_WORDS, StandardBoundaries.AFTER_CARET) + + // @formatter:on +} diff --git a/src/main/kotlin/org/acejump/action/AceEditorAction.kt b/src/main/kotlin/org/acejump/action/AceEditorAction.kt new file mode 100644 index 00000000..13eb8e2e --- /dev/null +++ b/src/main/kotlin/org/acejump/action/AceEditorAction.kt @@ -0,0 +1,62 @@ +package org.acejump.action + +import com.intellij.openapi.actionSystem.DataContext +import com.intellij.openapi.editor.Caret +import com.intellij.openapi.editor.Editor +import com.intellij.openapi.editor.actionSystem.EditorActionHandler +import org.acejump.boundaries.StandardBoundaries +import org.acejump.search.Pattern +import org.acejump.session.Session +import org.acejump.session.SessionManager + +/** + * Base class for keyboard-activated overrides of existing editor actions, that have a different meaning during an AceJump [Session]. + */ +sealed class AceEditorAction(private val originalHandler: EditorActionHandler) : EditorActionHandler() { + final override fun isEnabledForCaret(editor: Editor, caret: Caret, dataContext: DataContext?): Boolean { + return SessionManager[editor] != null || originalHandler.isEnabled(editor, caret, dataContext) + } + + final override fun doExecute(editor: Editor, caret: Caret?, dataContext: DataContext?) { + val session = SessionManager[editor] + + if (session != null) { + run(session) + } + else if (originalHandler.isEnabled(editor, caret, dataContext)) { + originalHandler.execute(editor, caret, dataContext) + } + } + + protected abstract fun run(session: Session) + + // Actions + + class Reset(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) { + override fun run(session: Session) = session.end() + } + + class ClearSearch(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) { + override fun run(session: Session) = session.restart() + } + + class SelectBackward(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) { + override fun run(session: Session) = session.visitPreviousTag() + } + + class SelectForward(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) { + override fun run(session: Session) = session.visitNextTag() + } + + class SearchCodeIndents(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) { + override fun run(session: Session) = session.startRegexSearch(Pattern.CODE_INDENTS, StandardBoundaries.WHOLE_FILE) + } + + class SearchLineStarts(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) { + override fun run(session: Session) = session.startRegexSearch(Pattern.START_OF_LINE, StandardBoundaries.WHOLE_FILE) + } + + class SearchLineEnds(originalHandler: EditorActionHandler) : AceEditorAction(originalHandler) { + override fun run(session: Session) = session.startRegexSearch(Pattern.END_OF_LINE, StandardBoundaries.WHOLE_FILE) + } +} diff --git a/src/main/kotlin/org/acejump/action/TagJumper.kt b/src/main/kotlin/org/acejump/action/TagJumper.kt new file mode 100644 index 00000000..b9f67eb3 --- /dev/null +++ b/src/main/kotlin/org/acejump/action/TagJumper.kt @@ -0,0 +1,108 @@ +package org.acejump.action + +import com.intellij.codeInsight.navigation.actions.GotoDeclarationAction +import com.intellij.codeInsight.navigation.actions.GotoTypeDeclarationAction +import com.intellij.openapi.actionSystem.ActionManager +import com.intellij.openapi.actionSystem.AnAction +import com.intellij.openapi.command.CommandProcessor +import com.intellij.openapi.command.UndoConfirmationPolicy +import com.intellij.openapi.editor.Document +import com.intellij.openapi.editor.Editor +import com.intellij.openapi.editor.actionSystem.DocCommandGroupId +import com.intellij.openapi.fileEditor.ex.IdeDocumentHistory +import com.intellij.openapi.project.Project +import com.intellij.openapi.ui.playback.commands.ActionCommand +import org.acejump.* +import org.acejump.input.JumpMode +import org.acejump.input.JumpMode.* +import org.acejump.search.SearchProcessor + +/** + * Performs [JumpMode] navigation and actions. + */ +internal class TagJumper(private val editor: Editor, private val mode: JumpMode, private val searchProcessor: SearchProcessor?) { + /** + * Moves caret to a specific offset in the editor according to the positioning and selection rules of the current [JumpMode]. + */ + fun visit(offset: Int) { + if (mode === JUMP_END || mode === TARGET) { + val chars = editor.immutableText + val matchingChars = searchProcessor?.let { chars.countMatchingCharacters(offset, it.query.rawText) } ?: 0 + val targetOffset = offset + matchingChars + val isInsideWord = matchingChars > 0 && chars[targetOffset - 1].isWordPart && chars[targetOffset].isWordPart + val finalTargetOffset = if (isInsideWord) chars.wordEnd(targetOffset) + 1 else targetOffset + + if (mode === JUMP_END) { + moveCaretTo(editor, finalTargetOffset) + } + else if (mode === TARGET) { + if (isInsideWord) { + selectRange(editor, chars.wordStart(targetOffset), finalTargetOffset) + } + else { + selectRange(editor, offset, finalTargetOffset) + } + } + } + else { + moveCaretTo(editor, offset) + } + } + + /** + * Updates caret and selection by [visit]ing a specific offset in the editor, and applying session-finalizing [JumpMode] actions such as + * using the Go To Declaration action, or selecting text between caret and target offset/word if Shift was held during the jump. + */ + fun jump(offset: Int, shiftMode: Boolean) { + val oldOffset = editor.caretModel.offset + + visit(offset) + + if (mode === DEFINE) { + performAction(if (shiftMode) GotoTypeDeclarationAction() else GotoDeclarationAction()) + return + } + + if (shiftMode) { + val newOffset = editor.caretModel.offset + + if (mode === TARGET) { + selectRange(editor, oldOffset, when { + newOffset < oldOffset -> editor.selectionModel.selectionStart + else -> editor.selectionModel.selectionEnd + }) + } + else { + selectRange(editor, oldOffset, newOffset) + } + } + } + + private companion object { + private fun moveCaretTo(editor: Editor, offset: Int) = with(editor) { + project?.let { addCurrentPositionToHistory(it, document) } + selectionModel.removeSelection(true) + caretModel.moveToOffset(offset) + } + + private fun selectRange(editor: Editor, fromOffset: Int, toOffset: Int) = with(editor) { + selectionModel.removeSelection(true) + selectionModel.setSelection(fromOffset, toOffset) + caretModel.moveToOffset(toOffset) + } + + private fun addCurrentPositionToHistory(project: Project, document: Document) { + CommandProcessor.getInstance().executeCommand(project, { + with(IdeDocumentHistory.getInstance(project)) { + setCurrentCommandHasMoves() + includeCurrentCommandAsNavigation() + includeCurrentPlaceAsChangePlace() + } + }, "AceJumpHistoryAppender", DocCommandGroupId.noneGroupId(document), UndoConfirmationPolicy.DO_NOT_REQUEST_CONFIRMATION, document) + } + + private fun performAction(action: AnAction) { + ActionManager.getInstance().tryToExecute(action, ActionCommand.getInputEvent(null), null, null, true) + } + } +} diff --git a/src/main/kotlin/org/acejump/action/TagVisitor.kt b/src/main/kotlin/org/acejump/action/TagVisitor.kt new file mode 100644 index 00000000..0733ece8 --- /dev/null +++ b/src/main/kotlin/org/acejump/action/TagVisitor.kt @@ -0,0 +1,73 @@ +package org.acejump.action + +import com.intellij.openapi.editor.Editor +import com.intellij.openapi.editor.ScrollType +import com.intellij.openapi.editor.SelectionModel +import org.acejump.search.SearchProcessor +import kotlin.math.abs + +/** + * Enables navigation between currently active tags. + */ +internal class TagVisitor(private val editor: Editor, private val searchProcessor: SearchProcessor, private val tagJumper: TagJumper) { + /** + * Places caret at the closest tag following the caret position, according to the rules of the current jump mode (see [TagJumper.visit]). + * If the caret is at or past the last tag, it moves to the first tag instead. + * If there is only one tag, it immediately performs the jump action as described in [TagJumper.jump]. + */ + fun visitNext(): Boolean { + return visit(SelectionModel::getSelectionEnd) { if (it < 0) -it - 1 else it + 1 } + } + + /** + * Places caret at the closest tag preceding the caret position, according to the rules of the current jump mode (see [TagJumper.visit]). + * If the caret is at or before the first tag, it moves to the last tag instead. + * If there is only one tag, it immediately performs the jump action as described in [TagJumper.jump]. + */ + fun visitPrevious(): Boolean { + return visit(SelectionModel::getSelectionStart) { if (it < 0) -it - 2 else it - 1 } + } + + /** + * Scrolls to the closest result to the caret. + */ + fun scrollToClosest() { + val caret = editor.caretModel.offset + val results = searchProcessor.results.takeUnless { it.isEmpty } ?: return + val index = results.binarySearch(caret).let { if (it < 0) -it - 1 else it } + + val targetOffset = listOfNotNull( + results.getOrNull(index - 1), + results.getOrNull(index) + ).minBy { + abs(it - caret) + } + + if (targetOffset != null) { + editor.scrollingModel.scrollTo(editor.offsetToLogicalPosition(targetOffset), ScrollType.RELATIVE) + } + } + + private inline fun visit(caretPosition: SelectionModel.() -> Int, indexModifier: (Int) -> Int): Boolean { + val results = searchProcessor.results.takeUnless { it.isEmpty } ?: return false + val nextIndex = indexModifier(results.binarySearch(caretPosition(editor.selectionModel))) + + val targetOffset = results.getInt(when { + nextIndex < 0 -> results.lastIndex + nextIndex > results.lastIndex -> 0 + else -> nextIndex + }) + + val onlyResult = results.size == 1 + + if (onlyResult) { + tagJumper.jump(targetOffset, shiftMode = false) + } + else { + tagJumper.visit(targetOffset) + } + + editor.scrollingModel.scrollToCaret(ScrollType.RELATIVE) + return onlyResult + } +} diff --git a/src/main/kotlin/org/acejump/boundaries/Boundaries.kt b/src/main/kotlin/org/acejump/boundaries/Boundaries.kt new file mode 100644 index 00000000..42352085 --- /dev/null +++ b/src/main/kotlin/org/acejump/boundaries/Boundaries.kt @@ -0,0 +1,44 @@ +package org.acejump.boundaries + +import com.intellij.openapi.editor.Editor +import kotlin.math.max +import kotlin.math.min + +/** + * Defines a (possibly) disjoint set of editor offsets that partitions the whole editor into two groups - offsets inside the range, and + * offsets outside the range. + */ +interface Boundaries { + /** + * Returns a range of editor offsets, starting at the first offset in the boundary, and ending at the last offset in the boundary. + * May include offsets outside the boundary, for ex. when the boundary is rectangular and the file has long lines which are only + * partially visible. + */ + fun getOffsetRange(editor: Editor, cache: EditorOffsetCache = EditorOffsetCache.Uncached): IntRange + + /** + * Returns whether the editor offset is included within the boundary. + */ + fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache = EditorOffsetCache.Uncached): Boolean + + /** + * Creates a boundary so that an offset/range is within the boundary iff it is within both original boundaries. + */ + fun intersection(other: Boundaries): Boundaries { + if (this === other) { + return this + } + + return object : Boundaries { + override fun getOffsetRange(editor: Editor, cache: EditorOffsetCache): IntRange { + val b1 = this@Boundaries.getOffsetRange(editor, cache) + val b2 = other.getOffsetRange(editor, cache) + return max(b1.first, b2.first)..min(b1.last, b2.last) + } + + override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache): Boolean { + return this@Boundaries.isOffsetInside(editor, offset, cache) && other.isOffsetInside(editor, offset, cache) + } + } + } +} diff --git a/src/main/kotlin/org/acejump/boundaries/EditorOffsetCache.kt b/src/main/kotlin/org/acejump/boundaries/EditorOffsetCache.kt new file mode 100644 index 00000000..292f13c1 --- /dev/null +++ b/src/main/kotlin/org/acejump/boundaries/EditorOffsetCache.kt @@ -0,0 +1,91 @@ +package org.acejump.boundaries + +import com.intellij.openapi.editor.Editor +import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap +import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap +import java.awt.Point + +/** + * Optionally caches slow operations of (1) retrieving the currently visible editor area, and (2) converting between editor offsets and + * pixel coordinates. + * + * To avoid unnecessary overhead, there is no automatic detection of when the editor, its contents, or its visible area has changed, so the + * cache must only be used for a single rendered frame of a single [Editor]. + */ +sealed class EditorOffsetCache { + /** + * Returns the top left and bottom right points of the visible area rectangle. + */ + abstract fun visibleArea(editor: Editor): Pair + + /** + * Returns the editor offset at the provided pixel coordinate. + */ + abstract fun xyToOffset(editor: Editor, pos: Point): Int + + /** + * Returns the top left pixel coordinate of the character at the provided editor offset. + */ + abstract fun offsetToXY(editor: Editor, offset: Int): Point + + companion object { + fun new(): EditorOffsetCache { + return Cache() + } + } + + private class Cache : EditorOffsetCache() { + private var visibleArea: Pair? = null + private val pointToOffset = Object2IntOpenHashMap().apply { defaultReturnValue(-1) } + private val offsetToPoint = Int2ObjectOpenHashMap() + + override fun visibleArea(editor: Editor): Pair { + return visibleArea ?: Uncached.visibleArea(editor).also { visibleArea = it } + } + + override fun xyToOffset(editor: Editor, pos: Point): Int { + val offset = pointToOffset.getInt(pos) + + if (offset != -1) { + return offset + } + + return Uncached.xyToOffset(editor, pos).also { + @Suppress("ReplacePutWithAssignment") + pointToOffset.put(pos, it) + } + } + + override fun offsetToXY(editor: Editor, offset: Int): Point { + val pos = offsetToPoint.get(offset) + + if (pos != null) { + return pos + } + + return Uncached.offsetToXY(editor, offset).also { + @Suppress("ReplacePutWithAssignment") + offsetToPoint.put(offset, it) + } + } + } + + object Uncached : EditorOffsetCache() { + override fun visibleArea(editor: Editor): Pair { + val visibleRect = editor.scrollingModel.visibleArea + + return Pair( + visibleRect.location, + visibleRect.location.apply { translate(visibleRect.width, visibleRect.height) } + ) + } + + override fun xyToOffset(editor: Editor, pos: Point): Int { + return editor.logicalPositionToOffset(editor.xyToLogicalPosition(pos)) + } + + override fun offsetToXY(editor: Editor, offset: Int): Point { + return editor.offsetToXY(offset, true, false) + } + } +} diff --git a/src/main/kotlin/org/acejump/boundaries/StandardBoundaries.kt b/src/main/kotlin/org/acejump/boundaries/StandardBoundaries.kt new file mode 100644 index 00000000..98277648 --- /dev/null +++ b/src/main/kotlin/org/acejump/boundaries/StandardBoundaries.kt @@ -0,0 +1,65 @@ +package org.acejump.boundaries + +import com.intellij.openapi.editor.Editor + +enum class StandardBoundaries : Boundaries { + WHOLE_FILE { + override fun getOffsetRange(editor: Editor, cache: EditorOffsetCache): IntRange { + return 0 until editor.document.textLength + } + + override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache): Boolean { + return offset in (0 until editor.document.textLength) + } + }, + + VISIBLE_ON_SCREEN { + override fun getOffsetRange(editor: Editor, cache: EditorOffsetCache): IntRange { + val (topLeft, bottomRight) = cache.visibleArea(editor) + val startOffset = cache.xyToOffset(editor, topLeft) + val endOffset = cache.xyToOffset(editor, bottomRight) + + return startOffset..endOffset + } + + override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache): Boolean { + + // 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 + } + }, + + BEFORE_CARET { + override fun getOffsetRange(editor: Editor, cache: EditorOffsetCache): IntRange { + return 0..(editor.caretModel.offset) + } + + override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache): Boolean { + return offset <= editor.caretModel.offset + } + }, + + AFTER_CARET { + override fun getOffsetRange(editor: Editor, cache: EditorOffsetCache): IntRange { + return editor.caretModel.offset until editor.document.textLength + } + + override fun isOffsetInside(editor: Editor, offset: Int, cache: EditorOffsetCache): Boolean { + return offset >= editor.caretModel.offset + } + } +} diff --git a/src/main/kotlin/org/acejump/config/AceConfig.kt b/src/main/kotlin/org/acejump/config/AceConfig.kt index bf96d663..bdf89b4c 100644 --- a/src/main/kotlin/org/acejump/config/AceConfig.kt +++ b/src/main/kotlin/org/acejump/config/AceConfig.kt @@ -4,112 +4,39 @@ import com.intellij.openapi.components.PersistentStateComponent import com.intellij.openapi.components.ServiceManager import com.intellij.openapi.components.State import com.intellij.openapi.components.Storage -import com.intellij.openapi.diagnostic.Logger -import org.acejump.label.Pattern -import org.acejump.label.Pattern.Companion.KeyLayout -import org.acejump.label.mapIndices -import org.acejump.search.JumpMode -import java.awt.Color +import org.acejump.input.KeyLayoutCache /** - * Ensures consistiency between [AceSettings] and [AceSettingsPanel]. - * Persists the state of the AceJump IDE settings across IDE restarts. - * https://www.jetbrains.org/intellij/sdk/docs/basics/persisting_state_of_components.html + * Ensures consistiency between [AceSettings] and [AceSettingsPanel]. Persists the state of the AceJump IDE settings across IDE restarts. + * [https://www.jetbrains.org/intellij/sdk/docs/basics/persisting_state_of_components.html] */ - @State(name = "AceConfig", storages = [(Storage("\$APP_CONFIG\$/AceJump.xml"))]) -class AceConfig: PersistentStateComponent { - private val logger = Logger.getInstance(AceConfig::class.java) - - internal var aceSettings = AceSettings() - set(value) { - allPossibleTags = value.allowedChars.bigrams(defaultTagOrder(value.layout)) - field = value - } - +class AceConfig : PersistentStateComponent { + private var aceSettings = AceSettings() + companion object { - val settings: AceSettings + val settings get() = ServiceManager.getService(AceConfig::class.java).aceSettings - val allowedChars: String get() = settings.allowedChars - val layout: KeyLayout get() = settings.layout - val cycleMode1: JumpMode get() = settings.cycleMode1 - val cycleMode2: JumpMode get() = settings.cycleMode2 - val cycleMode3: JumpMode get() = settings.cycleMode3 - val cycleMode4: JumpMode get() = settings.cycleMode4 - val jumpModeColor: Color get() = settings.jumpModeColor - val jumpEndModeColor: Color get() = settings.jumpEndModeColor - val targetModeColor: Color get() = settings.targetModeColor - val definitionModeColor: Color get() = settings.definitionModeColor - val textHighlightColor: Color get() = settings.textHighlightColor - val tagForegroundColor: Color get() = settings.tagForegroundColor - val tagBackgroundColor: Color get() = settings.tagBackgroundColor - val roundedTagCorners: Boolean get() = settings.roundedTagCorners - val searchWholeFile: Boolean get() = settings.searchWholeFile - val supportPinyin: Boolean get() = settings.supportPinyin - - private val nearby: Map> = mapOf( - // Values are QWERTY keys sorted by physical proximity to the map key - 'j' to "jikmnhuolbgypvftcdrxsezawq8796054321", - 'f' to "ftgvcdryhbxseujnzawqikmolp5463728190", - 'k' to "kolmjipnhubgyvftcdrxsezawq9807654321", - 'd' to "drfcxsetgvzawyhbqujnikmolp4352617890", - 'l' to "lkopmjinhubgyvftcdrxsezawq0987654321", - 's' to "sedxzawrfcqtgvyhbujnikmolp3241567890", - 'a' to "aqwszedxrfctgvyhbujnikmolp1234567890", - 'h' to "hujnbgyikmvftolcdrpxsezawq6758493021", - 'g' to "gyhbvftujncdrikmxseolzawpq5647382910", - 'y' to "yuhgtijnbvfrokmcdeplxswzaq6758493021", - 't' to "tygfruhbvcdeijnxswokmzaqpl5647382910", - 'u' to "uijhyokmnbgtplvfrcdexswzaq7869504321", - 'r' to "rtfdeygvcxswuhbzaqijnokmpl4536271890", - 'n' to "nbhjmvgyuiklocftpxdrzseawq7685940321", - 'v' to "vcfgbxdrtyhnzseujmawikqolp5463728190", - 'm' to "mnjkbhuilvgyopcftxdrzseawq8970654321", - 'c' to "cxdfvzsertgbawyhnqujmikolp4352617890", - 'b' to "bvghncftyujmxdrikzseolawqp6574839201", - 'i' to "iokjuplmnhybgtvfrcdexswzaq8970654321", - 'e' to "erdswtfcxzaqygvuhbijnokmpl3425167890", - 'x' to "xzsdcawerfvqtgbyhnujmikolp3241567890", - 'z' to "zasxqwedcrfvtgbyhnujmikolp1234567890", - 'o' to "oplkimjunhybgtvfrcdexswzaq9087654321", - 'w' to "wesaqrdxztfcygvuhbijnokmpl2314567890", - 'p' to "plokimjunhybgtvfrcdexswzaq0987654321", - 'q' to "qwaeszrdxtfcygvuhbijnokmpl1234567890", - '1' to "1234567890qawzsexdrcftvgybhunjimkolp", - '2' to "2134567890qwasezxdrcftvgybhunjimkolp", - '3' to "3241567890weqasdrzxcftvgybhunjimkolp", - '4' to "4352617890erwsdftqazxcvgybhunjimkolp", - '5' to "5463728190rtedfgywsxcvbhuqaznjimkolp", - '6' to "6574839201tyrfghuedcvbnjiwsxmkoqazlp", - '7' to "7685940321yutghjirfvbnmkoedclpwsxqaz", - '8' to "8796054321uiyhjkotgbnmlprfvedcwsxqaz", - '9' to "9807654321ioujklpyhnmtgbrfvedcwsxqaz", - '0' to "0987654321opiklujmyhntgbrfvedcwsxqaz") - .mapValues { (_, v) -> v.mapIndices() } - - private fun distance(fromKey: Char, toKey: Char) = nearby[fromKey]!![toKey] - - val defaultTagOrder = defaultTagOrder(this.layout) - - private fun defaultTagOrder(layout: KeyLayout) = compareBy( - { it[0].isDigit() || it[1].isDigit() }, - { distance(it[0], it.last()) }, - layout.priority { it[0] }) - - internal var allPossibleTags: Set = settings.allowedChars.bigrams() - - internal fun String.bigrams(comparator: Comparator = defaultTagOrder): Set { - return run { flatMap { e -> map { c -> "$e$c" } } }.sortedWith(comparator).toSet() - } - - fun getCompatibleTags(query: String, matching: (String) -> Boolean) = - Pattern.filter(allPossibleTags, query).filter(matching).toSet() + + val layout get() = settings.layout + val cycleModes get() = settings.let { arrayOf(it.cycleMode1, it.cycleMode2, it.cycleMode3, it.cycleMode4) } + val jumpModeColor get() = settings.jumpModeColor + val jumpEndModeColor get() = settings.jumpEndModeColor + val targetModeColor get() = settings.targetModeColor + val definitionModeColor get() = settings.definitionModeColor + val textHighlightColor get() = settings.textHighlightColor + val tagForegroundColor get() = settings.tagForegroundColor + val tagBackgroundColor get() = settings.tagBackgroundColor + val roundedTagCorners get() = settings.roundedTagCorners + val searchWholeFile get() = settings.searchWholeFile } - - override fun getState() = aceSettings - + + override fun getState(): AceSettings { + return aceSettings + } + override fun loadState(state: AceSettings) { - logger.info("Loaded AceConfig settings: $aceSettings") aceSettings = state + KeyLayoutCache.reset(state) } -} \ No newline at end of file +} diff --git a/src/main/kotlin/org/acejump/config/AceConfigurable.kt b/src/main/kotlin/org/acejump/config/AceConfigurable.kt index 420d131a..8fd25ea2 100644 --- a/src/main/kotlin/org/acejump/config/AceConfigurable.kt +++ b/src/main/kotlin/org/acejump/config/AceConfigurable.kt @@ -1,19 +1,16 @@ package org.acejump.config -import com.intellij.openapi.diagnostic.Logger import com.intellij.openapi.options.Configurable -import org.acejump.config.AceConfig.Companion.bigrams import org.acejump.config.AceConfig.Companion.settings +import org.acejump.input.KeyLayoutCache -class AceConfigurable: Configurable { - private val logger = Logger.getInstance(AceConfigurable::class.java) - - private val panel by lazy { AceSettingsPanel() } - +class AceConfigurable : Configurable { + private val panel by lazy(::AceSettingsPanel) + override fun getDisplayName() = "AceJump" - + override fun createComponent() = panel.rootPanel - + override fun isModified() = panel.allowedChars != settings.allowedChars || panel.keyboardLayout != settings.layout || @@ -29,37 +26,26 @@ class AceConfigurable: Configurable { panel.tagForegroundColor != settings.tagForegroundColor || panel.tagBackgroundColor != settings.tagBackgroundColor || panel.roundedTagCorners != settings.roundedTagCorners || - panel.searchWholeFile != settings.searchWholeFile || - panel.supportPinyin != settings.supportPinyin - - private fun String.distinctAlphanumerics() = - if (isEmpty()) settings.layout.text - else toList().distinct().filter(Char::isLetterOrDigit).joinToString("") - + panel.searchWholeFile != settings.searchWholeFile + override fun apply() { - panel.allowedChars.distinctAlphanumerics().let { - settings.allowedChars = it - AceConfig.allPossibleTags = it.bigrams() - } - + settings.allowedChars = panel.allowedChars settings.layout = panel.keyboardLayout settings.cycleMode1 = panel.cycleMode1 settings.cycleMode2 = panel.cycleMode2 settings.cycleMode3 = panel.cycleMode3 settings.cycleMode4 = panel.cycleMode4 - panel.jumpModeColor ?.let { settings.jumpModeColor = it } + panel.jumpModeColor?.let { settings.jumpModeColor = it } panel.jumpEndModeColor?.let { settings.jumpEndModeColor = it } - panel.targetModeColor ?.let { settings.targetModeColor = it } - panel.definitionModeColor ?.let { settings.definitionModeColor = it } - panel.textHighlightColor ?.let { settings.textHighlightColor = it } - panel.tagForegroundColor ?.let { settings.tagForegroundColor = it } - panel.tagBackgroundColor ?.let { settings.tagBackgroundColor = it } + panel.targetModeColor?.let { settings.targetModeColor = it } + panel.definitionModeColor?.let { settings.definitionModeColor = it } + panel.textHighlightColor?.let { settings.textHighlightColor = it } + panel.tagForegroundColor?.let { settings.tagForegroundColor = it } + panel.tagBackgroundColor?.let { settings.tagBackgroundColor = it } settings.roundedTagCorners = panel.roundedTagCorners settings.searchWholeFile = panel.searchWholeFile - settings.supportPinyin = panel.supportPinyin - - logger.info("User applied new settings: $settings") + KeyLayoutCache.reset(settings) } - + override fun reset() = panel.reset(settings) -} \ No newline at end of file +} diff --git a/src/main/kotlin/org/acejump/config/AceSettings.kt b/src/main/kotlin/org/acejump/config/AceSettings.kt index 4fa1c54a..2fc97815 100644 --- a/src/main/kotlin/org/acejump/config/AceSettings.kt +++ b/src/main/kotlin/org/acejump/config/AceSettings.kt @@ -1,47 +1,40 @@ package org.acejump.config import com.intellij.util.xmlb.annotations.OptionTag -import org.acejump.label.Pattern.Companion.KeyLayout -import org.acejump.label.Pattern.Companion.KeyLayout.QWERTY -import org.acejump.search.JumpMode +import org.acejump.input.JumpMode +import org.acejump.input.KeyLayout +import org.acejump.input.KeyLayout.QWERTY import java.awt.Color -/** - * Settings model located for [AceSettingsPanel]. - */ - -// TODO: https://github.com/acejump/AceJump/issues/215 data class AceSettings( var layout: KeyLayout = QWERTY, - var allowedChars: String = layout.text, + var allowedChars: String = layout.allChars, var cycleMode1: JumpMode = JumpMode.JUMP, var cycleMode2: JumpMode = JumpMode.DEFINE, var cycleMode3: JumpMode = JumpMode.TARGET, var cycleMode4: JumpMode = JumpMode.JUMP_END, - + @OptionTag("jumpModeRGB", converter = ColorConverter::class) var jumpModeColor: Color = Color.BLUE, - + @OptionTag("jumpEndModeRGB", converter = ColorConverter::class) var jumpEndModeColor: Color = Color.CYAN, - + @OptionTag("targetModeRGB", converter = ColorConverter::class) var targetModeColor: Color = Color.RED, - + @OptionTag("definitionModeRGB", converter = ColorConverter::class) var definitionModeColor: Color = Color.MAGENTA, - + @OptionTag("textHighlightRGB", converter = ColorConverter::class) var textHighlightColor: Color = Color.GREEN, - + @OptionTag("tagForegroundRGB", converter = ColorConverter::class) var tagForegroundColor: Color = Color.BLACK, - + @OptionTag("tagBackgroundRGB", converter = ColorConverter::class) var tagBackgroundColor: Color = Color.YELLOW, - - var displayQuery: Boolean = false, + var roundedTagCorners: Boolean = true, - var searchWholeFile: Boolean = true, - var supportPinyin: Boolean = false -) \ No newline at end of file + var searchWholeFile: Boolean = true +) diff --git a/src/main/kotlin/org/acejump/config/AceSettingsPanel.kt b/src/main/kotlin/org/acejump/config/AceSettingsPanel.kt index 3b200c6d..e2ff2e64 100644 --- a/src/main/kotlin/org/acejump/config/AceSettingsPanel.kt +++ b/src/main/kotlin/org/acejump/config/AceSettingsPanel.kt @@ -9,9 +9,8 @@ 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.label.Pattern.Companion.KeyLayout -import org.acejump.search.JumpMode -import org.acejump.search.aceString +import org.acejump.input.JumpMode +import org.acejump.input.KeyLayout import java.awt.Color import java.awt.Font import javax.swing.JCheckBox @@ -23,11 +22,11 @@ import kotlin.reflect.KProperty /** * Settings view located in File | Settings | Tools | AceJump. */ - +@Suppress("UsePropertyAccessSyntax") internal class AceSettingsPanel { private val tagCharsField = JBTextField() private val keyboardLayoutCombo = ComboBox() - private val keyboardLayoutArea = JBTextArea() + private val keyboardLayoutArea = JBTextArea().apply { isEditable = false } private val cycleModeCombo1 = ComboBox() private val cycleModeCombo2 = ComboBox() private val cycleModeCombo3 = ComboBox() @@ -39,57 +38,31 @@ internal class AceSettingsPanel { private val textHighlightColorWheel = ColorPanel() private val tagForegroundColorWheel = ColorPanel() private val tagBackgroundColorWheel = ColorPanel() - private val displayQueryCheckBox = JBCheckBox().apply { isEnabled = false } private val roundedTagCornersCheckBox = JBCheckBox() private val searchWholeFileCheckBox = JBCheckBox() - private val supportPinyinCheckBox = JBCheckBox() - + init { tagCharsField.apply { font = Font("monospaced", font.style, font.size) } - keyboardLayoutArea.apply { - font = Font("monospaced", font.style, font.size) - isEditable = false - } - - keyboardLayoutCombo.run { - KeyLayout.values().forEach { addItem(it) } - addActionListener { keyChars = (selectedItem as KeyLayout).joinBy("\n") } - } - - cycleModeCombo1.run { - JumpMode.values().forEach { addItem(it) } - addActionListener { cycleMode1 = selectedItem as JumpMode } - } - - cycleModeCombo2.run { - JumpMode.values().forEach { addItem(it) } - addActionListener { cycleMode2 = selectedItem as JumpMode } - } - - cycleModeCombo3.run { - JumpMode.values().forEach { addItem(it) } - addActionListener { cycleMode3 = selectedItem as JumpMode } - } - - cycleModeCombo4.run { - JumpMode.values().forEach { addItem(it) } - addActionListener { cycleMode4 = selectedItem as JumpMode } - } + keyboardLayoutArea.apply { font = Font("monospaced", font.style, font.size) } + keyboardLayoutCombo.setupEnumItems { keyChars = it.rows.joinToString("\n") } + cycleModeCombo1.setupEnumItems { cycleMode1 = it } + cycleModeCombo2.setupEnumItems { cycleMode2 = it } + cycleModeCombo3.setupEnumItems { cycleMode3 = it } + cycleModeCombo4.setupEnumItems { cycleMode4 = it } } - - // https://github.com/JetBrains/intellij-community/blob/master/platform/platform-impl/src/com/intellij/ui/layout/readme.md + internal val rootPanel: JPanel = panel { fun Cell.short(component: JComponent) = component(growPolicy = SHORT_TEXT) fun Cell.medium(component: JComponent) = component(growPolicy = MEDIUM_TEXT) - - titledRow(aceString("charactersAndLayoutHeading")) { - row(aceString("tagCharsToBeUsedLabel")) { medium(tagCharsField) } - row(aceString("keyboardLayoutLabel")) { short(keyboardLayoutCombo) } - row(aceString("keyboardDesignLabel")) { short(keyboardLayoutArea) } + + titledRow("Characters and Layout") { + row("Allowed characters in tags:") { medium(tagCharsField) } + row("Keyboard layout:") { short(keyboardLayoutCombo) } + row("Keyboard design:") { short(keyboardLayoutArea) } } - - titledRow(aceString("modesHeading")) { - row(aceString("cycleModeOrderLabel")) { + + titledRow("Modes") { + row("Cycle order:") { cell(isVerticalFlow = false, isFullWidth = false) { cycleModeCombo1() cycleModeCombo2() @@ -98,29 +71,26 @@ internal class AceSettingsPanel { } } } - - titledRow(aceString("colorsHeading")) { - row(aceString("jumpModeColorLabel")) { short(jumpModeColorWheel) } - row(aceString("jumpEndModeColorLabel")) { short(jumpEndModeColorWheel) } - row(aceString("targetModeColorLabel")) { short(targetModeColorWheel) } - row(aceString("definitionModeColorLabel")) { short(definitionModeColorWheel) } - row(aceString("textHighlightColorLabel")) { short(textHighlightColorWheel) } - row(aceString("tagForegroundColorLabel")) { short(tagForegroundColorWheel) } - row(aceString("tagBackgroundColorLabel")) { short(tagBackgroundColorWheel) } + + titledRow("Colors") { + row("Jump mode caret background:") { short(jumpModeColorWheel) } + row("Jump to End mode caret background:") { short(jumpEndModeColorWheel) } + row("Target mode caret background:") { short(targetModeColorWheel) } + row("Definition mode caret background:") { short(definitionModeColorWheel) } + row("Searched text background:") { short(textHighlightColorWheel) } + row("Tag foreground:") { short(tagForegroundColorWheel) } + row("Tag background:") { short(tagBackgroundColorWheel) } } - - titledRow(aceString("appearanceHeading")) { - row { short(displayQueryCheckBox.apply { text = aceString("displayQueryLabel") }) } - row { short(roundedTagCornersCheckBox.apply { text = aceString("roundedTagCornersLabel") }) } + + titledRow("Appearance") { + row { short(roundedTagCornersCheckBox.apply { text = "Rounded tag corners" }) } } - - titledRow(aceString("behaviorHeading")) { - row { short(searchWholeFileCheckBox.apply { text = aceString("searchWholeFileLabel") }) } - row { short(supportPinyinCheckBox.apply { text = aceString("supportPinyin") }) } + + titledRow("Behavior") { + row { short(searchWholeFileCheckBox.apply { text = "Search whole file" }) } } } - - + // Property-to-property delegation: https://stackoverflow.com/q/45074596/1772342 internal var allowedChars by tagCharsField internal var keyboardLayout by keyboardLayoutCombo @@ -136,11 +106,9 @@ internal class AceSettingsPanel { internal var textHighlightColor by textHighlightColorWheel internal var tagForegroundColor by tagForegroundColorWheel internal var tagBackgroundColor by tagBackgroundColorWheel - internal var displayQuery by displayQueryCheckBox internal var roundedTagCorners by roundedTagCornersCheckBox internal var searchWholeFile by searchWholeFileCheckBox - internal var supportPinyin by supportPinyinCheckBox - + fun reset(settings: AceSettings) { allowedChars = settings.allowedChars keyboardLayout = settings.layout @@ -155,22 +123,26 @@ internal class AceSettingsPanel { textHighlightColor = settings.textHighlightColor tagForegroundColor = settings.tagForegroundColor tagBackgroundColor = settings.tagBackgroundColor - displayQuery = settings.displayQuery roundedTagCorners = settings.roundedTagCorners searchWholeFile = settings.searchWholeFile - supportPinyin = settings.supportPinyin } - + // Removal pending support for https://youtrack.jetbrains.com/issue/KT-8575 + 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 private operator fun ColorPanel.setValue(a: AceSettingsPanel, p: KProperty<*>, c: Color?) = setSelectedColor(c) - + private operator fun JCheckBox.getValue(a: AceSettingsPanel, p: KProperty<*>) = isSelected private operator fun JCheckBox.setValue(a: AceSettingsPanel, p: KProperty<*>, selected: Boolean) = setSelected(selected) - + private operator fun ComboBox.getValue(a: AceSettingsPanel, p: KProperty<*>) = selectedItem as T private operator fun ComboBox.setValue(a: AceSettingsPanel, p: KProperty<*>, item: T) = setSelectedItem(item) -} \ No newline at end of file + + private inline fun > ComboBox.setupEnumItems(crossinline onChanged: (T) -> Unit) { + T::class.java.enumConstants.forEach(this::addItem) + addActionListener { onChanged(selectedItem as T) } + } +} diff --git a/src/main/kotlin/org/acejump/config/ColorConverter.kt b/src/main/kotlin/org/acejump/config/ColorConverter.kt index 238cc460..a7e42478 100644 --- a/src/main/kotlin/org/acejump/config/ColorConverter.kt +++ b/src/main/kotlin/org/acejump/config/ColorConverter.kt @@ -3,12 +3,12 @@ package org.acejump.config import com.intellij.util.xmlb.Converter import java.awt.Color -class ColorConverter : Converter() { +internal class ColorConverter : Converter() { override fun toString(value: Color): String { return value.rgb.toString() } - + override fun fromString(value: String): Color? { return value.toIntOrNull()?.let(::Color) } -} \ No newline at end of file +} diff --git a/src/main/kotlin/org/acejump/control/AceAction.kt b/src/main/kotlin/org/acejump/control/AceAction.kt deleted file mode 100755 index b3b796a2..00000000 --- a/src/main/kotlin/org/acejump/control/AceAction.kt +++ /dev/null @@ -1,90 +0,0 @@ -package org.acejump.control - -import com.intellij.openapi.actionSystem.AnActionEvent -import com.intellij.openapi.actionSystem.CommonDataKeys.EDITOR -import com.intellij.openapi.diagnostic.Logger -import com.intellij.openapi.project.DumbAwareAction -import org.acejump.control.Handler.regexSearch -import org.acejump.label.Pattern -import org.acejump.label.Pattern.ALL_WORDS -import org.acejump.search.JumpMode -import org.acejump.search.Jumper -import org.acejump.search.getNameOfFileInEditor -import org.acejump.view.Boundary.* -import org.acejump.view.Model.boundaries -import org.acejump.view.Model.defaultBoundary -import org.acejump.view.Model.editor - -/** - * Entry point for all actions. The IntelliJ Platform calls AceJump here. - */ - -open class AceAction: DumbAwareAction() { - open val logger = Logger.getInstance(javaClass) - override fun update(action: AnActionEvent) { - action.presentation.isEnabled = action.getData(EDITOR) != null - } - - override fun actionPerformed(e: AnActionEvent) { - editor = e.getData(EDITOR) ?: return - boundaries = defaultBoundary - val textLength = editor.document.textLength - logger.info("Invoked on ${editor.getNameOfFileInEditor()} ($textLength)") - Handler.activate() - customize() - } - - open fun customize() = Jumper.cycleMode() -} - -/** - * When target mode is activated, selecting a tag will highlight an entire word. - */ - -class AceTargetAction: AceAction() { - override fun customize() = Jumper.toggleMode(JumpMode.TARGET) -} - -/* - * When line mode is activated, we will tag the beginning and end of each line. - * - * TODO: https://github.com/acejump/AceJump/issues/327 - * TODO: https://github.com/acejump/AceJump/issues/340 - */ - -class AceLineAction: AceAction() { - override fun customize() = regexSearch(Pattern.LINE_MARK) -} - -/** - * When declaration mode is activated, selecting a tag will take us to the - * definition (i.e. declaration) of the token in the editor, if it exists. - */ - -class AceDefinitionAction: AceAction() { - override fun customize() = Jumper.toggleMode(JumpMode.DEFINE) -} - -/** - * When word mode is activated, we will tag all words on the screen. - */ - -class AceWordAction: AceAction() { - override fun customize() = regexSearch(ALL_WORDS, SCREEN_BOUNDARY) -} - -/** - * Search for words from the start of the screen to the caret - */ - -class AceWordForwardAction: AceAction() { - override fun customize() = regexSearch(ALL_WORDS, AFTER_CARET_BOUNDARY) -} - -/** - * Search for words from the caret position to the start of the screen - */ - -class AceWordBackwardsAction: AceAction() { - override fun customize() = regexSearch(ALL_WORDS, BEFORE_CARET_BOUNDARY) -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/control/AceSearchSession.kt b/src/main/kotlin/org/acejump/control/AceSearchSession.kt deleted file mode 100644 index 980a3086..00000000 --- a/src/main/kotlin/org/acejump/control/AceSearchSession.kt +++ /dev/null @@ -1,22 +0,0 @@ -package org.acejump.control - -import com.intellij.find.EditorSearchSession -import com.intellij.find.impl.livePreview.SearchResults -import com.intellij.openapi.actionSystem.AnAction -import com.intellij.openapi.editor.Editor -import org.acejump.search.AceFindModel - -class AceSearchSession(editor: Editor, findModel: AceFindModel): - EditorSearchSession(editor, editor.project, findModel) { - init { - editor.headerComponent = component - } - - override fun searchResultsUpdated(sr: SearchResults) { - super.searchResultsUpdated(sr) - } - - override fun createPrimarySearchActions(): Array { - return super.createPrimarySearchActions() - } -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/control/Handler.kt b/src/main/kotlin/org/acejump/control/Handler.kt deleted file mode 100755 index bad4964f..00000000 --- a/src/main/kotlin/org/acejump/control/Handler.kt +++ /dev/null @@ -1,207 +0,0 @@ -package org.acejump.control - -import com.intellij.openapi.actionSystem.DataContext -import com.intellij.openapi.actionSystem.IdeActions.* -import com.intellij.openapi.diagnostic.Logger -import com.intellij.openapi.editor.Caret -import com.intellij.openapi.editor.Editor -import com.intellij.openapi.editor.actionSystem.EditorActionHandler -import com.intellij.openapi.editor.actionSystem.EditorActionManager -import com.intellij.openapi.editor.actionSystem.TypedAction -import com.intellij.openapi.editor.actionSystem.TypedActionHandler -import com.intellij.openapi.editor.colors.EditorColors.CARET_COLOR -import com.intellij.openapi.editor.colors.EditorColors.TEXT_SEARCH_RESULT_ATTRIBUTES -import com.intellij.openapi.editor.colors.EditorColorsManager -import com.intellij.util.containers.ContainerUtil -import org.acejump.control.Scroller.restoreScroll -import org.acejump.control.Scroller.saveScroll -import org.acejump.label.Pattern -import org.acejump.label.Pattern.* -import org.acejump.label.Tagger -import org.acejump.search.* -import org.acejump.view.Boundary -import org.acejump.view.Boundary.FULL_FILE_BOUNDARY -import org.acejump.view.Canvas -import org.acejump.view.Canvas.bindCanvas -import org.acejump.view.Model -import org.acejump.view.Model.editor -import org.acejump.view.Model.setupCaret -import java.awt.Color - -/** - * Handles all incoming keystrokes, IDE notifications, and UI updates. - */ - -object Handler : TypedActionHandler, Resettable { - private val listeners: MutableList = ContainerUtil.createLockFreeCopyOnWriteList() - private val logger = Logger.getInstance(Handler::class.java) - private var enabled = false - private val typingAction = TypedAction.getInstance() - private val oldHandler = typingAction.rawHandler - - private val editorActionMap = mutableMapOf( - ACTION_EDITOR_BACKSPACE to makeHandler { clear() }, - ACTION_EDITOR_START_NEW_LINE to makeHandler { Selector.select(false) }, - ACTION_EDITOR_ENTER to makeHandler { Selector.select() }, - ACTION_EDITOR_TAB to makeHandler { Scroller.scroll(true) }, - ACTION_EDITOR_PREV_PARAMETER to makeHandler { Scroller.scroll(false) }, - ACTION_EDITOR_MOVE_CARET_UP to makeHandler { regexSearch(CODE_INDENTS) }, - ACTION_EDITOR_MOVE_CARET_LEFT to makeHandler { regexSearch(START_OF_LINE) }, - ACTION_EDITOR_MOVE_CARET_RIGHT to makeHandler { regexSearch(END_OF_LINE) }, - ACTION_EDITOR_MOVE_LINE_START to makeHandler { regexSearch(START_OF_LINE) }, - ACTION_EDITOR_MOVE_LINE_END to makeHandler { regexSearch(END_OF_LINE) }, - ACTION_EDITOR_ESCAPE to makeHandler { reset() } - ) - - private fun makeHandler(handle: () -> Unit) = object : EditorActionHandler() { - override fun doExecute(e: Editor, c: Caret?, dc: DataContext?) = handle() - } - - @ExternalUsage - fun regexSearch(regex: Pattern, bounds: Boundary = FULL_FILE_BOUNDARY) = - Canvas.reset().also { Finder.search(regex, bounds) } - - @ExternalUsage - fun customRegexSearch(regex: String, bounds: Boundary = FULL_FILE_BOUNDARY) = - Canvas.reset().also { Finder.search(regex, bounds) } - - fun activate() = if (!enabled) configureEditor() else { } - - private fun clear() { - applyTo(Tagger, Jumper, Finder, Canvas) { reset() } - repaintTagMarkers() - } - - private fun installKeyHandler() = typingAction.setupRawHandler(this) - private fun uninstallKeyHandler() = typingAction.setupRawHandler(oldHandler) - - /** - * TODO: Integrate query highlighting with [AceSearchSession] - */ - - var session: AceSearchSession? = null - override fun execute(editor: Editor, key: Char, dataContext: DataContext) { - logger.info("Intercepted keystroke: $key") - Finder.query += key // This will trigger an update - -// if (session == null) -// session = AceSearchSession(editor, AceFindModel(key.toString())) -// else session?.findModel!!.stringToFind += key - } - - private fun configureEditor() = - editor.run { - enabled = true - saveScroll() - saveCaret() - saveColors() - runNow { - setupCaret() - bindCanvas() - swapActionHandler() - installKeyHandler() - Listener.enable() - } - } - - private fun swapActionHandler() = EditorActionManager.getInstance().run { - editorActionMap.forEach { (actionId, handler) -> - editorActionMap[actionId] = getActionHandler(actionId) - setActionHandler(actionId, handler) - } - } - - fun repaintTagMarkers() { - if (Tagger.tagSelected) reset() else Canvas.jumpLocations = Tagger.markers - } - - fun redoFind() { - runNow { - editor.run { - restoreCanvas() - bindCanvas() - } - } - - if (Finder.query.isNotEmpty() || Tagger.regex) { - Finder.search() - repaintTagMarkers() - } - } - - override fun reset() { - if (enabled) Listener.disable() - session = null - - // In order to get Finder.query value, listeners should - // be placed before cleanup - listeners.forEach(AceJumpListener::finished) - clear() - editor.restoreSettings() - } - - @ExternalUsage - fun addAceJumpListener(listener: AceJumpListener) { - listeners += listener - } - - @ExternalUsage - fun removeAceJumpListener(listener: AceJumpListener) { - listeners -= listener - } - - private fun Editor.restoreSettings() = runNow { - enabled = false - swapActionHandler() - uninstallKeyHandler() - if(!isDisposed) { - restoreScroll() - restoreCanvas() - restoreCaret() - restoreColors() - } - } - - private fun Editor.restoreCanvas() = - contentComponent.run { - remove(Canvas) - repaint() - } - - private fun saveCaret() { - editor.settings.run { - Model.naturalBlock = isBlockCursor - Model.naturalBlink = isBlinkCaret - } - - editor.caretModel.primaryCaret.visualAttributes.run { - Model.naturalCaretColor = color - ?: EditorColorsManager.getInstance().globalScheme.getColor(CARET_COLOR) - ?: Color.BLACK - } - } - - private fun saveColors() = - EditorColorsManager.getInstance().globalScheme - .getAttributes(TEXT_SEARCH_RESULT_ATTRIBUTES) - ?.backgroundColor.let { Model.naturalHighlight = it } - - private fun Editor.restoreCaret() = - runNow { - settings.isBlinkCaret = Model.naturalBlink - settings.isBlockCursor = Model.naturalBlock - } - - private fun Editor.restoreColors() = - runNow { - colorsScheme.run { - setAttributes(TEXT_SEARCH_RESULT_ATTRIBUTES, - getAttributes(TEXT_SEARCH_RESULT_ATTRIBUTES) - .apply { backgroundColor = Model.naturalHighlight }) - } - } - - interface AceJumpListener { - fun finished() {} - } -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/control/Listener.kt b/src/main/kotlin/org/acejump/control/Listener.kt deleted file mode 100644 index cd22a4bc..00000000 --- a/src/main/kotlin/org/acejump/control/Listener.kt +++ /dev/null @@ -1,92 +0,0 @@ -package org.acejump.control - -import com.intellij.openapi.diagnostic.Logger -import com.intellij.openapi.editor.event.VisibleAreaEvent -import com.intellij.openapi.editor.event.VisibleAreaListener -import org.acejump.control.Handler.redoFind -import org.acejump.label.Tagger -import org.acejump.search.getView -import org.acejump.view.Model.editor -import org.acejump.view.Model.viewBounds -import java.awt.event.FocusEvent -import java.awt.event.FocusListener -import javax.swing.event.AncestorEvent -import javax.swing.event.AncestorListener -import kotlin.system.measureTimeMillis - -/** - * Callback for GUI updates (e.g. resize, scroll). Ensures tags are painted to - * the screen whenever the view changes. Since visible tags are prioritized, - * there may be tags off-screen which have not yet been painted. - */ - -internal object Listener: FocusListener, AncestorListener, VisibleAreaListener { - private val logger = Logger.getInstance(Listener::class.java) - private val redoFindTrigger = Trigger() - - fun enable() = - // TODO: Do we really need `synchronized` here? - synchronized(this) { - editor.run { - component.addFocusListener(Listener) - component.addAncestorListener(Listener) - scrollingModel.addVisibleAreaListener(Listener) - } - } - - fun disable() = - // TODO: Do we really need `synchronized` here? - synchronized(this) { - editor.run { - component.removeFocusListener(Listener) - component.removeAncestorListener(Listener) - scrollingModel.removeVisibleAreaListener(Listener) - } - } - - /** - * This callback is very jittery. We need to delay repainting tags by a short - * duration [Trigger] in order to prevent flashing tag syndrome. - */ - - override fun visibleAreaChanged(e: VisibleAreaEvent) { - var elapsed = measureTimeMillis { - if (canTagsSurviveViewResize()) { - viewBounds = editor.getView() - return - } - } - elapsed = (350L - elapsed).coerceAtLeast(0L) - redoFindTrigger(withDelay = elapsed) { - logger.info("Visible area changed") - redoFind() - } - } - - private fun canTagsSurviveViewResize() = - editor.getView().run { - if (first in viewBounds && last in viewBounds) return true - else if (Tagger.full) return true - else if (Tagger.regex) return false - else !Tagger.hasMatchBetweenOldAndNewView(viewBounds, this) - } - - override fun ancestorMoved(ancestorEvent: AncestorEvent?) { - if (!canTagsSurviveViewResize()) { - logger.info("Ancestor moved: $ancestorEvent") - Handler.reset() - } - } - - override fun ancestorAdded(ancestorEvent: AncestorEvent?) = - logger.info("Ancestor added: $ancestorEvent").also { Handler.reset() } - - override fun ancestorRemoved(ancestorEvent: AncestorEvent?) = - logger.info("Ancestor removed: $ancestorEvent").also { Handler.reset() } - - override fun focusLost(focusEvent: FocusEvent?) = - logger.info("Focus lost: $focusEvent").also { Handler.reset() } - - override fun focusGained(focusEvent: FocusEvent?) = - logger.info("Focus gained: $focusEvent").also { Handler.reset() } -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/control/Scroller.kt b/src/main/kotlin/org/acejump/control/Scroller.kt deleted file mode 100644 index fbe8f5b9..00000000 --- a/src/main/kotlin/org/acejump/control/Scroller.kt +++ /dev/null @@ -1,101 +0,0 @@ -package org.acejump.control - -import com.intellij.openapi.diagnostic.Logger -import com.intellij.openapi.editor.Editor -import com.intellij.openapi.editor.LogicalPosition -import com.intellij.openapi.editor.ScrollType.CENTER -import com.intellij.openapi.editor.ScrollType.MAKE_VISIBLE -import org.acejump.label.Tagger.textMatches -import org.acejump.search.* -import org.acejump.view.Model.editor -import org.acejump.view.Model.viewBounds - -/** - * Updates the editor's vertical scroll position to make search results visible. - * This will occur when the user presses TAB OR searches for text which does not - * currently appear on the screen. Once scrolling is complete, the [Listener] - * will [Trigger] an update that re-paint tags to the screen. - */ - -object Scroller { - private val logger = Logger.getInstance(Scroller::class.java) - private var scrollX = 0 - private var scrollY = 0 - - fun scroll(forward: Boolean = true): Boolean { - logger.info("Scrolling to ${if (forward) "next" else "previous"} match") - val position = if (forward) findNextPosition() else findPreviousPosition() - return if (position != null) true.also { scrollTo(position) } - else false.also { logger.info("No result found") } - } - - private fun scrollTo(position: LogicalPosition) = editor.run { - scrollingModel.disableAnimation() - scrollingModel.scrollTo(position, CENTER) - - val firstInView = textMatches.first { it in getView() } - val horizontalOffset = offsetToLogicalPosition(firstInView).column - if (horizontalOffset > scrollingModel.visibleArea.width) - scrollingModel.scrollHorizontally(horizontalOffset) - - viewBounds = getView() - } - - fun ensureCaretVisible() = editor.scrollingModel.run { - val initialArea = visibleArea - scrollToCaret(MAKE_VISIBLE) - visibleArea == initialArea - } - - private fun findPreviousPosition(): LogicalPosition? { - val prevIndex = textMatches.toList().dropLastWhile { it > viewBounds.first } - .lastOrNull() ?: textMatches.lastOrNull() ?: return null - - val prevLineNum = editor.offsetToLogicalPosition(prevIndex).line - - // Try to capture as many previous results as will fit in a screenful - fun maximizeCoverageOfPreviousOccurrence(): LogicalPosition { - val minVisibleLine = prevLineNum - editor.getScreenHeight() - val firstVisibleIndex = editor.getLineStartOffset(minVisibleLine) - val firstIndex = textMatches.dropWhile { it < firstVisibleIndex }.first() - return editor.offsetCenter(firstIndex, prevIndex) - } - - return maximizeCoverageOfPreviousOccurrence() - } - - /** - * Returns the center of the next set of results that will fit in the editor. - * [textMatches] must be sorted prior to using Scroller. If [textMatches] have - * not previously been sorted, the result of calling this method is undefined. - */ - - private fun findNextPosition(): LogicalPosition? { - val nextIndex = textMatches.dropWhile { it <= viewBounds.last } - .firstOrNull() ?: textMatches.firstOrNull() ?: return null - - val nextLineNum = editor.offsetToLogicalPosition(nextIndex).line - - // Try to capture as many subsequent results as will fit in a screenful - fun maximizeCoverageOfNextOccurrence(): LogicalPosition { - val maxVisibleLine = nextLineNum + editor.getScreenHeight() - val lastVisibleIndex = editor.getLineEndOffset(maxVisibleLine, true) - val lastIndex = textMatches.toList().dropLastWhile { it > lastVisibleIndex }.last() - return editor.offsetCenter(nextIndex, lastIndex) - } - - return maximizeCoverageOfNextOccurrence() - } - - fun Editor.saveScroll() { - scrollX = scrollingModel.horizontalScrollOffset - scrollY = scrollingModel.verticalScrollOffset - } - - fun Editor.restoreScroll() { - if (caretModel.offset !in getView()) { - scrollingModel.scrollVertically(scrollY) - scrollingModel.scrollHorizontally(scrollX) - } - } -} diff --git a/src/main/kotlin/org/acejump/control/Selector.kt b/src/main/kotlin/org/acejump/control/Selector.kt deleted file mode 100644 index fc7d137f..00000000 --- a/src/main/kotlin/org/acejump/control/Selector.kt +++ /dev/null @@ -1,31 +0,0 @@ -package org.acejump.control - -import org.acejump.search.Finder -import org.acejump.search.Jumper -import org.acejump.view.Model.caretOffset - -/** - * Supports cyclical selection of tags using the ENTER/SHIFT+ENTER keys. - * - * @see [Handler.editorActionMap] - */ - -object Selector { - fun select(forward: Boolean = true) { - val matches = nearestVisibleMatches(forward) - matches.ifEmpty { return } - Jumper.jumpTo(matches.first(), false) - val wasAlreadyVisible = Scroller.ensureCaretVisible() - if (matches.size == 1 && wasAlreadyVisible) Handler.reset() - } - - fun nearestVisibleMatches(forward: Boolean = true): List { - val caretOffset = caretOffset - - return Finder.visibleResults().sortedWith(compareBy( - { it == caretOffset }, - { (it <= caretOffset) == forward }, - { if (forward) it - caretOffset else caretOffset - it } - )) - } -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/control/Trigger.kt b/src/main/kotlin/org/acejump/control/Trigger.kt deleted file mode 100644 index a57bf355..00000000 --- a/src/main/kotlin/org/acejump/control/Trigger.kt +++ /dev/null @@ -1,41 +0,0 @@ -package org.acejump.control - -import com.intellij.openapi.diagnostic.Logger -import org.acejump.search.runLater -import java.util.concurrent.Executors -import java.util.concurrent.Future -import java.util.concurrent.TimeUnit - -/** - * Timer for triggering events with a designated delay. - */ - -class Trigger { - private companion object { - private val executor = Executors.newSingleThreadScheduledExecutor() - } - - private val logger = Logger.getInstance(Trigger::class.java) - private var task: Future<*>? = null - - /** - * Can be called multiple times inside [delay], but doing so will reset the - * timer, delaying the [event] from occurring by [withDelay] milliseconds. - */ - - @Synchronized - operator fun invoke(withDelay: Long, event: () -> Unit = {}) { - task?.cancel(true) - task = executor.schedule({ - runLater { - try { - event() - } catch (e: Exception) { - logger.error("Exception occurred while triggering event!", e) - } finally { - task = null - } - } - }, withDelay, TimeUnit.MILLISECONDS) - } -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/input/EditorKeyListener.kt b/src/main/kotlin/org/acejump/input/EditorKeyListener.kt new file mode 100644 index 00000000..ced90846 --- /dev/null +++ b/src/main/kotlin/org/acejump/input/EditorKeyListener.kt @@ -0,0 +1,38 @@ +package org.acejump.input + +import com.intellij.openapi.actionSystem.DataContext +import com.intellij.openapi.editor.Editor +import com.intellij.openapi.editor.actionSystem.TypedAction +import com.intellij.openapi.editor.actionSystem.TypedActionHandler + +/** + * If at least one session exists, this listener redirects all characters, typed in [Editor]s with attached sessions, to the appropriate + * sessions' own handlers. + */ +internal object EditorKeyListener : TypedActionHandler { + private val action = TypedAction.getInstance() + private val attached = mutableMapOf() + private var originalHandler: TypedActionHandler? = null + + override fun execute(editor: Editor, charTyped: Char, dataContext: DataContext) { + (attached[editor] ?: originalHandler ?: return).execute(editor, charTyped, dataContext) + } + + fun attach(editor: Editor, callback: TypedActionHandler) { + if (attached.isEmpty()) { + originalHandler = action.rawHandler + action.setupRawHandler(this) + } + + attached[editor] = callback + } + + fun detach(editor: Editor) { + attached.remove(editor) + + if (attached.isEmpty()) { + originalHandler?.let(action::setupRawHandler) + originalHandler = null + } + } +} diff --git a/src/main/kotlin/org/acejump/input/JumpMode.kt b/src/main/kotlin/org/acejump/input/JumpMode.kt new file mode 100644 index 00000000..87d1279f --- /dev/null +++ b/src/main/kotlin/org/acejump/input/JumpMode.kt @@ -0,0 +1,68 @@ +package org.acejump.input + +import com.intellij.openapi.editor.colors.impl.AbstractColorsScheme +import org.acejump.config.AceConfig +import java.awt.Color + +/** + * Describes modes that determine the behavior of a "jump" to a tag. Most modes have two variations: + * - **Default jump** happens when jumping without holding the Shift key + * - **Shift jump** happens when jumping while holding the Shift key + */ +enum class JumpMode { + /** + * Default value at the start of a session. If the session does not get assigned a proper [JumpMode] by the time the user requests a jump, + * the results of the jump are undefined. + */ + DISABLED, + + /** + * On default jump, places the caret at the first character of the search query. + * On shift jump, does the above but also selects all text between the original and new caret positions. + */ + JUMP, + + /** + * On default jump, places the caret at the end of a word. Word detection uses [Character.isJavaIdentifierPart] to count some special + * characters, such as underscores, as part of a word. If there is no word at the first character of the search query, then the caret is + * placed after the last character of the search query. + * + * On shift jump, does the above but also selects all text between the original and new caret positions. + */ + JUMP_END, + + /** + * On default jump, places the caret at the end of a word, and also selects the entire word. Word detection uses + * [Character.isJavaIdentifierPart] to count some special characters, such as underscores, as part of a word. If there is no word at the + * first character of the search query, then the caret is placed after the last character of the search query, and all text between the + * start and end of the search query is selected. + * + * On shift jump, does the above but also selects all text between the original caret position and the new selection, merging the + * selections into one. + */ + TARGET, + + /** + * On default jump, performs the Go To Declaration action, available via `Navigate | Declaration or Usages`. + * On shift jump, performs the Go To Type Declaration action, available via `Navigate | Type Declaration`. + * Always places the caret at the first character of the search query. + */ + DEFINE; + + val caretColor: Color + get() = when (this) { + JUMP -> AceConfig.jumpModeColor + JUMP_END -> AceConfig.jumpEndModeColor + DEFINE -> AceConfig.definitionModeColor + TARGET -> AceConfig.targetModeColor + DISABLED -> AbstractColorsScheme.INHERITED_COLOR_MARKER + } + + override fun toString() = when (this) { + DISABLED -> "(Skip)" + JUMP -> "Jump" + JUMP_END -> "Jump to End" + TARGET -> "Target" + DEFINE -> "Definition" + } +} diff --git a/src/main/kotlin/org/acejump/input/JumpModeTracker.kt b/src/main/kotlin/org/acejump/input/JumpModeTracker.kt new file mode 100644 index 00000000..3a7e7ab8 --- /dev/null +++ b/src/main/kotlin/org/acejump/input/JumpModeTracker.kt @@ -0,0 +1,48 @@ +package org.acejump.input + +import org.acejump.config.AceConfig + +/** + * Remembers the current [JumpMode] for a session. Allows cycling [JumpMode]s according to the order defined in configuration, or toggling + * one specific [JumpMode] on or off. + */ +internal class JumpModeTracker { + private var currentMode = JumpMode.DISABLED + private var currentIndex = 0 + + /** + * Switches to the next [JumpMode] defined in configuration, skipping any [JumpMode]s that are not assigned. If already at the last + * [JumpMode] in the cycle order, it resets to [JumpMode.DISABLED]. + */ + fun cycle(): JumpMode { + val cycleModes = AceConfig.cycleModes + + for (testModeIndex in (currentIndex + 1)..(cycleModes.size)) { + if (cycleModes[testModeIndex - 1] != JumpMode.DISABLED) { + currentMode = cycleModes[testModeIndex - 1] + currentIndex = testModeIndex + return currentMode + } + } + + currentMode = JumpMode.DISABLED + currentIndex = 0 + return currentMode + } + + /** + * Switches to the specified [JumpMode]. If the current mode already equals the specified one, it resets to [JumpMode.DISABLED]. + */ + fun toggle(newMode: JumpMode): JumpMode { + if (currentMode == newMode) { + currentMode = JumpMode.DISABLED + currentIndex = 0 + } + else { + currentMode = newMode + currentIndex = AceConfig.cycleModes.indexOfFirst { it == newMode } + 1 + } + + return currentMode + } +} diff --git a/src/main/kotlin/org/acejump/input/KeyLayout.kt b/src/main/kotlin/org/acejump/input/KeyLayout.kt new file mode 100644 index 00000000..ee0ae5e8 --- /dev/null +++ b/src/main/kotlin/org/acejump/input/KeyLayout.kt @@ -0,0 +1,24 @@ +package org.acejump.input + +/** + * Defines common keyboard layouts. Each layout has a key priority order, based on each key's distance from the home row and how + * ergonomically difficult they are to press. + */ +@Suppress("unused") +enum class KeyLayout(internal val rows: Array, priority: String) { + 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"), + QWERTZ(arrayOf("1234567890", "qwertzuiop", "asdfghjkl", "yxcvbnm"), priority = "fjghdkslavncmbxyrutzeiwoqp5849673210"), + QGMLWY(arrayOf("1234567890", "qgmlwyfub", "dstnriaeoh", "zxcvjkp"), priority = "naterisodhvkcpjxzlfmuwygbq5849673210"), + QGMLWB(arrayOf("1234567890", "qgmlwbyuv", "dstnriaeoh", "zxcfjkp"), priority = "naterisodhfkcpjxzlymuwbgvq5849673210"), + NORMAN(arrayOf("1234567890", "qwdfkjurl", "asetgynioh", "zxcvbpm"), priority = "tneigysoahbvpcmxzjkufrdlwq5849673210"); + + internal val allChars = rows.joinToString("").toCharArray().apply(CharArray::sort).joinToString("") + internal val allPriorities = priority.mapIndexed { index, char -> char to index }.toMap() + + internal inline fun priority(crossinline tagToChar: (String) -> Char): (String) -> Int? { + return { allPriorities[tagToChar(it)] } + } +} diff --git a/src/main/kotlin/org/acejump/input/KeyLayoutCache.kt b/src/main/kotlin/org/acejump/input/KeyLayoutCache.kt new file mode 100644 index 00000000..52bd175b --- /dev/null +++ b/src/main/kotlin/org/acejump/input/KeyLayoutCache.kt @@ -0,0 +1,93 @@ +package org.acejump.input + +import org.acejump.config.AceSettings + +/** + * 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 { + /** + * Stores keys ordered by proximity to other keys for the QWERTY layout. + * TODO: Support more layouts, perhaps generate automatically. + */ + private val qwertyCharacterDistances = mapOf( + 'j' to "jikmnhuolbgypvftcdrxsezawq8796054321", + 'f' to "ftgvcdryhbxseujnzawqikmolp5463728190", + 'k' to "kolmjipnhubgyvftcdrxsezawq9807654321", + 'd' to "drfcxsetgvzawyhbqujnikmolp4352617890", + 'l' to "lkopmjinhubgyvftcdrxsezawq0987654321", + 's' to "sedxzawrfcqtgvyhbujnikmolp3241567890", + 'a' to "aqwszedxrfctgvyhbujnikmolp1234567890", + 'h' to "hujnbgyikmvftolcdrpxsezawq6758493021", + 'g' to "gyhbvftujncdrikmxseolzawpq5647382910", + 'y' to "yuhgtijnbvfrokmcdeplxswzaq6758493021", + 't' to "tygfruhbvcdeijnxswokmzaqpl5647382910", + 'u' to "uijhyokmnbgtplvfrcdexswzaq7869504321", + 'r' to "rtfdeygvcxswuhbzaqijnokmpl4536271890", + 'n' to "nbhjmvgyuiklocftpxdrzseawq7685940321", + 'v' to "vcfgbxdrtyhnzseujmawikqolp5463728190", + 'm' to "mnjkbhuilvgyopcftxdrzseawq8970654321", + 'c' to "cxdfvzsertgbawyhnqujmikolp4352617890", + 'b' to "bvghncftyujmxdrikzseolawqp6574839201", + 'i' to "iokjuplmnhybgtvfrcdexswzaq8970654321", + 'e' to "erdswtfcxzaqygvuhbijnokmpl3425167890", + 'x' to "xzsdcawerfvqtgbyhnujmikolp3241567890", + 'z' to "zasxqwedcrfvtgbyhnujmikolp1234567890", + 'o' to "oplkimjunhybgtvfrcdexswzaq9087654321", + 'w' to "wesaqrdxztfcygvuhbijnokmpl2314567890", + 'p' to "plokimjunhybgtvfrcdexswzaq0987654321", + 'q' to "qwaeszrdxtfcygvuhbijnokmpl1234567890", + '1' to "1234567890qawzsexdrcftvgybhunjimkolp", + '2' to "2134567890qwasezxdrcftvgybhunjimkolp", + '3' to "3241567890weqasdrzxcftvgybhunjimkolp", + '4' to "4352617890erwsdftqazxcvgybhunjimkolp", + '5' to "5463728190rtedfgywsxcvbhuqaznjimkolp", + '6' to "6574839201tyrfghuedcvbnjiwsxmkoqazlp", + '7' to "7685940321yutghjirfvbnmkoedclpwsxqaz", + '8' to "8796054321uiyhjkotgbnmlprfvedcwsxqaz", + '9' to "9807654321ioujklpyhnmtgbrfvedcwsxqaz", + '0' to "0987654321opiklujmyhntgbrfvedcwsxqaz").mapValues { (_, v) -> v.mapIndexed { index, char -> char to index }.toMap() } + + /** + * Sorts tags according to current keyboard layout settings, and some predefined rules that force tags with digits, and tags with two + * keys far apart, to be sorted after other (easier to type) tags. + */ + lateinit var tagOrder: Comparator + private set + + /** + * Returns all possible two key tags, pre-sorted according to [tagOrder]. + */ + lateinit var allPossibleTags: List + 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 (!::tagOrder.isInitialized) { + reset(settings) + } + } + + /** + * Re-initializes cached data according to updated settings. + */ + fun reset(settings: AceSettings) { + tagOrder = compareBy( + { it[0].isDigit() || it[1].isDigit() }, + { qwertyCharacterDistances.getValue(it[0]).getValue(it[1]) }, + settings.layout.priority { it[0] } + ) + + val allPossibleChars = settings.allowedChars + .toCharArray() + .filter(Char::isLetterOrDigit) + .distinct() + .joinToString("") + .ifEmpty(settings.layout::allChars) + + allPossibleTags = allPossibleChars.flatMap { a -> allPossibleChars.map { b -> "$a$b".intern() } }.sortedWith(tagOrder) + } +} diff --git a/src/main/kotlin/org/acejump/label/Pattern.kt b/src/main/kotlin/org/acejump/label/Pattern.kt deleted file mode 100644 index a5b4622c..00000000 --- a/src/main/kotlin/org/acejump/label/Pattern.kt +++ /dev/null @@ -1,72 +0,0 @@ -package org.acejump.label - -import org.acejump.config.AceConfig - -/** - * Patterns related to key priority, separation, and regexps for line mode. - */ - -enum class Pattern(val string: String) { - END_OF_LINE("\\n|\\Z"), - START_OF_LINE("^.|^\\n"), - CODE_INDENTS("[^\\s].*|^\\n"), -// START_OF_LINE("^[^\\n]{2,}|^\\n"), -// CODE_INDENTS("[^\\s][^\\n]{2,}|^\\n"), - LINE_MARK(END_OF_LINE.string + "|" + - START_OF_LINE.string + "|" + - CODE_INDENTS.string), - ALL_WORDS("(?<=[^a-zA-Z0-9_]|\\A)[a-zA-Z0-9_]"); - - companion object { - val NUM_TAGS: Int - get() = NUM_CHARS * NUM_CHARS - - val NUM_CHARS: Int - get() = AceConfig.allowedChars.length - - fun filter(bigrams: Set, query: String) = - bigrams.filter { !query.endsWith(it[0]) } - - /** - * Sorts available tags by key distance. Tags which are ergonomically easier - * to reach will be assigned first. We would prefer to use tags that contain - * repeated keys (ex. FF, JJ), and use tags that contain physically adjacent - * keys (ex. 12, 21) to keys that are located further apart on the keyboard. - */ - - enum class KeyLayout(vararg val rows: String) { - COLEMK("1234567890", "qwfpgjluy", "arstdhneio", "zxcvbkm"), - WORKMN("1234567890", "qdrwbjfup", "ashtgyneoi", "zxmcvkl"), - DVORAK("1234567890", "pyfgcrl", "aoeuidhtns", "qjkxbmwvz"), - QWERTY("1234567890", "qwertyuiop", "asdfghjkl", "zxcvbnm"), - QWERTZ("1234567890", "qwertzuiop", "asdfghjkl", "yxcvbnm"), - QGMLWY("1234567890", "qgmlwyfub", "dstnriaeoh", "zxcvjkp"), - QGMLWB("1234567890", "qgmlwbyuv", "dstnriaeoh", "zxcfjkp"), - NORMAN("1234567890", "qwdfkjurl", "asetgynioh", "zxcvbpm"); - - private val priority by lazy { - when (this) { - QWERTY -> "fjghdkslavncmbxzrutyeiwoqp5849673210" - QWERTZ -> "fjghdkslavncmbxyrutzeiwoqp5849673210" - COLEMK -> "tndhseriaovkcmbxzgjplfuwyq5849673210" - DVORAK -> "uhetidonasxkbjmqwvzgfycprl5849673210" - NORMAN -> "tneigysoahbvpcmxzjkufrdlwq5849673210" - QGMLWY -> "naterisodhvkcpjxzlfmuwygbq5849673210" - QGMLWB -> "naterisodhfkcpjxzlymuwbgvq5849673210" - WORKMN -> "tnhegysoaiclvkmxzwfrubjdpq5849673210" - }.mapIndices() - } - - val text by lazy { - joinBy("").toCharArray().sortedBy { priority[it] }.joinToString("") - } - - fun priority(tagToChar: (String) -> Char): (String) -> Int? = - { priority[tagToChar(it)] } - - fun joinBy(separator: CharSequence) = rows.joinToString(separator) - } - } -} - -fun String.mapIndices() = mapIndexed { i, c -> c to i }.toMap() \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/label/Solver.kt b/src/main/kotlin/org/acejump/label/Solver.kt deleted file mode 100644 index cfd2b003..00000000 --- a/src/main/kotlin/org/acejump/label/Solver.kt +++ /dev/null @@ -1,210 +0,0 @@ -package org.acejump.label - -import com.intellij.openapi.diagnostic.Logger -import it.unimi.dsi.fastutil.ints.* -import it.unimi.dsi.fastutil.objects.Object2IntMap -import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap -import org.acejump.config.AceConfig -import org.acejump.search.wordBoundsPlus -import kotlin.math.max -import kotlin.system.measureTimeMillis - -/* - * Solves the Tag Assignment Problem. The tag assignment problem can be stated - * thusly: Given a set of indices I in document d, and a set of tags T, find a - * bijection f: T*⊂T → I*⊂I s.t. d[i..k] + t ∉ d[i'..(k + |t|)], ∀ i' ∈ I\{i}, - * ∀ k ∈ (i, |d|-|t|], where t ∈ T, i ∈ I. Maximize |I*|. This can be relaxed - * to t=t[0] and ∀ k ∈ (i, i+K] for some fixed K, in most natural documents. - * - * More concretely, tags are typically two-character strings containing alpha- - * numeric symbols. Documents are plaintext files. Indices are produced by a - * search query of length N, i.e. the preceding N characters of every index i in - * document d are identical. For characters proceeding d[i], all bets are off. - * We can assume that P(d[i]|d[i-1]) has some structure for d~D. Ultimately, we - * want a fast algorithm which maximizes the number of tagged document indices. - * - * Tags are used by the typist to select indices within a document. To select an - * index, the typist starts by activating AceJump and searching for a character. - * As soon as the first character is received, we begin to scan the document for - * matching locations and assign as many valid tags as possible. When subsequent - * characters are received, we refine the search results to match either: - * - * 1.) The plaintext query alone, or - * 2.) The concatenation of plaintext query and partial tag - * - * The constraint in paragraph no. 1 tries to impose the following criteria: - * - * 1.) All valid key sequences will lead to a unique location in the document - * 2.) All indices in the document will be reachable by a short key sequence - * - * If there is an insufficient number of two-character tags to cover every index - * (which typically occurs when the user searches for a common character within - * a long document), then we attempt to maximize the number of tags assigned to - * document indices. The key is, all tags must be assigned as soon as possible, - * i.e. as soon as the first character is received or whenever the user ceases - * typing (at the very latest). Once assigned, a visible tag must never change - * at any time during the selection process, so as not to confuse the user. - */ - -class Solver(val text: String, - val query: String, - val results: Collection, - val availableTags: Set, - val viewBounds: IntRange = 0..text.length) { - private val logger = Logger.getInstance(Solver::class.java) - private var newTags: Object2IntMap = - Object2IntOpenHashMap(Pattern.NUM_TAGS) - private val newTagIndices: IntSet = IntOpenHashSet() - private var strings: Set = - HashSet(results.flatMap { getWordFragments(it) }) - - /** - * Iterates through remaining available tags, until we find one matching our - * criteria, i.e. does not collide with an existing tag or plaintext string. - * - * @param tag the tag string which is to be assigned - * @param sites potential indices where a tag may be assigned - */ - - private fun tryToAssignTag(tag: String, sites: IntArray): Boolean { - if (newTags.containsKey(tag)) return false - val index = sites.firstOrNull { it !in newTagIndices } ?: return false - @Suppress("ReplacePutWithAssignment") - newTags.put(tag, index) - newTagIndices.add(index) - return true - } - - /** - * Ensures tag conservation. Most tags prefer to occupy certain sites during - * assignment, since not all tags may be assigned to all sites. Therefore, we - * must spend our tag "budget" wisely, in order to cover the most sites with - * the tags we have at our disposal. We should consider the "most restrictive" - * tags first, since they have the least chance of being available as further - * sites are assigned. - * - * Tags which are compatible with the fewest sites should have preference for - * first assignment. Here we ensure that scarce tags are prioritized for their - * subsequent binding to available sites. - * - * @see isCompatibleWithTagChar This defines how tags may be assigned to sites - */ - - private val tagOrder = AceConfig.defaultTagOrder - .thenComparingInt { eligibleSitesByTag.getValue(it).size } - .thenBy(AceConfig.layout.priority { it.last() }) - - /** - * Sorts jump targets to determine which positions get first choice for tags, - * by taking into account the structure of the surrounding text. For example, - * if the jump target is the first letter in a word, it is advantageous to - * prioritize this location (in case we run out of tags), since the typist is - * more likely to target words by their leading character. - */ - - private val siteOrder: IntComparator = IntComparator { a, b -> - val aInBounds = a in viewBounds - val bInBounds = b in viewBounds - - if (aInBounds != bInBounds) { - // Sites in immediate view should come first - return@IntComparator if (aInBounds) -1 else 1 - } - - val aIsNotFirstLetter = text[max(0, a - 1)].isLetterOrDigit() - val bIsNotFirstLetter = text[max(0, b - 1)].isLetterOrDigit() - - if (aIsNotFirstLetter != bIsNotFirstLetter) { - // Ensure that the first letter of a word is prioritized for tagging - return@IntComparator if (bIsNotFirstLetter) -1 else 1 - } - - when { - a < b -> -1 - a > b -> 1 - else -> 0 - } - } - - private val eligibleSitesByTag: MutableMap = HashMap(100) - - /** - * Maps tags to search results according to the following constraints. - * - * 1. A tag's first letter must not match any letters of the covered word. - * 2. Once assigned, a tag must never change until it has been selected. *A. - * - * Tags *should* have the following properties: - * - * A. Should be as short as possible. A tag may be "compacted" later. - * B. Should prefer keys that are physically closer on a QWERTY keyboard. - * - * @return A list of all tags and their corresponding indices - */ - - fun map(): Map { - var totalAssigned = 0 - var timeAssigned = 0L - val timeElapsed = measureTimeMillis { - val tagsByFirstLetter = availableTags.groupBy { it[0] } - for (site in results) { - for (tag in tagsByFirstLetter.getTagsCompatibleWith(site)) { - eligibleSitesByTag.getOrPut(tag){ IntArrayList(10) }.add(site) - } - } - - val sortedTags = eligibleSitesByTag.keys.toMutableList().apply { - sortWith(tagOrder) - } - - val matchingSites = HashMap() - val matchingSitesAsArrays = HashMap() - - for ((key, value) in eligibleSitesByTag.entries) { - matchingSitesAsArrays[key] = matchingSites.getOrPut(value){ - value.toIntArray().apply { IntArrays.mergeSort(this, siteOrder) } - } - } - - timeAssigned = measureTimeMillis { - for (tag in sortedTags) { - if (totalAssigned == results.size) break - if (tryToAssignTag(tag, matchingSitesAsArrays.getValue(tag))) - totalAssigned++ - } - } - } - - logger.run { - info("results size: ${results.size}") - info("newTags size: ${newTags.size}") - info("Time elapsed: $timeElapsed ms") - info("Total assign: $totalAssigned") - info("Completed in: $timeAssigned ms") - } - - return newTags - } - - private fun Map>.getTagsCompatibleWith(site: Int) = - entries.flatMap { (firstLetter, tags) -> - if (site isCompatibleWithTagChar firstLetter) tags else emptyList() - } - - /** - * Returns true IFF the tag, when inserted at any position in the word, could - * match an existing substring elsewhere in the editor text. We should never - * assign a tag which can be partly completed by typing plaintext. - */ - - private infix fun Int.isCompatibleWithTagChar(char: Char) = - getWordFragments(this).map { it + char }.none { it in strings } - - private fun getWordFragments(site: Int): List { - val left = max(0, site + query.length - 1) - val right = text.wordBoundsPlus(site).second - val lowercase = text.substring(left, right).toLowerCase() - - return (0..(right - left)).map { lowercase.substring(0, it) } - } -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/label/Tagger.kt b/src/main/kotlin/org/acejump/label/Tagger.kt deleted file mode 100755 index 22744fc2..00000000 --- a/src/main/kotlin/org/acejump/label/Tagger.kt +++ /dev/null @@ -1,319 +0,0 @@ -package org.acejump.label - -import com.google.common.collect.BiMap -import com.google.common.collect.HashBiMap -import com.intellij.openapi.diagnostic.Logger -import org.acejump.config.AceConfig -import org.acejump.control.Scroller -import org.acejump.search.AceFindModel -import org.acejump.search.Finder -import org.acejump.search.Jumper -import org.acejump.search.Resettable -import org.acejump.search.canIndicesBeSimultaneouslyVisible -import org.acejump.search.getFeasibleRegion -import org.acejump.search.runNow -import org.acejump.view.Marker -import org.acejump.view.Model.editor -import org.acejump.view.Model.editorText -import org.acejump.view.Model.viewBounds -import java.util.* -import kotlin.collections.Iterable -import kotlin.collections.List -import kotlin.collections.Map -import kotlin.collections.Set -import kotlin.collections.all -import kotlin.collections.any -import kotlin.collections.component1 -import kotlin.collections.component2 -import kotlin.collections.contains -import kotlin.collections.emptyList -import kotlin.collections.filter -import kotlin.collections.firstOrNull -import kotlin.collections.isNotEmpty -import kotlin.collections.iterator -import kotlin.collections.joinToString -import kotlin.collections.lastOrNull -import kotlin.collections.map -import kotlin.collections.mapKeysTo -import kotlin.collections.none -import kotlin.collections.partition -import kotlin.collections.plus -import kotlin.collections.sortedSetOf -import kotlin.collections.sortedWith -import kotlin.collections.toMap -import kotlin.collections.toSortedSet -import kotlin.collections.zip -import kotlin.streams.toList -import kotlin.system.measureTimeMillis - -/** - * The [Tagger] works with [Finder] to assign selectable tags to search results - * in the editor. These tags may be selected by typing their label at any point - * during the search. Since there is no explicit signal to begin selecting a tag - * when AceJump is active, we must infer when a tag is being selected. We do so - * by carefully assigning tags to search results so that every search result can - * be expanded indefinitely and selected unambiguously any time the user wishes. - * - * To do so, we must solve a tag assignment problem, where each search result is - * assigned an available tag. The Tagger (1) identifies available tags (2) uses - * the [Solver] to assign them, and (3) determines when a previously assigned - * tag has been selected, then (4) calls [Jumper] to reposition the caret. - */ - -object Tagger : Resettable { - var markers: List = emptyList() - private set - var regex = false - private set - var query = "" - private set - - @Volatile - var full = false // Tracks whether all search results were successfully tagged - var textMatches: SortedSet = sortedSetOf() - @Volatile - var tagMap: BiMap = HashBiMap.create() - private val logger = Logger.getInstance(Tagger::class.java) - - @Volatile - var tagSelected = false - - private fun Iterable.noneInView() = none { it in viewBounds } - - fun markOrJump(model: AceFindModel, results: SortedSet) { - model.run { - if (!regex) regex = isRegularExpressions - query = if (regex) " $stringToFind" else stringToFind.mapIndexed { i, c -> - if (i == 0) c else c.toLowerCase() - }.joinToString("") - logger.info("Received query: \"$query\"") - } - - val availableTags = AceConfig.getCompatibleTags(query) { it !in tagMap } - - measureTimeMillis { textMatches = refineSearchResults(results) } - .let { if (!regex) logger.info("Refined search results in $it ms") } - - giveJumpOpportunity() - if (!tagSelected && query.isNotEmpty()) mark(textMatches, availableTags) - - if (1 < query.length && tagMap.values.noneInView()) - runNow { Scroller.scroll() } - } - - /** - * Narrows down results that need to be tagged. For example, "eee" need not be - * tagged three times. Furthermore, we will not be able to tag every location - * in a very large document. - */ - - private fun refineSearchResults(results: SortedSet): SortedSet { - if (regex) return results - - val admittance: (t: Int) -> Boolean = { editorText.admitsTagAtLocation(it) } - val sites = if (results.size < 500) results.filter(admittance) - else results.parallelStream().filter(admittance).toList() - - val discards = results.size - sites.size - discards.let { if (it > 0) logger.info("Discarded $it unsuitable results") } - - return sites.toSortedSet() - } - - /** - * Returns whether a given index inside a String can be tagged with a two- - * character tag (either to the left or right) without visually overlapping - * any nearby tags. - */ - - private fun String.admitsTagAtLocation(loc: Int) = when { - 1 < query.length -> true - loc - 1 < 0 -> true - loc + 1 >= length -> true - this[loc] isUnlike this[loc - 1] -> true - this[loc] isUnlike this[loc + 1] -> true - this[loc] != this[loc - 1] -> true - this[loc] != this[loc + 1] -> true - this[loc + 1] == '\r' || this[loc + 1] == '\n' -> true - this[loc - 1] == this[loc] && this[loc] == this[loc + 1] -> false - this[loc + 1].isWhitespace() && this[(loc + 2) - .coerceAtMost(length - 1)].isWhitespace() -> true - else -> false - } - - private infix fun Char.isUnlike(other: Char) = - this.isLetterOrDigit() xor other.isLetterOrDigit() || - this.isWhitespace() xor other.isWhitespace() - - /** - * Checks whether a visible tag has been selected, and if so, jumps to it. - */ - - private fun giveJumpOpportunity() = - tagMap.entries.firstOrNull { it.value in viewBounds && it solves query } - ?.run { - logger.info("User selected tag: ${key.toUpperCase()}") - tagSelected = true - Jumper.jumpTo(value) - } - - /** - * Returns true if and only if a tag location is unambiguously completed by a - * given query. This can only happen if the query matches the underlying text, - * AND ends with the tag in question. Tags are case-insensitive. - */ - - private infix fun Map.Entry.solves(query: String) = - query.endsWith(key, true) && isCompatibleWithQuery(query) - - private fun Map.Entry.isCompatibleWithQuery(query: String) = - query.getPlaintextPortion(key).let { text -> - regex || editorText.regionMatches( - thisOffset = value, - other = text, - otherOffset = 0, - length = text.length, - ignoreCase = true - ) - } - - private fun mark(results: SortedSet, availableTags: Set) = - assignMissingTags(results, availableTags).compact().apply { - tagMap = this - markers = if(results.isEmpty()) // Last query char must be a tag char - tagMap.map { (tag, index) -> Marker(query, tag, index) } - else results.map { Marker(query, tagMap.inverse()[it], it) } - full = markers.size == tagMap.size - } - - /** - * Shortens previously assigned tags. Two-character tags may be shortened to - * one-character tags if and only if: - * - * 1. The shortened tag is unique among the set of visible tags. - * 3. The query does not end with the shortened tag, in whole or part. - */ - - private fun Map.compact(): HashBiMap { - var timeElapsed = System.currentTimeMillis() - var totalCompacted = 0 - val compacted = mapKeysTo(HashBiMap.create(size)) { e -> - val tag = e.key - if (e.value !in viewBounds) return@mapKeysTo tag - // Avoid matching query - will trigger a jump. TODO: lift this constraint. - val queryEndsWith = query.endsWith(tag[0]) || query.endsWith(tag) - return@mapKeysTo if (!queryEndsWith && tag.canBeShortened(this)) { - totalCompacted++ - tag[0].toString() - } else tag - } - - timeElapsed = System.currentTimeMillis() - timeElapsed - logger.info("Compacted $totalCompacted visible tags in $timeElapsed ms") - return compacted - } - - private fun String.canBeShortened(tagMap: Map): Boolean { - var i = 0 - var canBeShortened = true - - runNow { - for (tag in tagMap) { - if (tag.key[0] == this[0] && - editor.canIndicesBeSimultaneouslyVisible(tagMap[this]!!, tag.value)) - i++ - if (1 < i) { - canBeShortened = false; break - } - } - } - - return canBeShortened - } - - /** - * Assigns [availableTags] to [results]. Initially, all results are vacant. - * If there are any untagged results visible, assign as many tags as possible. - * Assuming all visible tags have been assigned, there is nothing left to do. - */ - - private fun assignMissingTags(results: Set, - availableTags: Set): Map { - var timeElapsed = System.currentTimeMillis() - val oldTags = transferExistingTagsCompatibleWithQuery() - // Ongoing queries with results in view do not need further tag assignment - oldTags.run { - if (regex && isNotEmpty() && values.all { it in viewBounds }) return this - else if (hasTagSuffixInView(query)) return this - } - - val remainder = getFeasibleSites(results) - val (onScreen, offScreen) = remainder.partition { it in viewBounds } - val completeResultSet = onScreen + offScreen - // Some results are untagged. Let's assign some tags! - val vacantResults = completeResultSet.filter { it !in oldTags.values } - - logger.run { - timeElapsed = System.currentTimeMillis() - timeElapsed - info("Results on screen: ${onScreen.size}, off screen: ${offScreen.size}") - info("Vacant Results: ${vacantResults.size}") - info("Available Tags: ${availableTags.size}") - info("Time elapsed: $timeElapsed ms") - } - - return if (regex) solveRegex(vacantResults, availableTags) else oldTags + - Solver(editorText, query, vacantResults, availableTags, viewBounds).map() - } - - private fun getFeasibleSites(results: Set): List { - val feasibleRegion = getFeasibleRegion(results) - val remainder = results.partition { it in feasibleRegion } - remainder.second.size.let { if (it > 0) logger.info("Discarded $it OOBs") } - return remainder.first - } - - private fun solveRegex(vacantResults: List, availableTags: Set) = - availableTags.sortedWith(AceConfig.defaultTagOrder).zip(vacantResults).toMap() - - /** - * Adds pre-existing tags where search string and tag overlap. For example, - * tags starting with the last character of the query will be included. Tags - * that no longer match the query will be discarded. - */ - - private fun transferExistingTagsCompatibleWithQuery() = - tagMap.filter { it.isCompatibleWithQuery(query) || it.value in textMatches } - - override fun reset() { - regex = false - full = false - textMatches = sortedSetOf() - tagMap = HashBiMap.create() - query = "" - markers = emptyList() - tagSelected = false - } - - private fun String.getPlaintextPortion(tag: String) = when { - endsWith(tag, true) -> dropLast(tag.length) - endsWith(tag.first(), true) -> dropLast(1) - else -> this - } - - /** - * Returns true if the Tagger contains a match in the new view, that is not - * contained (visible) in the old view. This method assumes that [textMatches] - * are in ascending order by index. - * - * @return true if there is a match in the new range not in the old range - */ - - fun hasMatchBetweenOldAndNewView(old: IntRange, new: IntRange) = - textMatches.lastOrNull { it < old.first } ?: -1 >= new.first || - textMatches.firstOrNull { it > old.last } ?: new.last < new.last - - fun hasTagSuffixInView(query: String) = - tagMap.any { it.value in viewBounds && it.isCompatibleWithQuery(query) } - - infix fun canDiscard(i: Int) = !(Finder.skim || i in tagMap.values || i == -1) -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/search/AceFindModel.kt b/src/main/kotlin/org/acejump/search/AceFindModel.kt deleted file mode 100644 index 41ab10fd..00000000 --- a/src/main/kotlin/org/acejump/search/AceFindModel.kt +++ /dev/null @@ -1,26 +0,0 @@ -package org.acejump.search - -import com.intellij.find.FindModel -import kotlin.text.RegexOption.IGNORE_CASE -import kotlin.text.RegexOption.MULTILINE - -class AceFindModel: FindModel { - internal constructor(key: String, isRegex: Boolean = false): super() { - isCaseSensitive = false - stringToFind = key - isRegularExpressions = isRegex - isReplaceState = false - } - - fun toRegex(): Regex { - var regex = stringToFind - val options = mutableSetOf(MULTILINE) - - if (!isCaseSensitive && stringToFind.first().isLowerCase()) - options.add(IGNORE_CASE) - if (!isRegularExpressions) - regex = Regex.escape(stringToFind) - - return Regex(regex, options) - } -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/search/AceUtil.kt b/src/main/kotlin/org/acejump/search/AceUtil.kt deleted file mode 100755 index 33b815a2..00000000 --- a/src/main/kotlin/org/acejump/search/AceUtil.kt +++ /dev/null @@ -1,294 +0,0 @@ -package org.acejump.search - -import com.intellij.openapi.application.ApplicationManager -import com.intellij.openapi.application.ReadAction -import com.intellij.openapi.editor.* -import com.intellij.openapi.fileEditor.FileDocumentManager -import com.intellij.openapi.fileEditor.FileEditorManager -import com.intellij.openapi.project.ProjectManager -import com.intellij.ui.awt.RelativePoint -import com.intellij.util.IntPair -import org.acejump.view.Model.MAX_TAG_RESULTS -import org.acejump.view.Model.viewBounds -import java.awt.Point -import java.util.* -import javax.swing.JComponent -import kotlin.math.* - -interface Resettable { - fun reset() -} - -fun aceString(s: String): String = - ResourceBundle.getBundle("AceResources").getString(s) - -fun

applyTo(vararg ps: P, fx: P.() -> Unit) = ps.forEach { it.fx() } - -operator fun Point.component1() = x -operator fun Point.component2() = y - -operator fun CharSequence.get(i: Int, j: Int) = substring(i, j).toCharArray() - -fun String.hasSpaceRight(i: Int) = length <= i + 1 || this[i + 1].isWhitespace() - -/** - * TODO: This is mostly an antipattern and can be replaced with [ReadAction.run] - * - * Further details: https://www.jetbrains.org/intellij/sdk/docs/basics/architectural_overview/general_threading_rules.html#readwrite-lock - */ - -@Deprecated("This is applied too broadly. Narrow down usages where necessary.") -fun runNow(t: () -> Unit) = ApplicationManager.getApplication().invokeAndWait(t) - -@Deprecated("This is applied too broadly. Narrow down usages where necessary.") -fun runLater(t: () -> Unit) = ApplicationManager.getApplication().invokeLater(t) - -fun Editor.offsetCenter(first: Int, second: Int): LogicalPosition { - val firstIndexLine = offsetToLogicalPosition(first).line - val lastIndexLine = offsetToLogicalPosition(second).line - val center = (firstIndexLine + lastIndexLine) / 2 - return offsetToLogicalPosition(getLineStartOffset(center)) -} - -fun Editor.getNameOfFileInEditor() = - FileDocumentManager.getInstance().getFile(document)?.presentableName - -fun Editor.isNotFolded(offset: Int) = !foldingModel.isOffsetCollapsed(offset) - -/** - * Identifies the bounds of a word, defined as a contiguous group of letters - * and digits, by expanding the provided index until a non-matching character - * is seen on either side. - */ - -fun String.wordBounds(index: Int): IntPair { - var first = index - var last = index - while (0 < first && get(first - 1).isJavaIdentifierPart()) first-- - while (last < length && get(last).isJavaIdentifierPart()) last++ - return IntPair(first, last) -} - -operator fun IntPair.component1() = this.first -operator fun IntPair.component2() = this.second - -fun String.wordBoundsPlus(index: Int): IntPair { - var (left, right) = wordBounds(index) - - for (it in (right..(right + 3).coerceAtMost(length - 1))) { - if (get(it) == '\n' || get(it) == '\r') { - break - } else { - right = it - } - } - - return IntPair(left, right) -} - -fun defaultEditor(): Editor = - FileEditorManager.getInstance(ProjectManager.getInstance() - .run { openProjects.firstOrNull() ?: defaultProject }) - .run { - selectedTextEditor ?: allEditors.firstOrNull { it is Editor } as? Editor - ?: EditorFactory.getInstance().run { createEditor(createDocument("")) } - } - -fun Editor.getPoint(idx: Int) = visualPositionToXY(offsetToVisualPosition(idx)) - -fun Editor.getPointRelative(absolute: Point, relativeToComponent: JComponent) = - RelativePoint(relativeToComponent, absolute).originalPoint - -fun Editor.isFirstCharacterOfLine(index: Int) = - index == getLineStartOffset(offsetToLogicalPosition(index).line) - -/** - * Returns up to [MAX_TAG_RESULTS] by accumulating results before and after the - * view boundaries, (approximately centered around the middle of the screen). - */ - -fun getFeasibleRegion(results: Set, takeAtMost: Int = MAX_TAG_RESULTS) = - (viewBounds.run { first + last } / 2).let { middleOfScreen -> - results.sortedBy { abs(middleOfScreen - it) } - .take(min(results.size, takeAtMost)) - }.sorted().let { if (it.isNotEmpty()) it.first()..it.last() else viewBounds } - -fun Editor.getView(): IntRange { - val firstVisibleLine = max(0, getVisualLineAtTopOfScreen() - 1) - val firstLine = visualLineToLogicalLine(firstVisibleLine) - val startOffset = getLineStartOffset(firstLine) - - val height = getScreenHeight() + 2 - val lastLine = visualLineToLogicalLine(firstVisibleLine + height) - var endOffset = getLineEndOffset(lastLine, true) - endOffset = normalizeOffset(lastLine, endOffset) - endOffset = min(max(0, document.textLength - 1), endOffset + 1) - - return startOffset..endOffset -} - -fun Editor.selectRange(fromOffset: Int, toOffset: Int) = runNow { - selectionModel.removeSelection() - selectionModel.setSelection(fromOffset, toOffset) - caretModel.moveToOffset(toOffset) -} - -/** - * Returns whether two indices can be simultaneously visible on screen - */ - -fun Editor.canIndicesBeSimultaneouslyVisible(idx0: Int, idx1: Int): Boolean { - // Thread must must have read access - val line1 = offsetToLogicalPosition(idx0).line - val line2 = offsetToLogicalPosition(idx1).line - - return abs(line1 - line2) < getScreenHeight() -} - -/* - * IdeaVim - A Vim emulator plugin for IntelliJ Idea - * Copyright (C) 2003-2005 Rick Maddy - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -/** - * This is a set of helper methods for working with editors. - * All line and column values are zero based. - */ - -fun Editor.getVisualLineAtTopOfScreen() = - (scrollingModel.verticalScrollOffset + lineHeight - 1) / lineHeight - -/** - * Gets the number of actual lines in the file - * - * @return The file line count - */ - -fun Editor.getLineCount() = document.run { - lineCount - if (textLength > 0 && text[textLength - 1] == '\n') 1 else 0 -} - -/** - * Gets the actual number of characters in the file - * - * @param countNewLines True include newline - * - * @return The file's character count - */ - -fun Editor.getFileSize(countNewLines: Boolean = false): Int { - val len = document.textLength - val doc = document.charsSequence - return if (countNewLines || len == 0 || doc[len - 1] != '\n') len else len - 1 -} - -/** - * Gets the number of lines than can be displayed on the screen at one time. - * This is rounded down to the nearest whole line if there is a partial line - * visible at the bottom of the screen. - * - * @return The number of screen lines - */ - -fun Editor.getScreenHeight() = - (scrollingModel.visibleArea.y + scrollingModel.visibleArea.height - - getVisualLineAtTopOfScreen() * lineHeight) / lineHeight - -/** - * Converts a visual line number to a logical line number. - * - * @param line The visual line number to convert - * - * @return The logical line number - */ - -fun Editor.visualLineToLogicalLine(line: Int) = - normalizeLine(visualToLogicalPosition( - VisualPosition(line.coerceAtLeast(0), 0)).line) - -/** - * Returns the offset of the start of the requested line. - * - * @param line The logical line to get the start offset for. - * - * @return 0 if line is < 0, file size of line is bigger than file, else the - * start offset for the line - */ - -fun Editor.getLineStartOffset(line: Int) = - when { - line < 0 -> 0 - line >= getLineCount() -> getFileSize() - else -> document.getLineStartOffset(line) - } - -/** - * Returns the offset of the end of the requested line. - * - * @param line The logical line to get the end offset for - * - * @param allowEnd True include newline - * - * @return 0 if line is < 0, file size of line is bigger than file, else the - * end offset for the line - */ - -fun Editor.getLineEndOffset(line: Int, allowEnd: Boolean = true) = - when { - line < 0 -> 0 - line >= getLineCount() -> getFileSize(allowEnd) - else -> document.getLineEndOffset(line) - if (allowEnd) 0 else 1 - } - -/** - * Ensures that the supplied logical line is within the range 0 (incl) and the - * number of logical lines in the file (excl). - * - * @param line The logical line number to normalize - * - * @return The normalized logical line number - */ - -fun Editor.normalizeLine(line: Int) = max(0, min(line, getLineCount() - 1)) - -/** - * Ensures that the supplied offset for the given logical line is within the - * range for the line. If allowEnd is true, the range will allow for the offset - * to be one past the last character on the line. - * - * @param line The logical line number - * - * @param offset The offset to normalize - * - * @param allowEnd true if the offset can be one past the last character on the - * line, false if not - * - * @return The normalized column number - */ - -fun Editor.normalizeOffset(line: Int, offset: Int, allowEnd: Boolean = true) = - if (getFileSize(allowEnd) == 0) 0 else - max(min(offset, getLineEndOffset(line, allowEnd)), getLineStartOffset(line)) - -/** - * This annotation is a marker which means that the annotated function is - * used in external plugins. - */ - -@Retention(AnnotationRetention.SOURCE) -@Target(AnnotationTarget.FUNCTION) -annotation class ExternalUsage \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/search/Finder.kt b/src/main/kotlin/org/acejump/search/Finder.kt deleted file mode 100644 index b254f33c..00000000 --- a/src/main/kotlin/org/acejump/search/Finder.kt +++ /dev/null @@ -1,229 +0,0 @@ -package org.acejump.search - -import com.intellij.openapi.diagnostic.Logger -import com.intellij.openapi.editor.markup.HighlighterLayer -import com.intellij.openapi.editor.markup.HighlighterTargetArea.EXACT_RANGE -import com.intellij.openapi.editor.markup.RangeHighlighter -import org.acejump.config.AceConfig -import org.acejump.control.Handler -import org.acejump.control.Trigger -import org.acejump.label.Pattern -import org.acejump.label.Tagger -import org.acejump.view.Boundary -import org.acejump.view.Marker -import org.acejump.view.Model.LONG_DOCUMENT -import org.acejump.view.Model.boundaries -import org.acejump.view.Model.editor -import org.acejump.view.Model.editorText -import org.acejump.view.Model.markup -import org.acejump.view.Model.viewBounds -import java.util.* -import kotlin.math.max -import kotlin.math.min -import kotlin.system.measureTimeMillis - -/** - * Singleton that searches for text in editor and highlights matching results. - */ - -object Finder : Resettable { - @Volatile - private var results: SortedSet = sortedSetOf() - @Volatile - private var textHighlights = listOf() - private var HIGHLIGHT_LAYER = HighlighterLayer.LAST + 1 - private val logger = Logger.getInstance(Finder::class.java) - private val skimTrigger = Trigger() - var isShiftSelectEnabled = false - - var skim = false - private set - - @Volatile - var query: String = "" - set(value) { - field = value - if (query.isNotEmpty()) logger.info("Received query: \"$value\"") - isShiftSelectEnabled = value.lastOrNull()?.isUpperCase() == true - - when { - value.isEmpty() -> return - Tagger.regex -> search() - value.length == 1 -> skimThenSearch() - value.isValidQuery() -> skimThenSearch() - else -> { - logger.info("Invalid query \"$field\", dropping: ${field.last()}") - field = field.dropLast(1) - } - } - } - - /** - * A user has two possible intentions when launching an AceJump search. - * - * 1. To locate the position of a known string in the document (a.k.a. Find) - * 2. To reposition the caret to a known location (i.e. staring at location) - * - * Since we cannot know why the user initiated any query a priori, here we - * attempt to satisfy both goals. First, we highlight all matches on (or off) - * the screen. This operation has very low latency. As soon as the user types - * a single character, we highlight all matches immediately. If we should - * receive no further characters after a short delay (indicating a pause in - * typing cadence), then we apply tags. - * - * Typically when a user searches for a known string, they will type several - * characters in rapid succession. We can avoid unnecessary work by only - * applying tags once we have received a "chunk" of search text. - */ - - private fun skimThenSearch() { - if (results.size == 0 && LONG_DOCUMENT && AceConfig.searchWholeFile) { - logger.info("Skimming document for matches of: $query") - skim = true - search() - skimTrigger(400L) { skim = false; search() } - } - else { - search() - } - } - - fun search(pattern: Pattern, bounds: Boundary) { - logger.info("Searching for regular expression: ${pattern.name} in $bounds") - search(pattern.string, bounds) - } - - fun search(pattern: String, bounds: Boundary) { - boundaries = bounds - // TODO: Fix this broken reset - reset() - Tagger.reset() - search(AceFindModel(pattern, true)) - } - - fun search(model: AceFindModel = AceFindModel(query)) { - val time = measureTimeMillis { - results = Scanner.find(model, calculateSearchBoundaries(), results) - } - - logger.info("Found ${results.size} matching sites in $time ms") - - markResults(results, model) - } - - private fun calculateSearchBoundaries(): IntRange { - if (AceConfig.searchWholeFile) { - return boundaries.intRange() - } - - val bounds1 = boundaries - val bounds2 = Boundary.SCREEN_BOUNDARY - return max(bounds1.start, bounds2.start)..min(bounds1.endInclusive, bounds2.endInclusive) - } - - /** - * This method is used by IdeaVim integration plugin and must not be inlined. - * - * By default, when this function is called externally, [results] are already - * collected and [AceFindModel] should be empty. Additionally, if the flag - * [AceFindModel.isRegularExpressions] is true only one symbol is highlighted. - */ - - @ExternalUsage - fun markResults(results: SortedSet, - model: AceFindModel = AceFindModel("", true) - ) { - markup(results, model.isRegularExpressions) - if (!skim) tag(model, results) - } - - /** - * Paints text highlights beneath each query result to the editor using the - * [com.intellij.openapi.editor.markup.MarkupModel]. - */ - - fun markup(markers: Set = results, isRegexQuery: Boolean = false) { - if (markers.isEmpty()) { - return - } - - runLater { - val highlightLen = if (isRegexQuery) 1 else query.length - - editor.document.isInBulkUpdate = true - textHighlights.forEach { markup.removeHighlighter(it) } - - textHighlights = markers.map { - val start = it - if (it == editorText.length) 1 else 0 - val end = start + highlightLen - createTextHighlight(max(start, 0), min(end, editorText.length - 1)) - } - editor.document.isInBulkUpdate = false - } - } - - private fun createTextHighlight(start: Int, end: Int) = - markup.addRangeHighlighter(start, end, HIGHLIGHT_LAYER, null, EXACT_RANGE) - .apply { customRenderer = Marker.Companion } - - private fun tag(model: AceFindModel, results: SortedSet) { - synchronized(this) { Tagger.markOrJump(model, results) } - val (ivb, ovb) = textHighlights.partition { it.startOffset in viewBounds } - - ivb.cull() - runLater { ovb.cull() } - - if (model.stringToFind == query || model.isRegularExpressions) - Handler.repaintTagMarkers() - } - - /** - * Erases highlights which are no longer compatible with the current query. - */ - - private fun List.cull() = - eraseIf { Tagger canDiscard startOffset } - .also { newHighlights -> - val numDiscarded = size - newHighlights.size - if (numDiscarded != 0) logger.info("Discarded $numDiscarded highlights") - } - - fun List.eraseIf(cond: RangeHighlighter.() -> Boolean): List { - val (erased, kept) = partition(cond) - - if (erased.isNotEmpty()) { - runLater { - editor.document.isInBulkUpdate = true - erased.forEach { markup.removeHighlighter(it) } - editor.document.isInBulkUpdate = false - } - } - return kept - } - - fun visibleResults() = results.filter { it in viewBounds } - - private fun String.isValidQuery() = - Tagger.hasTagSuffixInView(query) || - results.any { - editorText.regionMatches( - thisOffset = it, - other = this, - otherOffset = 0, - length = length, - ignoreCase = true - ) - } - - override fun reset() { - runLater { - editor.document.isInBulkUpdate = true - markup.removeAllHighlighters() - editor.document.isInBulkUpdate = false - } - query = "" - skim = false - results = sortedSetOf() - textHighlights = listOf() - } -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/search/JumpMode.kt b/src/main/kotlin/org/acejump/search/JumpMode.kt deleted file mode 100644 index c423fd4e..00000000 --- a/src/main/kotlin/org/acejump/search/JumpMode.kt +++ /dev/null @@ -1,89 +0,0 @@ -package org.acejump.search - -import com.intellij.openapi.editor.colors.EditorColors.CARET_COLOR -import org.acejump.config.AceConfig -import org.acejump.control.Handler -import org.acejump.view.Canvas -import org.acejump.view.Model -import org.acejump.view.Model.editor -import java.awt.Color - -enum class JumpMode { - DISABLED, JUMP, JUMP_END, TARGET, DEFINE; - - companion object: Resettable { - private var modeIndex = 0 - private var mode: JumpMode = DISABLED - set(value) { - field = value - setCaretColor(when (field) { - JUMP -> AceConfig.jumpModeColor - JUMP_END -> AceConfig.jumpEndModeColor - DEFINE -> AceConfig.definitionModeColor - TARGET -> AceConfig.targetModeColor - DISABLED -> Model.naturalCaretColor - }) - - Finder.markup() - Canvas.repaint() - } - - private fun setCaretColor(color: Color) = - editor.colorsScheme.setColor(CARET_COLOR, color) - - fun toggle(newMode: JumpMode): JumpMode { - if (mode == newMode) { - mode = DISABLED - modeIndex = 0 - Handler.reset() - } - else { - mode = newMode - modeIndex = cycleSettings.indexOfFirst { it == newMode } + 1 - } - return mode - } - - private val cycleSettings - get() = arrayOf( - AceConfig.cycleMode1, - AceConfig.cycleMode2, - AceConfig.cycleMode3, - AceConfig.cycleMode4 - ) - - fun cycle(): JumpMode { - val cycleSettings = cycleSettings - - for (testModeIndex in (modeIndex + 1)..(cycleSettings.size)) { - if (cycleSettings[testModeIndex - 1] != DISABLED) { - mode = cycleSettings[testModeIndex - 1] - modeIndex = testModeIndex - return mode - } - } - - mode = DISABLED - modeIndex = 0 - Handler.reset() - return mode - } - - override fun reset() { - mode = DISABLED - modeIndex = 0 - } - - override fun equals(other: Any?) = - if (other is JumpMode) mode == other else super.equals(other) - - } - - override fun toString() = when(this) { - DISABLED -> aceString("jumpModeDisabled") - JUMP -> aceString("jumpModeJump") - JUMP_END -> aceString("jumpModeJumpEnd") - TARGET -> aceString("jumpModeTarget") - DEFINE -> aceString("jumpModeDefine") - } -} diff --git a/src/main/kotlin/org/acejump/search/Jumper.kt b/src/main/kotlin/org/acejump/search/Jumper.kt deleted file mode 100755 index 0f2b88af..00000000 --- a/src/main/kotlin/org/acejump/search/Jumper.kt +++ /dev/null @@ -1,132 +0,0 @@ -package org.acejump.search - -import com.intellij.codeInsight.editorActions.SelectWordUtil.addWordSelection -import com.intellij.codeInsight.navigation.actions.GotoDeclarationAction -import com.intellij.openapi.actionSystem.ActionManager -import com.intellij.openapi.command.CommandProcessor -import com.intellij.openapi.diagnostic.Logger -import com.intellij.openapi.editor.Editor -import com.intellij.openapi.editor.actionSystem.DocCommandGroupId -import com.intellij.openapi.fileEditor.ex.IdeDocumentHistory -import com.intellij.openapi.fileEditor.impl.IdeDocumentHistoryImpl -import com.intellij.openapi.ui.playback.commands.ActionCommand -import com.intellij.openapi.util.TextRange -import org.acejump.label.Tagger -import org.acejump.search.JumpMode.* -import org.acejump.view.Model.editor -import org.acejump.view.Model.editorText -import org.acejump.view.Model.project -import kotlin.math.max -import kotlin.math.min - -/** - * Updates the [com.intellij.openapi.editor.CaretModel] after a tag is selected. - */ - -object Jumper: Resettable { - private val logger = Logger.getInstance(Jumper::class.java) - - fun cycleMode() = - logger.info("Entering ${JumpMode.cycle()} mode") - - fun toggleMode(mode: JumpMode) = - logger.info("Entering ${JumpMode.toggle(mode)} mode") - - fun jumpTo(newOffset: Int, done: Boolean = true) = - editor.run { - val logPos = offsetToLogicalPosition(newOffset) - logger.debug("Jumping to line ${logPos.line}, column ${logPos.column}...") - - val oldOffset = caretModel.offset - - when { - JumpMode.equals(JUMP_END) -> - moveCaretToEnd(newOffset + countMatchingCharacters(newOffset, Tagger.query)) - - else -> - moveCaretTo(newOffset) - } - - when { - Finder.isShiftSelectEnabled && done -> selectRange(oldOffset, newOffset) - JumpMode.equals(TARGET) -> selectWordAtOffset(newOffset) - JumpMode.equals(DEFINE) && done -> gotoSymbolAction() - } - } - - private val aceJumpHistoryAppender = { - with(IdeDocumentHistory.getInstance(project) as IdeDocumentHistoryImpl) { - onSelectionChanged() - includeCurrentCommandAsNavigation() - includeCurrentPlaceAsChangePlace() - } - } - - /** - * Ensures each jump destination is appended to [IdeDocumentHistory] so that - * users can navigate forward and backward using the IDE actions. - */ - - private fun Editor.appendCaretPositionToEditorNavigationHistory() = - CommandProcessor.getInstance().executeCommand(project, - aceJumpHistoryAppender, "AceJumpHistoryAppender", - DocCommandGroupId.noneGroupId(document), document) - - private fun Editor.moveCaretTo(offset: Int) { - appendCaretPositionToEditorNavigationHistory() - selectionModel.removeSelection() - caretModel.moveToOffset(offset) - } - - private fun Editor.moveCaretToEnd(offset: Int) { - val ranges = ArrayList() - addWordSelection(settings.isCamelWords, editorText, offset, ranges) - - if (ranges.isEmpty()) { - moveCaretTo(offset) - } - else { - moveCaretTo(min(ranges[0].endOffset, editorText.length)) - } - } - - private fun countMatchingCharacters(offset: Int, query: String): Int { - var count = 0 - while (offset + count < editorText.length && count < query.length && editorText[offset + count] == query[count]) { - count++ - } - return count - } - - /** - * Selects a sequence of contiguous characters adjacent to the target offset - * matching [Character.isJavaIdentifierPart], or nothing at all. - * - * TODO: Make this language agnostic. - */ - - private fun Editor.selectWordAtOffset(offset: Int = caretModel.offset) { - val ranges = ArrayList() - addWordSelection(settings.isCamelWords, editorText, offset, ranges) - - ranges.ifEmpty { return } - - val firstRange = ranges[0] - val startOfWordOffset = max(0, firstRange.startOffset) - val endOfWordOffset = min(firstRange.endOffset, editorText.length) - - selectRange(startOfWordOffset, endOfWordOffset) - } - - /** - * Navigates to the target symbol's declaration, using [GotoDeclarationAction] - */ - - private fun gotoSymbolAction() = - runNow { - ActionManager.getInstance().tryToExecute(GotoDeclarationAction(), - ActionCommand.getInputEvent("NewFromTemplate"), null, null, true) - } - - override fun reset() = JumpMode.reset() -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/search/Pattern.kt b/src/main/kotlin/org/acejump/search/Pattern.kt new file mode 100644 index 00000000..e80c8e9e --- /dev/null +++ b/src/main/kotlin/org/acejump/search/Pattern.kt @@ -0,0 +1,9 @@ +package org.acejump.search + +enum class Pattern(val regex: String) { + START_OF_LINE("^.|^\\n"), + END_OF_LINE("\\n|\\Z"), + CODE_INDENTS("[^\\s].*|^\\n"), + LINE_MARK(END_OF_LINE.regex + "|" + START_OF_LINE.regex + "|" + CODE_INDENTS.regex), + ALL_WORDS("(?<=[^a-zA-Z0-9_]|\\A)[a-zA-Z0-9_]"); +} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/search/Scanner.kt b/src/main/kotlin/org/acejump/search/Scanner.kt deleted file mode 100644 index 7bba213f..00000000 --- a/src/main/kotlin/org/acejump/search/Scanner.kt +++ /dev/null @@ -1,76 +0,0 @@ -package org.acejump.search - -import com.intellij.openapi.diagnostic.Logger -import org.acejump.view.Model.LONG_DOCUMENT_LENGTH -import org.acejump.view.Model.editorText -import java.util.* -import kotlin.streams.toList - -/** - * Returns a set of indices indicating query matches, within the given range. - * These are full indices, i.e. are not offset to the beginning of the range. - */ - -internal object Scanner { - val cores = Runtime.getRuntime().availableProcessors() - 1 - private val logger = Logger.getInstance(Scanner::class.java) - - /** - * Returns [SortedSet] of indices matching the [model]. Providing a [cache] - * will filter prior results instead of searching the editor contents. - */ - - fun find(model: AceFindModel, boundaries: IntRange, cache: Set = emptySet()): SortedSet = - if (cache.isNotEmpty() || (boundaries.last - boundaries.first) < LONG_DOCUMENT_LENGTH) - editorText.search(model, cache, boundaries).toSortedSet() - else editorText.chunk().parallelStream().map { chunk -> - editorText.search(model, cache, chunk) - }.toList().flatten().toSortedSet() - - /** - * Divides lines of text into equally-sized chunks for parallelized search. - */ - - private fun String.chunk(): List { - val lines = splitToSequence("\n", "\r").toList() - val chunkSize = lines.size / cores + 1 - logger.info("Parallelizing ${lines.size}-line search across $cores cores") - var offset = 0 - return lines.chunked(chunkSize).map { - val len = it.joinToString("\n").length - (offset..(offset + len)).also { offset += len + 1 } - } - } - - /** - * Searches the [cache] (if it is populated), or else the whole document. - */ - - fun String.search(model: AceFindModel, cache: Set, chunk: IntRange) = - run { - val query = model.stringToFind - if (isEmpty() || query.isEmpty()) sortedSetOf() - else if (cache.isNotEmpty()) filterCache(cache, query) - else findAll(model.toRegex(), chunk) - }.toList() - - private fun String.filterCache(cache: Set, query: String) = - cache.asSequence().filter { index -> - regionMatches( - thisOffset = index + query.length - 1, - other = query.last().toString(), - otherOffset = 0, - length = 1, - ignoreCase = query.last().isLowerCase() - ) - }.toList() - - fun CharSequence.findAll(regex: Regex, chunk: IntRange) = - generateSequence( - seedFunction = { regex.find(this, chunk.first) }, - nextFunction = { result -> filterNext(result, chunk) } - ).map { it.range.first }.toList() - - fun filterNext(result: MatchResult, chunk: IntRange): MatchResult? = - result.next()?.let { if(it.range.first !in chunk) null else it } -} diff --git a/src/main/kotlin/org/acejump/search/SearchProcessor.kt b/src/main/kotlin/org/acejump/search/SearchProcessor.kt new file mode 100644 index 00000000..584c075b --- /dev/null +++ b/src/main/kotlin/org/acejump/search/SearchProcessor.kt @@ -0,0 +1,122 @@ +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.immutableText +import org.acejump.isWordPart +import org.acejump.matchesAt + +/** + * Searches editor text for matches of a [SearchQuery], and updates previous results when the user [type]s a character. + */ +internal class SearchProcessor private constructor(private val editor: Editor, query: SearchQuery, boundaries: Boundaries) { + companion object { + fun fromChar(editor: Editor, char: Char, boundaries: Boundaries): SearchProcessor { + return SearchProcessor(editor, SearchQuery.Literal(char.toString()), boundaries) + } + + fun fromRegex(editor: Editor, pattern: String, boundaries: Boundaries): SearchProcessor { + return SearchProcessor(editor, SearchQuery.RegularExpression(pattern), boundaries) + } + } + + var query = query + private set + + var results = IntArrayList(0) + private set + + init { + val regex = query.toRegex() + + if (regex != null) { + val offsetRange = boundaries.getOffsetRange(editor) + var result = regex.find(editor.immutableText, offsetRange.first) + + while (result != null) { + val index = result.range.first // For some reason regex matches can be out of bounds, but boundary check prevents an exception. + + if (boundaries.isOffsetInside(editor, index)) { + results.add(index) + } + else if (index > offsetRange.last) { + break + } + + result = result.next() + } + } + } + + /** + * Appends a character to the search query and removes all search results that no longer match the query. If the last typed character + * transitioned the search query from a non-word to a word, it notifies the [Tagger] to reassign all tags. If the new query does not + * make sense because it would remove every result, the change is reverted and this function returns false. + */ + fun type(char: Char, tagger: Tagger): Boolean { + val newQuery = query.rawText + char + val chars = editor.immutableText + val canMatchTag = tagger.canQueryMatchAnyTag(newQuery) + + // If the typed character is not compatible with any existing tag or as a continuation of any previous occurrence, reject the query + // change and return false to indicate that nothing else should happen. + + if (newQuery.length > 1 && !canMatchTag && results.none { chars.matchesAt(it, newQuery, ignoreCase = true) }) { + return false + } + + // If the typed character transitioned the search query from a non-word to a word, and the typed character does not belong to an + // existing tag, we basically restart the search at the beginning of every new word, and unmark existing results so that all tags get + // regenerated immediately afterwards. Although this causes tags to change, it is one solution for conflicts between tag characters and + // search query characters, and moving searches across word boundaries during search should be fairly uncommon. + + if (!canMatchTag && newQuery.length >= 2 && !newQuery[newQuery.length - 2].isWordPart && char.isWordPart) { + query = SearchQuery.Literal(char.toString()) + tagger.unmark() + + val iter = results.iterator() + while (iter.hasNext()) { + val movedOffset = iter.nextInt() + newQuery.length - 1 + + if (movedOffset < chars.length && chars[movedOffset].equals(char, ignoreCase = true)) { + iter.set(movedOffset) + } + else { + iter.remove() + } + } + } + else { + removeObsoleteResults(newQuery, tagger) + query = SearchQuery.Literal(newQuery) + } + + return true + } + + /** + * After updating the query, removes all results that no longer match the search query. + */ + private fun removeObsoleteResults(newQuery: String, tagger: Tagger) { + val lastCharOffset = newQuery.lastIndex + val lastChar = newQuery[lastCharOffset] + val ignoreCase = newQuery[0].isLowerCase() + val chars = editor.immutableText + + val remaining = IntArrayList() + val iter = results.iterator() + + while (iter.hasNext()) { + val offset = iter.nextInt() + val endOffset = offset + lastCharOffset + val lastTypedCharMatches = endOffset < chars.length && chars[endOffset].equals(lastChar, ignoreCase) + + if (lastTypedCharMatches || tagger.isQueryCompatibleWithTagAt(newQuery, offset)) { + remaining.add(offset) + } + } + + results = remaining + } +} diff --git a/src/main/kotlin/org/acejump/search/SearchQuery.kt b/src/main/kotlin/org/acejump/search/SearchQuery.kt new file mode 100644 index 00000000..365404bf --- /dev/null +++ b/src/main/kotlin/org/acejump/search/SearchQuery.kt @@ -0,0 +1,62 @@ +package org.acejump.search + +import org.acejump.countMatchingCharacters + +/** + * Defines the current search query for a session. + */ +internal sealed class SearchQuery { + abstract val rawText: String + + /** + * Returns how many characters the search occurrence highlight should cover. + */ + abstract fun getHighlightLength(text: CharSequence, offset: Int): Int + + /** + * Converts the query into a regular expression to find the initial matches. + */ + abstract fun toRegex(): Regex? + + /** + * Searches for all occurrences of a literal text query. If the first character of the query is lowercase, then the entire query will be + * case-insensitive. + * + * Each occurrence must either match the entire query, or match the query up to a point so that the rest of the query matches the + * beginning of a tag at the location of the occurrence. + */ + class Literal(override var rawText: String) : SearchQuery() { + init { + require(rawText.isNotEmpty()) + } + + override fun getHighlightLength(text: CharSequence, offset: Int): Int { + return text.countMatchingCharacters(offset, rawText) + } + + override fun toRegex(): Regex { + val options = mutableSetOf(RegexOption.MULTILINE) + + if (rawText.first().isLowerCase()) { + options.add(RegexOption.IGNORE_CASE) + } + + return Regex(Regex.escape(rawText), options) + } + } + + /** + * Searches for all matches of a regular expression. + */ + class RegularExpression(private var pattern: String) : SearchQuery() { + override val rawText = "" + + override fun getHighlightLength(text: CharSequence, offset: Int): Int { + return 1 + } + + override fun toRegex(): Regex { + return Regex(pattern, setOf(RegexOption.MULTILINE, RegexOption.IGNORE_CASE)) + } + } +} diff --git a/src/main/kotlin/org/acejump/search/Solver.kt b/src/main/kotlin/org/acejump/search/Solver.kt new file mode 100644 index 00000000..d9a6863e --- /dev/null +++ b/src/main/kotlin/org/acejump/search/Solver.kt @@ -0,0 +1,186 @@ +package org.acejump.search + +import com.intellij.openapi.editor.Editor +import it.unimi.dsi.fastutil.ints.* +import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap +import org.acejump.boundaries.EditorOffsetCache +import org.acejump.boundaries.StandardBoundaries +import org.acejump.config.AceConfig +import org.acejump.immutableText +import org.acejump.input.KeyLayoutCache +import org.acejump.isWordPart +import org.acejump.wordEndPlus +import java.util.* +import kotlin.collections.HashMap +import kotlin.collections.HashSet +import kotlin.math.max + +/* + * Solves the Tag Assignment Problem. The tag assignment problem can be stated + * thusly: Given a set of indices I in document d, and a set of tags T, find a + * bijection f: T*⊂T → I*⊂I s.t. d[i..k] + t ∉ d[i'..(k + |t|)], ∀ i' ∈ I\{i}, + * ∀ k ∈ (i, |d|-|t|], where t ∈ T, i ∈ I. Maximize |I*|. This can be relaxed + * to t=t[0] and ∀ k ∈ (i, i+K] for some fixed K, in most natural documents. + * + * More concretely, tags are typically two-character strings containing alpha- + * numeric symbols. Documents are plaintext files. Indices are produced by a + * search query of length N, i.e. the preceding N characters of every index i in + * document d are identical. For characters proceeding d[i], all bets are off. + * We can assume that P(d[i]|d[i-1]) has some structure for d~D. Ultimately, we + * want a fast algorithm which maximizes the number of tagged document indices. + * + * Tags are used by the typist to select indices within a document. To select an + * index, the typist starts by activating AceJump and searching for a character. + * As soon as the first character is received, we begin to scan the document for + * matching locations and assign as many valid tags as possible. When subsequent + * characters are received, we refine the search results to match either: + * + * 1.) The plaintext query alone, or + * 2.) The concatenation of plaintext query and partial tag + * + * The constraint in paragraph no. 1 tries to impose the following criteria: + * + * 1.) All valid key sequences will lead to a unique location in the document + * 2.) All indices in the document will be reachable by a short key sequence + * + * If there is an insufficient number of two-character tags to cover every index + * (which typically occurs when the user searches for a common character within + * a long document), then we attempt to maximize the number of tags assigned to + * document indices. The key is, all tags must be assigned as soon as possible, + * i.e. as soon as the first character is received or whenever the user ceases + * typing (at the very latest). Once assigned, a visible tag must never change + * at any time during the selection process, so as not to confuse the user. + */ + +internal class Solver private constructor(private val editor: Editor, private val queryLength: Int, private val results: IntList) { + companion object { + fun solve(editor: Editor, query: SearchQuery, results: IntList, tags: List, cache: EditorOffsetCache): Map { + return Solver(editor, max(1, query.rawText.length), results).map(tags, cache) + } + } + + private var newTags = Object2IntOpenHashMap(KeyLayoutCache.allPossibleTags.size) + private val newTagIndices = IntOpenHashSet() + + private var allWordFragments = HashSet(results.size).apply { + val iter = results.iterator() + while (iter.hasNext()) { + forEachWordFragment(iter.nextInt()) { add(it) } + } + } + + fun map(availableTags: List, cache: EditorOffsetCache): Map { + val eligibleSitesByTag = HashMap(100) + val tagsByFirstLetter = availableTags.groupBy { it[0] } + + val iter = results.iterator() + while (iter.hasNext()) { + val site = iter.nextInt() + + for ((firstLetter, tags) in tagsByFirstLetter.entries) { + if (canTagBeginWithChar(site, firstLetter)) { + for (tag in tags) { + eligibleSitesByTag.getOrPut(tag) { IntArrayList(10) }.add(site) + } + } + } + } + + val matchingSites = HashMap() + val matchingSitesAsArrays = IdentityHashMap() // Keys are guaranteed to be from a single collection. + + val siteOrder = siteOrder(cache) + val tagOrder = KeyLayoutCache.tagOrder + .thenComparingInt { eligibleSitesByTag.getValue(it).size } + .thenBy(AceConfig.layout.priority(String::last)) + + val sortedTags = eligibleSitesByTag.keys.toMutableList().apply { + sortWith(tagOrder) + } + + for ((key, value) in eligibleSitesByTag.entries) { + matchingSitesAsArrays[key] = matchingSites.getOrPut(value) { + value.toIntArray().apply { IntArrays.mergeSort(this, siteOrder) } + } + } + + var totalAssigned = 0 + + for (tag in sortedTags) { + if (totalAssigned == results.size) { + break + } + + if (tryToAssignTag(tag, matchingSitesAsArrays.getValue(tag))) { + totalAssigned++ + } + } + + return newTags + } + + private fun tryToAssignTag(tag: String, sites: IntArray): Boolean { + if (newTags.containsKey(tag)) { + return false + } + + val index = sites.firstOrNull { it !in newTagIndices } ?: return false + + @Suppress("ReplacePutWithAssignment") + newTags.put(tag, index) + newTagIndices.add(index) + return true + } + + private fun siteOrder(cache: EditorOffsetCache) = IntComparator { a, b -> + val aIsVisible = StandardBoundaries.VISIBLE_ON_SCREEN.isOffsetInside(editor, a, cache) + val bIsVisible = StandardBoundaries.VISIBLE_ON_SCREEN.isOffsetInside(editor, b, cache) + + if (aIsVisible != bIsVisible) { + // Sites in immediate view should come first. + return@IntComparator if (aIsVisible) -1 else 1 + } + + val chars = editor.immutableText + val aIsNotWordStart = chars[max(0, a - 1)].isWordPart + val bIsNotWordStart = chars[max(0, b - 1)].isWordPart + + if (aIsNotWordStart != bIsNotWordStart) { + // Ensure that the first letter of a word is prioritized for tagging. + return@IntComparator if (bIsNotWordStart) -1 else 1 + } + + when { + a < b -> -1 + a > b -> 1 + else -> 0 + } + } + + private fun canTagBeginWithChar(site: Int, char: Char): Boolean { + if (char.toString() in allWordFragments) { + return false + } + + forEachWordFragment(site) { + if (it + char in allWordFragments) { + return false + } + } + + return true + } + + private inline fun forEachWordFragment(site: Int, callback: (String) -> Unit) { + val chars = editor.immutableText + val left = max(0, site + queryLength - 1) + val right = chars.wordEndPlus(site) + + val builder = StringBuilder(1 + right - left) + + for (i in left..right) { + builder.append(chars[i].toLowerCase()) + callback(builder.toString()) + } + } +} diff --git a/src/main/kotlin/org/acejump/search/Tagger.kt b/src/main/kotlin/org/acejump/search/Tagger.kt new file mode 100644 index 00000000..f0a7fb85 --- /dev/null +++ b/src/main/kotlin/org/acejump/search/Tagger.kt @@ -0,0 +1,195 @@ +package org.acejump.search + +import com.google.common.collect.HashBiMap +import com.intellij.openapi.editor.Editor +import it.unimi.dsi.fastutil.ints.IntArrayList +import it.unimi.dsi.fastutil.ints.IntList +import org.acejump.ExternalUsage +import org.acejump.boundaries.EditorOffsetCache +import org.acejump.boundaries.StandardBoundaries +import org.acejump.immutableText +import org.acejump.input.KeyLayoutCache.allPossibleTags +import org.acejump.isWordPart +import org.acejump.matchesAt +import org.acejump.view.Tag +import java.util.AbstractMap.SimpleImmutableEntry +import kotlin.collections.component1 +import kotlin.collections.component2 + +/** + * Assigns tags to search occurrences, updates them when the search query changes, and requests a jump if the search query matches a tag. + */ +internal class Tagger(private val editor: Editor) { + private var tagMap = HashBiMap.create() + + @ExternalUsage + val tags + get() = tagMap.map { SimpleImmutableEntry(it.key, it.value) }.sortedBy { it.value } + + /** + * Removes all markers, allowing them to be regenerated from scratch. + */ + fun unmark() { + tagMap = HashBiMap.create() + } + + /** + * Assigns tags to as many results as possible, keeping previously assigned tags. Returns a [TaggingResult.Jump] if the current search + * query matches any existing tag and we should jump to it and end the session, or [TaggingResult.Mark] to continue the session with + * updated tag markers. + * + * Note that the [results] collection will be mutated. + */ + fun markOrJump(query: SearchQuery, results: IntList): TaggingResult { + val isRegex = query is SearchQuery.RegularExpression + val queryText = if (isRegex) " ${query.rawText}" else query.rawText[0] + query.rawText.drop(1).toLowerCase() + + val availableTags = allPossibleTags.filter { !queryText.endsWith(it[0]) && it !in tagMap } + + if (!isRegex) { + for (entry in tagMap.entries) { + if (entry solves queryText) { + return TaggingResult.Jump(entry.value) + } + } + + if (queryText.length == 1) { + removeResultsWithOverlappingTags(results) + } + } + + if (!isRegex || tagMap.isEmpty()) { + tagMap = assignTagsAndMerge(results, availableTags, query, queryText) + } + + return TaggingResult.Mark(createTagMarkers(results, query.rawText.ifEmpty { null })) + } + + /** + * Assigns as many unassigned tags as possible, and merges them with the existing compatible tags. + */ + private fun assignTagsAndMerge(results: IntList, availableTags: List, query: SearchQuery, queryText: String): HashBiMap { + val cache = EditorOffsetCache.new() + + results.sort { a, b -> + val aIsVisible = StandardBoundaries.VISIBLE_ON_SCREEN.isOffsetInside(editor, a, cache) + val bIsVisible = StandardBoundaries.VISIBLE_ON_SCREEN.isOffsetInside(editor, b, cache) + + when { + aIsVisible && !bIsVisible -> -1 + bIsVisible && !aIsVisible -> 1 + else -> 0 + } + } + + val allAssignedTags = mutableMapOf() + val oldCompatibleTags = tagMap.filter { isTagCompatibleWithQuery(it.key, it.value, queryText) || it.value in results } + val vacantResults: IntList + + if (oldCompatibleTags.isEmpty()) { + vacantResults = results + } + else { + vacantResults = IntArrayList() + + val iter = results.iterator() + while (iter.hasNext()) { + val offset = iter.nextInt() + + if (offset !in oldCompatibleTags.values) { + vacantResults.add(offset) + } + } + } + + allAssignedTags.putAll(oldCompatibleTags) + allAssignedTags.putAll(Solver.solve(editor, query, vacantResults, availableTags, cache)) + + return allAssignedTags.mapKeysTo(HashBiMap.create(allAssignedTags.size)) { (tag, _) -> + // Avoid matching query - will trigger a jump. + // TODO: lift this constraint. + val queryEndsWith = queryText.endsWith(tag[0]) || queryText.endsWith(tag) + + if (!queryEndsWith && canShortenTag(tag, allAssignedTags)) + tag[0].toString() + else + tag + } + } + + private infix fun Map.Entry.solves(query: String): Boolean { + return query.endsWith(key, true) && isTagCompatibleWithQuery(key, value, query) + } + + private fun isTagCompatibleWithQuery(tag: String, offset: Int, query: String): Boolean { + return editor.immutableText.matchesAt(offset, getPlaintextPortion(query, tag), ignoreCase = true) + } + + fun isQueryCompatibleWithTagAt(query: String, offset: Int): Boolean { + return tagMap.inverse()[offset].let { it != null && isTagCompatibleWithQuery(it, offset, query) } + } + + fun canQueryMatchAnyTag(query: String): Boolean { + return tagMap.any { (tag, offset) -> + val tagPortion = getTagPortion(query, tag) + tagPortion.isNotEmpty() && tag.startsWith(tagPortion, ignoreCase = true) && isTagCompatibleWithQuery(tag, offset, query) + } + } + + private fun removeResultsWithOverlappingTags(results: IntList) { + val iter = results.iterator() + val chars = editor.immutableText + + while (iter.hasNext()) { + if (!chars.canTagWithoutOverlap(iter.nextInt())) { + iter.remove() // Very uncommon, so slow removal is fine. + } + } + } + + private fun createTagMarkers(results: IntList, literalQueryText: String?): List { + val tagMapInv = tagMap.inverse() + return results.mapNotNull { index -> tagMapInv[index]?.let { tag -> Tag.create(editor, tag, index, literalQueryText) } } + } + + private companion object { + private fun CharSequence.canTagWithoutOverlap(loc: Int) = when { + loc - 1 < 0 -> true + loc + 1 >= length -> true + this[loc] isUnlike this[loc - 1] -> true + this[loc] isUnlike this[loc + 1] -> true + this[loc] != this[loc - 1] -> true + this[loc] != this[loc + 1] -> true + this[loc + 1] == '\r' || this[loc + 1] == '\n' -> true + this[loc - 1] == this[loc] && this[loc] == this[loc + 1] -> false + this[loc + 1].isWhitespace() && this[(loc + 2).coerceAtMost(length - 1)].isWhitespace() -> true + else -> false + } + + private infix fun Char.isUnlike(other: Char): Boolean { + return this.isWordPart xor other.isWordPart || this.isWhitespace() xor other.isWhitespace() + } + + private fun getPlaintextPortion(query: String, tag: String) = when { + query.endsWith(tag, true) -> query.dropLast(tag.length) + query.endsWith(tag.first(), true) -> query.dropLast(1) + else -> query + } + + private fun getTagPortion(query: String, tag: String) = when { + query.endsWith(tag, true) -> query.takeLast(tag.length) + query.endsWith(tag.first(), true) -> query.takeLast(1) + else -> "" + } + + private fun canShortenTag(tag: String, tagMap: Map): Boolean { + for (other in tagMap.keys) { + if (tag != other && tag[0] == other[0]) { + return false + } + } + + return true + } + } +} diff --git a/src/main/kotlin/org/acejump/search/TaggingResult.kt b/src/main/kotlin/org/acejump/search/TaggingResult.kt new file mode 100644 index 00000000..5dd813e2 --- /dev/null +++ b/src/main/kotlin/org/acejump/search/TaggingResult.kt @@ -0,0 +1,8 @@ +package org.acejump.search + +import org.acejump.view.Tag + +internal sealed class TaggingResult { + class Jump(val offset: Int) : TaggingResult() + class Mark(val tags: List) : TaggingResult() +} diff --git a/src/main/kotlin/org/acejump/session/EditorSettings.kt b/src/main/kotlin/org/acejump/session/EditorSettings.kt new file mode 100644 index 00000000..3b16a511 --- /dev/null +++ b/src/main/kotlin/org/acejump/session/EditorSettings.kt @@ -0,0 +1,29 @@ +package org.acejump.session + +import com.intellij.openapi.editor.Editor + +/** + * Holds [Editor] caret settings. The settings are saved the moment a [Session] starts, modified to indicate AceJump states, and restored + * once the [Session] ends. + */ +internal data class EditorSettings(private val isBlockCursor: Boolean, private val isBlinkCaret: Boolean) { + companion object { + fun setup(editor: Editor): EditorSettings { + val settings = editor.settings + val original = EditorSettings( + isBlockCursor = settings.isBlockCursor, + isBlinkCaret = settings.isBlinkCaret + ) + + settings.isBlockCursor = true + settings.isBlinkCaret = false + + return original + } + } + + fun restore(editor: Editor) = editor.settings.let { + it.isBlockCursor = isBlockCursor + it.isBlinkCaret = isBlinkCaret + } +} diff --git a/src/main/kotlin/org/acejump/session/Session.kt b/src/main/kotlin/org/acejump/session/Session.kt new file mode 100644 index 00000000..60e51240 --- /dev/null +++ b/src/main/kotlin/org/acejump/session/Session.kt @@ -0,0 +1,195 @@ +package org.acejump.session + +import com.intellij.openapi.actionSystem.DataContext +import com.intellij.openapi.editor.Editor +import com.intellij.openapi.editor.ScrollType +import com.intellij.openapi.editor.actionSystem.TypedActionHandler +import com.intellij.openapi.editor.colors.EditorColors +import org.acejump.ExternalUsage +import org.acejump.action.TagJumper +import org.acejump.action.TagVisitor +import org.acejump.boundaries.Boundaries +import org.acejump.boundaries.EditorOffsetCache +import org.acejump.boundaries.StandardBoundaries +import org.acejump.config.AceConfig +import org.acejump.input.EditorKeyListener +import org.acejump.input.JumpMode +import org.acejump.input.JumpModeTracker +import org.acejump.input.KeyLayoutCache +import org.acejump.search.* +import org.acejump.view.TagCanvas +import org.acejump.view.TextHighlighter + +/** + * Manages an AceJump session for a single [Editor]. + */ +class Session(private val editor: Editor) { + private companion object { + private val defaultBoundaries + get() = if (AceConfig.searchWholeFile) StandardBoundaries.WHOLE_FILE else StandardBoundaries.VISIBLE_ON_SCREEN + } + + private val originalSettings = EditorSettings.setup(editor) + + private val jumpModeTracker = JumpModeTracker() + private var jumpMode = JumpMode.DISABLED + set(value) { + field = value + + if (value === JumpMode.DISABLED) { + end() + } + else { + searchProcessor?.let { textHighlighter.render(it.results, it.query, jumpMode) } + editor.colorsScheme.setColor(EditorColors.CARET_COLOR, value.caretColor) + editor.contentComponent.repaint() + } + } + + private var searchProcessor: SearchProcessor? = null + private var tagger = Tagger(editor) + + private val tagJumper + get() = TagJumper(editor, jumpMode, searchProcessor) + + private val tagVisitor + get() = searchProcessor?.let { TagVisitor(editor, it, tagJumper) } + + private val textHighlighter = TextHighlighter(editor) + private val tagCanvas = TagCanvas(editor) + + @ExternalUsage + val tags + get() = tagger.tags + + init { + KeyLayoutCache.ensureInitialized(AceConfig.settings) + + EditorKeyListener.attach(editor, object : TypedActionHandler { + override fun execute(editor: Editor, charTyped: Char, context: DataContext) { + var processor = searchProcessor + + if (processor == null) { + processor = SearchProcessor.fromChar(editor, charTyped, defaultBoundaries).also { searchProcessor = it } + } + else if (!processor.type(charTyped, tagger)) { + return + } + + updateSearch(processor, shiftMode = charTyped.isUpperCase()) + } + }) + } + + /** + * Updates text highlights and tag markers according to the current search state. Dispatches jumps if the search query matches a tag. + * If all tags are outside view, scrolls to the closest one. + */ + private fun updateSearch(processor: SearchProcessor, shiftMode: Boolean = false) { + val query = processor.query + val results = processor.results + + textHighlighter.render(results, query, jumpMode) + + when (val result = tagger.markOrJump(query, results.clone())) { + is TaggingResult.Jump -> { + tagJumper.jump(result.offset, shiftMode) + tagCanvas.removeMarkers() + end() + } + + is TaggingResult.Mark -> { + val tags = result.tags + tagCanvas.setMarkers(tags, isRegex = query is SearchQuery.RegularExpression) + + val cache = EditorOffsetCache.new() + val boundaries = StandardBoundaries.VISIBLE_ON_SCREEN + + if (tags.none { boundaries.isOffsetInside(editor, it.offsetL, cache) || boundaries.isOffsetInside(editor, it.offsetR, cache) }) { + tagVisitor?.scrollToClosest() + } + } + } + } + + /** + * Starts a regular expression search. If a search was already active, it will be reset alongside its tags and highlights. + */ + fun startRegexSearch(pattern: String, boundaries: Boundaries) { + tagger = Tagger(editor) + tagCanvas.setMarkers(emptyList(), isRegex = true) + updateSearch(SearchProcessor.fromRegex(editor, pattern, boundaries.intersection(defaultBoundaries)).also { searchProcessor = it }) + } + + /** + * Starts a regular expression search. If a search was already active, it will be reset alongside its tags and highlights. + */ + fun startRegexSearch(pattern: Pattern, boundaries: Boundaries) { + startRegexSearch(pattern.regex, boundaries) + } + + /** + * See [JumpModeTracker.cycle]. + */ + fun cycleJumpMode() { + jumpMode = jumpModeTracker.cycle() + } + + /** + * See [JumpModeTracker.toggle] + */ + fun toggleJumpMode(newMode: JumpMode) { + jumpMode = jumpModeTracker.toggle(newMode) + } + + /** + * See [TagVisitor.visitPrevious]. If there are no tags, nothing happens. + */ + fun visitPreviousTag() { + if (tagVisitor?.visitPrevious() == true) { + end() + } + } + + /** + * See [TagVisitor.visitNext]. If there are no tags, nothing happens. + */ + fun visitNextTag() { + if (tagVisitor?.visitNext() == true) { + end() + } + } + + /** + * Ends this session. + */ + fun end() { + SessionManager.end(editor) + } + + /** + * Clears any currently active search, tags, and highlights. Does not reset [JumpMode]. + */ + fun restart() { + tagger = Tagger(editor) + searchProcessor = null + tagCanvas.removeMarkers() + textHighlighter.reset() + } + + /** + * Should only be used from [SessionManager] to dispose a successfully ended session. + */ + internal fun dispose() { + tagger = Tagger(editor) + EditorKeyListener.detach(editor) + tagCanvas.unbind() + textHighlighter.reset() + + if (!editor.isDisposed) { + originalSettings.restore(editor) + editor.colorsScheme.setColor(EditorColors.CARET_COLOR, JumpMode.DISABLED.caretColor) + editor.scrollingModel.scrollToCaret(ScrollType.MAKE_VISIBLE) + } + } +} diff --git a/src/main/kotlin/org/acejump/session/SessionManager.kt b/src/main/kotlin/org/acejump/session/SessionManager.kt new file mode 100644 index 00000000..c1e0f6a7 --- /dev/null +++ b/src/main/kotlin/org/acejump/session/SessionManager.kt @@ -0,0 +1,41 @@ +package org.acejump.session + +import com.intellij.openapi.editor.Editor + +/** + * Manages active [Session]s in [Editor]s. There may only be one [Session] per [Editor], but multiple [Session]s across multiple [Editor]s + * may be active at once. + * + * It is possible for an [Editor] to be disposed with an active [Session]. In such case, the reference to both will remain until a new + * [Session] starts, at which point the [SessionManager.cleanup] method will purge disposed [Editor]s. + */ +object SessionManager { + private val sessions = HashMap(4) + + /** + * Starts a new [Session], or returns an existing [Session] if the specified [Editor] already has one. + */ + fun start(editor: Editor): Session { + return sessions.getOrPut(editor) { cleanup(); Session(editor) } + } + + /** + * Returns the active [Session] in the specified [Editor], or null if the [Editor] has no active session. + */ + operator fun get(editor: Editor): Session? { + return sessions[editor] + } + + /** + * Ends the active [Session] in the specified [Editor], or does nothing if the [Editor] has no active session. + */ + fun end(editor: Editor) { + sessions.remove(editor)?.dispose() + } + + private fun cleanup() { + for (disposedEditor in sessions.keys.filter { it.isDisposed }) { + sessions.remove(disposedEditor)?.dispose() + } + } +} diff --git a/src/main/kotlin/org/acejump/view/Boundary.kt b/src/main/kotlin/org/acejump/view/Boundary.kt deleted file mode 100644 index da1a0200..00000000 --- a/src/main/kotlin/org/acejump/view/Boundary.kt +++ /dev/null @@ -1,69 +0,0 @@ -package org.acejump.view - -import org.acejump.search.getLineEndOffset -import org.acejump.search.getLineStartOffset -import org.acejump.view.Model.editor -import org.acejump.view.Model.editorText -import org.acejump.view.Model.viewBounds -import kotlin.math.max -import kotlin.math.min - -/** - * Interface which defines the boundary inside the file to be searched - */ - -enum class Boundary: ClosedRange { - // Search the complete file - FULL_FILE_BOUNDARY { - override val start: Int - get() = 0 - override val endInclusive: Int - get() = editorText.length - }, - // Search only on the screen - SCREEN_BOUNDARY { - override val start: Int - get() = Model.viewBounds.first - override val endInclusive: Int - get() = Model.viewBounds.last - }, - // Search from the start of the screen to the caret - BEFORE_CARET_BOUNDARY { - override val start: Int - get() = max(0, viewBounds.first) - override val endInclusive: Int - get() = min(editor.caretModel.offset, viewBounds.last) - }, - // Search from the caret to the end of the screen - AFTER_CARET_BOUNDARY { - override val start: Int - get() = max(editor.caretModel.offset, viewBounds.first) - override val endInclusive: Int - get() = viewBounds.last - }, - // Search on the current line - CURRENT_LINE_BOUNDARY { - override val start: Int - get() = editor.getLineStartOffset(editor.caretModel.logicalPosition.line) - override val endInclusive: Int - get() = editor.getLineEndOffset(editor.caretModel.logicalPosition.line) - }, - // Search after caret within line - CURRENT_LINE_AFTER_CARET_BOUNDARY { - override val start: Int - get() = max(editor.caretModel.offset, viewBounds.first) - override val endInclusive: Int - get() = editor.getLineEndOffset(editor.caretModel.logicalPosition.line) - }, - // Search before caret within line - CURRENT_LINE_BEFORE_CARET_BOUNDARY { - override val start: Int - get() = editor.getLineStartOffset(editor.caretModel.logicalPosition.line) - override val endInclusive: Int - get() = min(editor.caretModel.offset, viewBounds.last) - }; - - fun intRange() = IntRange(start, endInclusive) - - override fun toString() = super.toString() + " (${intRange()}) " -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/view/Canvas.kt b/src/main/kotlin/org/acejump/view/Canvas.kt deleted file mode 100755 index 4a10f6b2..00000000 --- a/src/main/kotlin/org/acejump/view/Canvas.kt +++ /dev/null @@ -1,65 +0,0 @@ -package org.acejump.view - -import com.intellij.openapi.application.ApplicationInfo -import com.intellij.openapi.diagnostic.Logger -import com.intellij.openapi.editor.Editor -import org.acejump.search.* -import org.acejump.view.Model.fontWidth -import org.acejump.view.Model.viewBounds -import java.awt.Graphics -import java.awt.Point -import javax.swing.JComponent -import javax.swing.SwingUtilities.convertPoint - -/** - * Overlay composed of all tag [Marker]s. Maintains a registry of tags' visual - * positions once assigned, so that we do not paint two tags to the same space. - */ - -object Canvas: JComponent(), Resettable { - private val logger = Logger.getInstance(Canvas::class.java) - private val occupied = hashSetOf() - @Volatile - var jumpLocations: Collection = emptyList() - set(value) { - field = value - runLater { repaint() } - } - - fun Editor.bindCanvas() { - reset() - storeBounds() - contentComponent.add(Canvas) - setBounds(0, 0, contentComponent.width, contentComponent.height) - - if (ApplicationInfo.getInstance().build.components.first() < 173) { - val loc = convertPoint(Canvas, location, component.rootPane) - setLocation(-loc.x, -loc.y) - } - } - - private fun Editor.storeBounds() { - viewBounds = getView() - logger.info("View bounds: $viewBounds (lines " + - "${offsetToLogicalPosition(viewBounds.first).line}.." + - "${offsetToLogicalPosition(viewBounds.last).line})") - } - - override fun paint(graphics: Graphics) { - jumpLocations.ifEmpty { return } - - super.paint(graphics) - occupied.clear() - jumpLocations.forEach { it.paintMe(graphics) } - } - - fun registerTag(p: Point, tag: String) = - (-1..tag.length).forEach { occupied.add(Point(p.x + it * fontWidth, p.y)) } - - fun isFree(point: Point) = point !in occupied - - override fun reset() { - jumpLocations = emptyList() - occupied.clear() - } -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/view/Marker.kt b/src/main/kotlin/org/acejump/view/Marker.kt deleted file mode 100644 index f128f5a7..00000000 --- a/src/main/kotlin/org/acejump/view/Marker.kt +++ /dev/null @@ -1,230 +0,0 @@ -package org.acejump.view - -import com.intellij.openapi.editor.Editor -import com.intellij.openapi.editor.markup.CustomHighlighterRenderer -import com.intellij.openapi.editor.markup.RangeHighlighter -import org.acejump.config.AceConfig -import org.acejump.control.Selector -import org.acejump.label.Tagger.regex -import org.acejump.search.* -import org.acejump.search.JumpMode.TARGET -import org.acejump.view.Marker.Alignment.* -import org.acejump.view.Model.arcD -import org.acejump.view.Model.editor -import org.acejump.view.Model.fontHeight -import org.acejump.view.Model.fontWidth -import org.acejump.view.Model.naturalCaretColor -import org.acejump.view.Model.rectHeight -import org.acejump.view.Model.rectVOffset -import java.awt.* -import java.awt.AlphaComposite.SRC_OVER -import java.awt.AlphaComposite.getInstance -import java.awt.RenderingHints.KEY_ANTIALIASING -import java.awt.RenderingHints.VALUE_ANTIALIAS_ON -import org.acejump.view.Model.editorText as text - -/** - * Represents the visual component of a tag, which gets painted to the screen. - * All functionality related to tag highlighting including visual appearance, - * alignment and painting should be handled here. Tags are "captioned" with two - * or fewer characters. To select a tag, a user will type the tag's assigned - * "caption", which will move the caret to a known index in the document. - * - * TODO: Clean up this class. - */ - -class Marker { - val index: Int - private val query: String - val tag: String? - private val tagUpperCase: String? - private var srcPoint: Point - private var queryLength: Int - private var trueOffset: Int - private val searchWidth: Int - private val tgIdx: Int - private val start: Point - private val startY: Int - private var tagPoint: Point - private var yPos: Int - private var alignment: Alignment - private val endsWith: Boolean - - constructor(query: String, tag: String?, index: Int) { - this.query = query - this.tag = tag - this.tagUpperCase = tag?.toUpperCase() - this.index = index - val lastQueryChar = query.last() - endsWith = tag != null && lastQueryChar == tag[0] - queryLength = query.length - if(endsWith) 1 else 0 - trueOffset = query.length - 1 - - searchWidth = if (regex) 0 else queryLength * fontWidth - - var i = 1 - while (i < query.length && index + i < text.length && - query[i].equals(text[index + i], ignoreCase = true)) i++ - trueOffset = i - 1 - queryLength = i - - tgIdx = index + trueOffset - - editor.run { - start = getPoint(index) - srcPoint = getPointRelative(start, contentComponent) - tagPoint = - if (index == tgIdx) srcPoint - else getPointRelative(getPoint(tgIdx), contentComponent) - } - - startY = start.y + rectVOffset - yPos = tagPoint.y + rectVOffset - alignment = RIGHT - } - - enum class Alignment { /*TOP, BOTTOM,*/ LEFT, RIGHT, NONE } - - /** - * Called by AceJump as a renderable element of [Canvas]. Paints [tag]s. - */ - - fun paintMe(graphics: Graphics) = (graphics as Graphics2D).run { - setRenderingHint(KEY_ANTIALIASING, VALUE_ANTIALIAS_ON) - - if (!Finder.skim) - tag?.alignTag(Canvas) - ?.apply { Canvas.registerTag(this, tag) } - ?.let { - if (alignment == NONE) return - highlightTag(it); drawTagForeground(it) - } - } - - /** - * Called by IntelliJ as a [CustomHighlighterRenderer]. Paints [highlight]s. - */ - - companion object: CustomHighlighterRenderer { - override fun paint(editor: Editor, highlighter: RangeHighlighter, g: Graphics) = - (g as Graphics2D).run { - setRenderingHint(KEY_ANTIALIASING, VALUE_ANTIALIAS_ON) - color = AceConfig.textHighlightColor - val start = editor.getPoint(highlighter.startOffset) - val startY = start.y + rectVOffset - - if (regex) { - highlightRegex(start.x, startY) - } - else { - val queryLength = highlighter.endOffset - highlighter.startOffset - val searchWidth = queryLength * fontWidth - fillRoundRect(start.x, startY, searchWidth, rectHeight, arcD, arcD) - if (JumpMode.equals(TARGET)) { - surroundTargetWord(highlighter.startOffset, startY) - } - } - - // TODO this is a lag-fest, results should be cached before this gets turned back on - //if (highlighter.startOffset == Selector.nearestVisibleMatches().firstOrNull()) { - // color = naturalCaretColor - // drawLine(start.x, startY, start.x, startY + rectHeight) - //} - } - - private fun Graphics2D.highlightRegex(x: Int, y: Int) { - composite = getInstance(SRC_OVER, 0.40.toFloat()) - fillRoundRect(x, y, fontWidth, rectHeight, arcD, arcD) - } - - private fun Graphics2D.surroundTargetWord(index: Int, startY: Int) { - if (!text[index].isLetterOrDigit()) { - return - } - - color = AceConfig.targetModeColor - val (wordStart, wordEnd) = text.wordBounds(index) - - val xPos = editor.getPoint(wordStart).x - val wordWidth = (wordEnd - wordStart) * fontWidth - - drawRoundRect(xPos, startY, wordWidth, rectHeight, arcD, arcD) - } - } - - private fun Graphics2D.drawTagForeground(tagPosition: Point) { - font = Model.font - color = AceConfig.tagForegroundColor - composite = getInstance(SRC_OVER, 1.toFloat()) - - drawString(tagUpperCase!!, tagPosition.x, tagPosition.y + fontHeight) - } - - // TODO: Fix tag alignment and visibility issues - // https://github.com/acejump/AceJump/issues/233 - // https://github.com/acejump/AceJump/issues/228 - private fun String.alignTag(canvas: Canvas): Point { - val xPos = tagPoint.x + fontWidth -// val top = Point(x - fontWidth, y - fontHeight) -// val bottom = Point(x - fontWidth, y + fontHeight) - val left = Point(srcPoint.x - fontWidth * length, yPos) - val right = Point(xPos, yPos) - - val nextCharIsWhiteSpace = text.length <= index + 1 || - text[index + 1].isWhitespace() - - val canAlignRight = canvas.isFree(right) - val isFirstCharacterOfLine = editor.isFirstCharacterOfLine(index) - val canAlignLeft = !isFirstCharacterOfLine && canvas.isFree(left) - - alignment = when { - nextCharIsWhiteSpace -> RIGHT - isFirstCharacterOfLine -> RIGHT - canAlignLeft -> LEFT - canAlignRight -> RIGHT - else -> NONE - } - - return when (alignment) { -// TOP -> top - LEFT -> left - RIGHT -> right -// BOTTOM -> bottom - NONE -> Point(-1, -1) - } - } - - private fun Graphics2D.highlightTag(point: Point?) { - if (query.isEmpty() || alignment == NONE) return - - var tagX = point!!.x - var tagWidth = tag?.length?.times(fontWidth) ?: 0 - val charIndex = index + query.length - 1 - val beforeEnd = charIndex < text.length - val textChar = if (beforeEnd) text[charIndex].toLowerCase() else 0.toChar() - - fun highlightFirst() { - composite = getInstance(SRC_OVER, 0.40.toFloat()) - color = AceConfig.textHighlightColor - - if (endsWith && query.last() != textChar) { - fillRoundRect(tagX, yPos, fontWidth, rectHeight, arcD, arcD) - tagX += fontWidth - tagWidth -= fontWidth - } - } - - fun highlightLast() { - color = AceConfig.tagBackgroundColor - if (alignment != RIGHT || text.hasSpaceRight(index) || regex) - composite = getInstance(SRC_OVER, 1.toFloat()) - - fillRoundRect(tagX, yPos, tagWidth, rectHeight, arcD, arcD) - } - - highlightFirst() - highlightLast() - } - - infix fun inside(viewBounds: IntRange) = index in viewBounds -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/view/Model.kt b/src/main/kotlin/org/acejump/view/Model.kt deleted file mode 100644 index aae28e38..00000000 --- a/src/main/kotlin/org/acejump/view/Model.kt +++ /dev/null @@ -1,73 +0,0 @@ -package org.acejump.view - -import com.github.promeg.pinyinhelper.Pinyin -import com.intellij.openapi.editor.Editor -import com.intellij.openapi.editor.colors.EditorColors.CARET_COLOR -import com.intellij.openapi.editor.impl.EditorImpl -import com.intellij.openapi.project.ProjectManager -import org.acejump.config.AceConfig -import org.acejump.search.defaultEditor -import org.acejump.view.Boundary.FULL_FILE_BOUNDARY -import java.awt.Color.BLACK -import java.awt.Color.YELLOW -import java.awt.Font -import java.awt.Font.BOLD - -/** - * Data holder for all settings and IDE components needed by AceJump. - * - * TODO: Integrate this class with [org.acejump.config.AceSettings] - */ - -object Model { - var editor: Editor = defaultEditor() - - val markup - get() = editor.markupModel - val project - get() = editor.project ?: ProjectManager.getInstance().defaultProject - val caretOffset - get() = editor.caretModel.offset - val editorText: String - get() = editor.document.text - .let { if (AceConfig.supportPinyin) it.mapToPinyin() else it } - - private fun String.mapToPinyin() = - map { Pinyin.toPinyin(it).first() }.joinToString("") - - var naturalBlock = false - var naturalBlink = true - var naturalCaretColor = BLACK - var naturalHighlight = YELLOW - - val scheme - get() = editor.colorsScheme - val font - get() = Font(scheme.editorFontName, BOLD, scheme.editorFontSize) - val fontWidth - get() = editor.component.getFontMetrics(font).stringWidth("w") - val fontHeight - get() = editor.colorsScheme.editorFontSize - val lineHeight - get() = editor.lineHeight - val rectHeight - get() = fontHeight + 3 - val rectVOffset - get() = lineHeight - (editor as EditorImpl).descent - fontHeight - val arcD - get() = if (AceConfig.roundedTagCorners) rectHeight - 6 else 1 - var viewBounds = 0..0 - const val LONG_DOCUMENT_LENGTH = 100000 - val LONG_DOCUMENT - get() = LONG_DOCUMENT_LENGTH < editorText.length - const val MAX_TAG_RESULTS = 300 - - val defaultBoundary = FULL_FILE_BOUNDARY - var boundaries: Boundary = defaultBoundary - - fun Editor.setupCaret() { - settings.isBlockCursor = true - settings.isBlinkCaret = false - colorsScheme.setColor(CARET_COLOR, AceConfig.jumpModeColor) - } -} \ No newline at end of file diff --git a/src/main/kotlin/org/acejump/view/Tag.kt b/src/main/kotlin/org/acejump/view/Tag.kt new file mode 100644 index 00000000..ae01144b --- /dev/null +++ b/src/main/kotlin/org/acejump/view/Tag.kt @@ -0,0 +1,139 @@ +package org.acejump.view + +import com.intellij.openapi.editor.Editor +import com.intellij.ui.ColorUtil +import com.intellij.ui.scale.JBUIScale +import org.acejump.boundaries.EditorOffsetCache +import org.acejump.boundaries.StandardBoundaries +import org.acejump.config.AceConfig +import org.acejump.countMatchingCharacters +import org.acejump.immutableText +import java.awt.Color +import java.awt.Graphics2D +import java.awt.Point +import java.awt.Rectangle +import kotlin.math.max + +/** + * Describes a 1 or 2 character shortcut that points to a specific character in the editor. + */ +internal class Tag( + private val tag: String, + val offsetL: Int, + val offsetR: Int, + private val shiftR: Int, + private val hasSpaceRight: Boolean +) { + private val length = tag.length + + companion object { + /** + * Creates a new tag, precomputing some information about the nearby characters to reduce rendering overhead. If the last typed + * character ([literalQueryText]) matches the first [tag] character, only the second [tag] character is displayed. + */ + fun create(editor: Editor, tag: String, offset: Int, literalQueryText: String?): Tag { + val chars = editor.immutableText + val matching = literalQueryText?.let { chars.countMatchingCharacters(offset, it) } ?: 0 + val hasSpaceRight = offset + 1 >= chars.length || chars[offset + 1].isWhitespace() + + val displayedTag = if (literalQueryText != null && literalQueryText.last().equals(tag.first(), ignoreCase = true)) + tag.drop(1).toUpperCase() + else + tag.toUpperCase() + + return Tag(displayedTag, offset, offset + max(0, matching - 1), tag.length - displayedTag.length, hasSpaceRight) + } + + /** + * Renders the tag background. + */ + private fun drawHighlight(g: Graphics2D, rect: Rectangle, color: Color, arc: Int) { + g.color = color + g.fillRoundRect(rect.x, rect.y + 1, rect.width, rect.height - 1, arc, arc) + } + + /** + * Renders the tag text. + */ + private fun drawForeground(g: Graphics2D, font: TagFont, point: Point, text: String) { + g.font = font.tagFont + g.color = AceConfig.tagForegroundColor + g.drawString(text, point.x, point.y + font.baselineDistance) + } + } + + /** + * Returns true if the left-aligned offset is in the range. Use to cull tags outside visible range. + * Only the left offset is checked, because if the tag was right-aligned on the last index of the range, it would not be visible anyway. + */ + fun isOffsetInRange(range: IntRange): Boolean { + return offsetL in range + } + + /** + * Determines on which side of the target character the tag is positioned. + */ + enum class TagAlignment { + LEFT, + RIGHT + } + + /** + * Paints the tag, taking into consideration visual space around characters in the editor, as well as all other previously painted tags. + * Returns a rectangle indicating the area where the tag was rendered, or null if the tag could not be rendered due to overlap. + */ + fun paint( + g: Graphics2D, editor: Editor, cache: EditorOffsetCache, font: TagFont, occupied: MutableList, isRegex: Boolean + ): Rectangle? { + val (rect, alignment) = alignTag(editor, cache, font, occupied) ?: return null + + val highlightColor = when { + alignment != TagAlignment.RIGHT || hasSpaceRight || isRegex -> AceConfig.tagBackgroundColor + else -> ColorUtil.darker(AceConfig.tagBackgroundColor, 3) + } + + drawHighlight(g, rect, highlightColor, font.tagCornerArc) + drawForeground(g, font, rect.location, tag) + + occupied.add(JBUIScale.scale(2).let { Rectangle(rect.x - it, rect.y, rect.width + (2 * it), rect.height) }) + return rect + } + + private fun alignTag(editor: Editor, cache: EditorOffsetCache, font: TagFont, occupied: List): Pair? { + val boundaries = StandardBoundaries.VISIBLE_ON_SCREEN + + if (hasSpaceRight || offsetL == 0 || editor.immutableText[offsetL - 1].let { it == '\n' || it == '\r' }) { + val rectR = createRightAlignedTagRect(editor, cache, font) + + return (rectR to TagAlignment.RIGHT).takeIf { + boundaries.isOffsetInside(editor, offsetR, cache) && occupied.none(rectR::intersects) + } + } + + val rectL = createLeftAlignedTagRect(editor, cache, font) + + if (occupied.none(rectL::intersects)) { + return (rectL to TagAlignment.LEFT).takeIf { boundaries.isOffsetInside(editor, offsetL, cache) } + } + + val rectR = createRightAlignedTagRect(editor, cache, font) + + if (occupied.none(rectR::intersects)) { + return (rectR to TagAlignment.RIGHT).takeIf { boundaries.isOffsetInside(editor, offsetR, cache) } + } + + return null + } + + private fun createRightAlignedTagRect(editor: Editor, cache: EditorOffsetCache, font: TagFont): Rectangle { + val pos = cache.offsetToXY(editor, offsetR) + val shift = font.editorFontMetrics.charWidth(editor.immutableText[offsetR]) + (font.tagCharWidth * shiftR) + return Rectangle(pos.x + shift, pos.y, font.tagCharWidth * length, font.lineHeight) + } + + private fun createLeftAlignedTagRect(editor: Editor, cache: EditorOffsetCache, font: TagFont): Rectangle { + val pos = cache.offsetToXY(editor, offsetL) + val shift = -(font.tagCharWidth * length) + return Rectangle(pos.x + shift, pos.y, font.tagCharWidth * length, font.lineHeight) + } +} diff --git a/src/main/kotlin/org/acejump/view/TagCanvas.kt b/src/main/kotlin/org/acejump/view/TagCanvas.kt new file mode 100644 index 00000000..19bf306b --- /dev/null +++ b/src/main/kotlin/org/acejump/view/TagCanvas.kt @@ -0,0 +1,101 @@ +package org.acejump.view + +import com.intellij.openapi.application.ApplicationInfo +import com.intellij.openapi.editor.Editor +import com.intellij.openapi.editor.event.CaretEvent +import com.intellij.openapi.editor.event.CaretListener +import com.intellij.ui.ColorUtil +import org.acejump.boundaries.EditorOffsetCache +import org.acejump.boundaries.StandardBoundaries +import org.acejump.config.AceConfig +import java.awt.Graphics +import java.awt.Graphics2D +import java.awt.Rectangle +import java.awt.RenderingHints +import javax.swing.JComponent +import javax.swing.SwingUtilities + +/** + * Holds all active tag markers and renders them on top of the editor. + */ +internal class TagCanvas(private val editor: Editor) : JComponent(), CaretListener { + private var markers: List? = null + private var isRegex = false + + init { + val contentComponent = editor.contentComponent + contentComponent.add(this) + setBounds(0, 0, contentComponent.width, contentComponent.height) + + if (ApplicationInfo.getInstance().build.components.first() < 173) { + SwingUtilities.convertPoint(this, location, editor.component.rootPane).let { setLocation(-it.x, -it.y) } + } + + editor.caretModel.addCaretListener(this) + } + + fun unbind() { + markers = null + editor.contentComponent.remove(this) + editor.caretModel.removeCaretListener(this) + } + + /** + * Ensures that all tags and the outline around the selected tag are repainted. It should not be necessary to repaint the entire tag + * canvas, but the cost of repainting visible tags is negligible. + */ + override fun caretPositionChanged(event: CaretEvent) { + repaint() + } + + fun setMarkers(markers: List, isRegex: Boolean) { + this.markers = markers + this.isRegex = isRegex + repaint() + } + + fun removeMarkers() { + this.markers = emptyList() + } + + override fun paint(g: Graphics) { + if (!markers.isNullOrEmpty()) { + super.paint(g) + } + } + + override fun paintChildren(g: Graphics) { + super.paintChildren(g) + + val markers = markers ?: return + val font = TagFont(editor) + + val cache = EditorOffsetCache.new() + val viewRange = StandardBoundaries.VISIBLE_ON_SCREEN.getOffsetRange(editor, cache) + val occupied = mutableListOf() + + (g as Graphics2D).setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON) + + // If there is a tag at the caret location, prioritize its rendering over all other tags. This is helpful for seeing which tag is + // currently selected while navigating highly clustered tags, although it does end up rearranging nearby tags which can be confusing. + + // TODO instead of immediately painting, we could calculate the layout of everything first, and then remove tags that interfere with + // the caret tag to avoid changing the alignment of the caret tag + + val caretOffset = editor.caretModel.offset + val caretMarker = markers.find { it.offsetL == caretOffset || it.offsetR == caretOffset } + val caretRect = caretMarker?.paint(g, editor, cache, font, occupied, isRegex) + + for (marker in markers) { + if (marker.isOffsetInRange(viewRange) && marker !== caretMarker) { + marker.paint(g, editor, cache, font, occupied, isRegex) + } + } + + if (caretRect != null) { + g.color = ColorUtil.brighter(AceConfig.tagBackgroundColor, 10) + // Only adding 1 to width because it seems the right side of the tag highlight is slightly off. + g.drawRoundRect(caretRect.x - 1, caretRect.y, caretRect.width + 1, caretRect.height, font.tagCornerArc, font.tagCornerArc) + } + } +} diff --git a/src/main/kotlin/org/acejump/view/TagFont.kt b/src/main/kotlin/org/acejump/view/TagFont.kt new file mode 100644 index 00000000..f5d15d78 --- /dev/null +++ b/src/main/kotlin/org/acejump/view/TagFont.kt @@ -0,0 +1,20 @@ +package org.acejump.view; + +import com.intellij.openapi.editor.Editor +import com.intellij.openapi.editor.colors.EditorFontType +import org.acejump.config.AceConfig +import java.awt.Font +import java.awt.FontMetrics + +/** + * Stores font metrics for aligning and rendering [Tag]s. + */ +internal class TagFont(editor: Editor) { + val tagFont: Font = editor.colorsScheme.getFont(EditorFontType.BOLD) + val tagCharWidth = editor.component.getFontMetrics(tagFont).charWidth('w') + val tagCornerArc = if (AceConfig.roundedTagCorners) editor.colorsScheme.editorFontSize - 3 else 1 + + val editorFontMetrics: FontMetrics = editor.component.getFontMetrics(editor.colorsScheme.getFont(EditorFontType.PLAIN)) + val lineHeight = editor.lineHeight + val baselineDistance = editor.ascent +} diff --git a/src/main/kotlin/org/acejump/view/TextHighlighter.kt b/src/main/kotlin/org/acejump/view/TextHighlighter.kt new file mode 100644 index 00000000..f50a9100 --- /dev/null +++ b/src/main/kotlin/org/acejump/view/TextHighlighter.kt @@ -0,0 +1,139 @@ +package org.acejump.view + +import com.intellij.openapi.editor.Editor +import com.intellij.openapi.editor.colors.EditorFontType +import com.intellij.openapi.editor.markup.CustomHighlighterRenderer +import com.intellij.openapi.editor.markup.HighlighterLayer +import com.intellij.openapi.editor.markup.HighlighterTargetArea +import com.intellij.openapi.editor.markup.RangeHighlighter +import com.intellij.util.ui.JBUI +import it.unimi.dsi.fastutil.ints.IntList +import org.acejump.boundaries.EditorOffsetCache +import org.acejump.config.AceConfig +import org.acejump.immutableText +import org.acejump.input.JumpMode +import org.acejump.isWordPart +import org.acejump.search.SearchQuery +import org.acejump.wordEnd +import org.acejump.wordStart +import java.awt.Graphics +import kotlin.math.max + +/** + * Renders highlights for search occurrences. + */ +internal class TextHighlighter(private val editor: Editor) { + private companion object { + private const val LAYER = HighlighterLayer.LAST + 1 + private var ARC = 0 + } + + private var previousHighlights: Array? = null + + /** + * Removes all current highlights and re-creates them from scratch. Must be called whenever any of the method parameters change. + */ + fun render(offsets: IntList, query: SearchQuery, jumpMode: JumpMode) { + val markup = editor.markupModel + val chars = editor.immutableText + + ARC = TagFont(editor).tagCornerArc + + val renderer = when { + query is SearchQuery.RegularExpression -> RegexRenderer + jumpMode === JumpMode.TARGET -> SearchedWordWithOutlineRenderer + else -> SearchedWordRenderer + } + + val modifications = (previousHighlights?.size ?: 0) + offsets.size + val enableBulkEditing = modifications > 1000 + + val document = editor.document + + try { + if (enableBulkEditing) { + document.isInBulkUpdate = true + } + + previousHighlights?.forEach(markup::removeHighlighter) + previousHighlights = Array(offsets.size) { index -> + val start = offsets.getInt(index) + val end = start + query.getHighlightLength(chars, start) + + markup.addRangeHighlighter(start, end, LAYER, null, HighlighterTargetArea.EXACT_RANGE).apply { + customRenderer = renderer + } + } + } finally { + if (enableBulkEditing) { + document.isInBulkUpdate = false + } + } + } + + fun reset() { + editor.markupModel.removeAllHighlighters() + previousHighlights = null + } + + /** + * Renders a filled highlight in the background of a searched text occurrence. + */ + private object SearchedWordRenderer : CustomHighlighterRenderer { + override fun paint(editor: Editor, highlighter: RangeHighlighter, g: Graphics) { + drawFilled(g, editor, highlighter.startOffset, highlighter.endOffset) + } + + private fun drawFilled(g: Graphics, editor: Editor, startOffset: Int, endOffset: Int) { + val start = EditorOffsetCache.Uncached.offsetToXY(editor, startOffset) + val end = EditorOffsetCache.Uncached.offsetToXY(editor, endOffset) + + g.color = AceConfig.textHighlightColor + g.fillRoundRect(start.x, start.y + 1, end.x - start.x, editor.lineHeight - 1, ARC, ARC) + } + } + + /** + * Renders a filled highlight in the background of a searched text occurrence, as well as an outline indicating the range of characters + * that will be selected by [JumpMode.TARGET]. + */ + private object SearchedWordWithOutlineRenderer : CustomHighlighterRenderer { + override fun paint(editor: Editor, highlighter: RangeHighlighter, g: Graphics) { + SearchedWordRenderer.paint(editor, highlighter, g) + + val chars = editor.immutableText + val startOffset = highlighter.startOffset + + if (chars.getOrNull(startOffset)?.isWordPart == true) { + drawOutline(g, editor, chars.wordStart(startOffset), chars.wordEnd(startOffset) + 1) + } + } + + private fun drawOutline(g: Graphics, editor: Editor, startOffset: Int, endOffset: Int) { + val start = EditorOffsetCache.Uncached.offsetToXY(editor, startOffset) + val end = EditorOffsetCache.Uncached.offsetToXY(editor, endOffset) + + g.color = AceConfig.targetModeColor + g.drawRoundRect(max(0, start.x - JBUI.scale(1)), start.y, end.x - start.x + JBUI.scale(2), editor.lineHeight, ARC, ARC) + } + } + + /** + * Renders a filled highlight in the background of the first highlighted position. Used for regex search queries. + */ + private object RegexRenderer : CustomHighlighterRenderer { + override fun paint(editor: Editor, highlighter: RangeHighlighter, g: Graphics) { + drawSingle(g, editor, highlighter.startOffset) + } + + private fun drawSingle(g: Graphics, editor: Editor, offset: Int) { + val pos = EditorOffsetCache.Uncached.offsetToXY(editor, offset) + val char = editor.immutableText.getOrNull(offset)?.takeUnless { it == '\n' || it == '\t' } ?: ' ' + val font = editor.colorsScheme.getFont(EditorFontType.PLAIN) + val lastCharWidth = editor.component.getFontMetrics(font).charWidth(char) + + g.color = AceConfig.textHighlightColor + g.fillRoundRect(pos.x, pos.y + 1, lastCharWidth, editor.lineHeight - 1, ARC, ARC) + } + } +} diff --git a/src/main/resources/AceResources.properties b/src/main/resources/AceResources.properties deleted file mode 100644 index a900d256..00000000 --- a/src/main/resources/AceResources.properties +++ /dev/null @@ -1,26 +0,0 @@ -charactersAndLayoutHeading=Characters and Layout -tagCharsToBeUsedLabel=Allowed characters: -keyboardLayoutLabel=Keyboard layout: -keyboardDesignLabel=Keyboard design: -modesHeading=Modes -cycleModeOrderLabel=Cycle order: -jumpModeDisabled=(Skip) -jumpModeJump=Jump -jumpModeJumpEnd=Jump to End -jumpModeTarget=Target -jumpModeDefine=Definition -colorsHeading=Colors -jumpModeColorLabel=Jump mode caret background: -jumpEndModeColorLabel=Jump to End mode caret background: -targetModeColorLabel=Target mode caret background: -definitionModeColorLabel=Definition mode caret background: -textHighlightColorLabel=Searched text background: -tagForegroundColorLabel=Tag foreground: -tagBackgroundColorLabel=Tag background: -appearanceHeading=Appearance -displayQueryLabel=Display search query -roundedTagCornersLabel=Rounded tag corners -languagesHeading=Language -behaviorHeading=Behavior -searchWholeFileLabel=Search whole file -supportPinyin=Support Pinyin selection diff --git a/src/main/resources/META-INF/plugin.xml b/src/main/resources/META-INF/plugin.xml index 502a61e6..4fa582b3 100755 --- a/src/main/resources/META-INF/plugin.xml +++ b/src/main/resources/META-INF/plugin.xml @@ -18,48 +18,67 @@ + + + + + + + + + + + class="org.acejump.action.AceAction$ActivateOrCycleMode" + text="Activate / Cycle AceJump Mode"> + + + + + + + + - - - - - + class="org.acejump.action.AceAction$ToggleAllWordsMode" + text="Start AceJump in All Words Mode"/> + class="org.acejump.action.AceAction$ToggleAllWordsForwardMode" + text="Start in All Words After Caret Mode"/> - + class="org.acejump.action.AceAction$ToggleAllWordsBackwardsMode" + text="Start in All Words Before Caret Mode"/> diff --git a/src/test/kotlin/AceTest.kt b/src/test/kotlin/AceTest.kt index 6815f143..9ff7dd51 100644 --- a/src/test/kotlin/AceTest.kt +++ b/src/test/kotlin/AceTest.kt @@ -1,17 +1,7 @@ -import com.intellij.openapi.actionSystem.AnAction -import com.intellij.openapi.actionSystem.IdeActions.* -import com.intellij.openapi.components.ServiceManager -import com.intellij.openapi.fileTypes.PlainTextFileType -import com.intellij.psi.PsiFile -import com.intellij.testFramework.fixtures.BasePlatformTestCase -import com.intellij.util.ui.UIUtil -import org.acejump.config.AceConfig -import org.acejump.control.* -import org.acejump.label.Tagger -import org.acejump.view.Canvas -import kotlin.random.Random -import kotlin.system.measureTimeMillis -import java.io.File +import com.intellij.openapi.actionSystem.IdeActions.ACTION_EDITOR_ENTER +import com.intellij.openapi.actionSystem.IdeActions.ACTION_EDITOR_START_NEW_LINE +import org.acejump.action.AceAction +import org.acejump.test.util.BaseTest /** * Functional test cases and end-to-end performance tests. @@ -19,7 +9,7 @@ import java.io.File * TODO: Add more structure to test cases, use test resources to define files. */ -class AceTest: BasePlatformTestCase() { +class AceTest : BaseTest() { fun `test that scanner finds all occurrences of single character`() = assertEquals("test test test".search("t"), setOf(0, 3, 5, 8, 10, 13)) @@ -65,7 +55,7 @@ class AceTest: BasePlatformTestCase() { fun `test tag selection`() { "testing 1234".search("g") - typeAndWaitForResults(Canvas.jumpLocations.first().tag!!) + typeAndWaitForResults(session.tags[0].key) myFixture.checkResult("testing 1234") } @@ -73,7 +63,7 @@ class AceTest: BasePlatformTestCase() { fun `test shift selection`() { "testing 1234".search("4") - typeAndWaitForResults(Canvas.jumpLocations.first().tag!!.toUpperCase()) + typeAndWaitForResults(session.tags[0].key.toUpperCase()) myFixture.checkResult("testing 1234") } @@ -81,27 +71,27 @@ class AceTest: BasePlatformTestCase() { fun `test words before caret action`() { makeEditor("test words before caret is two") - takeAction(AceWordBackwardsAction()) + takeAction(AceAction.ToggleAllWordsBackwardsMode) - assertEquals(2, Tagger.markers.size) + assertEquals(2, session.tags.size) } fun `test words after caret action`() { makeEditor("test words after caret is four") - takeAction(AceWordForwardAction()) + takeAction(AceAction.ToggleAllWordsForwardMode) - assertEquals(4, Tagger.markers.size) + assertEquals(4, session.tags.size) } fun `test word mode`() { makeEditor("test word action") - takeAction(AceWordAction()) + takeAction(AceAction.ToggleAllWordsMode) - assertEquals(3, Tagger.markers.size) + assertEquals(3, session.tags.size) - typeAndWaitForResults(Canvas.jumpLocations.toList()[1].tag!!) + typeAndWaitForResults(session.tags[1].key) myFixture.checkResult("test word action") } @@ -109,123 +99,17 @@ class AceTest: BasePlatformTestCase() { fun `test target mode`() { "test target action".search("target") - takeAction(AceTargetAction()) - typeAndWaitForResults(Canvas.jumpLocations.first().tag!!) + takeAction(AceAction.ToggleTargetMode) + typeAndWaitForResults(session.tags[0].key) myFixture.checkResult("test target action") } fun `test line mode`() { - makeEditor(" test\n three\n lines") + makeEditor(" test\n three\n lines\n") - takeAction(AceLineAction()) + takeAction(AceAction.ToggleAllLinesMode) - assertEquals(9, Tagger.markers.size) + assertEquals(8, session.tags.size) // last empty line does not count } - - fun `test pinyin selection`() { - getSettings().supportPinyin = true - - "test 拼音 selection".search("py") - - takeAction(AceTargetAction()) - typeAndWaitForResults(Canvas.jumpLocations.first().tag!!) - - myFixture.checkResult("test 拼音 selection") - } - - fun `test tag latency`(editorText: String) { - var time = 0L - - editorText.toCharArray().distinct().filter { !it.isWhitespace() } - .forEach { query -> - repeat(10) { - makeEditor(editorText) - - myFixture.testAction(AceAction()) - time += measureTimeMillis { typeAndWaitForResults("$query") } - assert(Tagger.markers.isNotEmpty()) { "Should be tagged: $query" } - resetEditor() - } - } - - println("Average time to tag results: ${time / 100}ms") - } - - fun `test random text latency`() = - `test tag latency`( - generateSequence { - generateSequence { - generateSequence { - ('a'..'z').random(Random(0)) - }.take(5).joinToString("") - }.take(20).joinToString(" ") - }.take(100).joinToString("\n") - ) - - fun `test lorem ipsum latency`() = - `test tag latency`( - File( - javaClass.classLoader.getResource("lipsum.txt")!!.file - ).readText() - ) - - fun getSettings() = - ServiceManager.getService(AceConfig::class.java).aceSettings - - // Enforces the results are available in less than 100ms - private fun String.search(query: String) = - myFixture.run { - maybeWarmUp(this@search, query) - val queryTime = measureTimeMillis { this@search.executeQuery(query) } -// assert(queryTime < 100) { "Query exceeded time limit! ($queryTime ms)" } - this@search.replace(Regex("<[^>]*>"), "").assertCorrectNumberOfTags(query) - editor.markupModel.allHighlighters.map { it.startOffset }.toSet() - } - - // Ensures that the correct number of locations are tagged - private fun String.assertCorrectNumberOfTags(query: String) = - assertEquals(split(query.fold("") { prefix, char -> - if ((prefix + char) in this) prefix + char else return - }).size - 1, myFixture.editor.markupModel.allHighlighters.size) - - private var shouldWarmup = true - - // Should be run exactly once to warm up the JVM - private fun maybeWarmUp(text: String, query: String) { - if (shouldWarmup) { - text.executeQuery(query) - takeAction(ACTION_EDITOR_ESCAPE) - UIUtil.dispatchAllInvocationEvents() - // Now the JVM is warm, never run this method again - shouldWarmup = false - } - } - - fun makeEditor(contents: String): PsiFile = - myFixture.configureByText(PlainTextFileType.INSTANCE, contents) - - fun takeAction(action: String) = myFixture.performEditorAction(action) - - fun takeAction(action: AnAction) = myFixture.testAction(action) - - // Just does a query without enforcing any time limit - private fun String.executeQuery(query: String) { - myFixture.run { - makeEditor(this@executeQuery) - testAction(AceAction()) - typeAndWaitForResults(query) - } - } - - fun resetEditor() { - takeAction(ACTION_EDITOR_ESCAPE) - UIUtil.dispatchAllInvocationEvents() - assertEmpty(myFixture.editor.markupModel.allHighlighters) - } - - override fun tearDown() = resetEditor().also { super.tearDown() } - - private fun typeAndWaitForResults(string: String) = - myFixture.type(string).also { UIUtil.dispatchAllInvocationEvents() } -} \ No newline at end of file +} diff --git a/src/test/kotlin/LatencyTest.kt b/src/test/kotlin/LatencyTest.kt new file mode 100644 index 00000000..16d28e0a --- /dev/null +++ b/src/test/kotlin/LatencyTest.kt @@ -0,0 +1,45 @@ +import org.acejump.action.AceAction +import org.acejump.test.util.BaseTest +import org.junit.Ignore +import java.io.File +import kotlin.random.Random +import kotlin.system.measureTimeMillis + +@Ignore +class LatencyTest : BaseTest() { + + private fun `test tag latency`(editorText: String) { + val chars = editorText.toCharArray().distinct().filter { !it.isWhitespace() } + val avg = averageTimeWithWarmup(warmupRuns = 10, timedRuns = 10) { + var time = 0L + + for (query in chars) { + makeEditor(editorText) + myFixture.testAction(AceAction.ActivateOrCycleMode) + time += measureTimeMillis { typeAndWaitForResults("$query") } + // TODO assert(Tagger.markers.isNotEmpty()) { "Should be tagged: $query" } + resetEditor() + } + + time + } + + println("Average time to tag results: ${String.format("%.1f", avg.toDouble() / chars.size)} ms") + } + + fun `test random text latency`() = `test tag latency`( + generateSequence { + generateSequence { + generateSequence { + ('a'..'z').random(Random(0)) + }.take(5).joinToString("") + }.take(20).joinToString(" ") + }.take(100).joinToString("\n") + ) + + fun `test lorem ipsum latency`() = `test tag latency`( + File( + javaClass.classLoader.getResource("lipsum.txt")!!.file + ).readText() + ) +} \ No newline at end of file diff --git a/src/test/kotlin/org/acejump/test/util/BaseTest.kt b/src/test/kotlin/org/acejump/test/util/BaseTest.kt new file mode 100644 index 00000000..360717bb --- /dev/null +++ b/src/test/kotlin/org/acejump/test/util/BaseTest.kt @@ -0,0 +1,75 @@ +package org.acejump.test.util + +import com.intellij.openapi.actionSystem.AnAction +import com.intellij.openapi.actionSystem.IdeActions +import com.intellij.openapi.fileTypes.PlainTextFileType +import com.intellij.psi.PsiFile +import com.intellij.testFramework.fixtures.BasePlatformTestCase +import com.intellij.util.ui.UIUtil +import org.acejump.action.AceAction +import org.acejump.session.SessionManager + +abstract class BaseTest : BasePlatformTestCase() { + companion object { + inline fun averageTimeWithWarmup(warmupRuns: Int, timedRuns: Int, action: () -> Long): Long { + repeat(warmupRuns) { + action() + } + + var time = 0L + + repeat(timedRuns) { + time += action() + } + + return time / timedRuns + } + } + + protected val session + get() = SessionManager[myFixture.editor]!! + + override fun tearDown() { + resetEditor() + super.tearDown() + } + + fun takeAction(action: String) = myFixture.performEditorAction(action) + fun takeAction(action: AnAction) = myFixture.testAction(action) + + fun makeEditor(contents: String): PsiFile { + return myFixture.configureByText(PlainTextFileType.INSTANCE, contents) + } + + fun resetEditor() { + takeAction(IdeActions.ACTION_EDITOR_ESCAPE) + UIUtil.dispatchAllInvocationEvents() + assertEmpty(myFixture.editor.markupModel.allHighlighters) + } + + fun typeAndWaitForResults(string: String) { + myFixture.type(string) + UIUtil.dispatchAllInvocationEvents() + } + + fun String.executeQuery(query: String) { + myFixture.run { + makeEditor(this@executeQuery) + testAction(AceAction.ActivateOrCycleMode) + typeAndWaitForResults(query) + } + } + + fun String.search(query: String): Set { + this@search.executeQuery(query) + this@search.replace(Regex("<[^>]*>"), "").assertCorrectNumberOfTags(query) + return myFixture.editor.markupModel.allHighlighters.map { it.startOffset }.toSet() + } + + private fun String.assertCorrectNumberOfTags(query: String) { + assertEquals(split(query.fold("") { prefix, char -> + if ((prefix + char) in this) prefix + char else return + }).size - 1, myFixture.editor.markupModel.allHighlighters.size) + } + +}