Howto highlight cursor row

[dagraham]

I searched for ideas about how to do this and, failing to find anything useful, finally came up with this working example:

from prompt_toolkit import Application
from prompt_toolkit.widgets import TextArea
from prompt_toolkit.layout import Layout
from prompt_toolkit.key_binding import KeyBindings
from prompt_toolkit.lexers import Lexer
from prompt_toolkit.document import Document
from prompt_toolkit.styles import Style
import shutil

width = shutil.get_terminal_size()[0] - 1

kb = KeyBindings()

def is_current_row(line_number: int):
    cursor_row = input_area.document.cursor_position_row
    return int(line_number) == int(cursor_row)

# Custom lexer to highlight the current cursor row
class HighlightCurrentLineLexer(Lexer):
    def __init__(self, buffer):
        self.buffer = buffer

    def lex_document(self, document: Document):
        lines = document.lines
        def get_line_tokens(line_number: int):
            line = lines[line_number]
            if is_current_row(line_number):
                # Apply style to the whole line with a background for the current line
                return [('class:highlighted-line', f"{line:<{width}}")]
            else:
                # Apply no special style for other lines
                return [('class:default', line)]

        return get_line_tokens

# Create a TextArea with an empty buffer first
input_area = TextArea(text='', multiline=True)

# Set the custom lexer with input_area's buffer
input_area.lexer = HighlightCurrentLineLexer(input_area.buffer)

# Initialize the content for input_area
input_area.text = '\n'.join([f"line {i}" for i in range(10)])

# Style definitions
style = Style.from_dict({
    'highlighted-line': 'bg:#ffffcc',  # Yellow background for the current line
    'default': ''                       # No special styling for other lines
})

# Keybinding to refresh/redraw the screen when the cursor moves
@kb.add('c-q')
def exit_app(event):
    """Exit the application."""
    app.exit()


# Create the layout and application
layout = Layout(input_area)

# Create the Application with the key bindings and the style
app = Application(layout=layout, key_bindings=kb, full_screen=True, style=style)

# Run the application
app.run()

[nitanmarcel]

You can use processors for that

https://github.com/prompt-toolkit/pyvim/blob/ae9257ad4118da0d882bd0e75f687e7158aad02a/pyvim/layout.py#L627

[tayfuryldz]

A Processor is the better abstraction for this than a Lexer.

The current cursor row is display/UI state, not lexical information derived from the document text. A Lexer can make your example work because it is called while rendering lines, but it couples syntax tokenization to cursor position and makes composition with a real syntax lexer harder.

A Processor can style the fragments produced for display while leaving the underlying document and lexer unchanged. prompt_toolkit already uses processors for UI-state overlays such as selection/search highlighting.

For the full-row background, don't pad text to shutil.get_terminal_size(). That bypasses prompt_toolkit's layout width calculation and becomes wrong when the TextArea is inside a split/frame or the terminal resizes. Let the Window own its width. The processor should change styles for the fragments on the cursor's logical row; if you need the background to fill unused cells to the right, use Window/style behavior for the line rather than manufacturing spaces based on the physical terminal width.

Cursor movement through normal key bindings already invalidates/redraws the application. If you change the highlighted-row state from outside the normal input path, call app.invalidate().

So your prototype demonstrates the desired effect, but I would move the cursor-dependent styling out of HighlightCurrentLineLexer and into an input Processor, and remove the fixed terminal-width padding.