Draw a (column-wise) selection rectangle in CodeArea?

[sirop]

Hello.

I am aware of #222 ,
but still it is not clear for me how to draw a selection rectangle upon CodeArea.

Just to be sure that i am undestood correctly:
I mean this kind of selection rectangular
@Ansury This is "rectangular selection":

Originally posted by @alt-grr in #106 (comment)

Both VirtualizedScrollPane<CodeArea> und CodeArea have only getChildrenUnmodifiable() , which means that I can not really add Rectangle selectionRectangle .

Thanks.

[lekhoon99]

@Jugen I am looking for similar feature like the above rectangular selection - where the text area listens to ALT key + mouse drag event, and highlight the selected rectangular area, and able to do copy, paste, cut as usual.

There is already an identical feature implemented in Notepad++:

How should I begin to implement this?

• extending from text area (e.g. InlineCssTextArea) class?
• extending from SelectionImpl?
• any other area to change/extend

[Jugen]

Will have a look and get back to you ....

[lekhoon99]

@Jugen Thanks you so much, the rectangle selection and highlight works well!
Is there any work around to get copy, paste and cut action to work since getSelectedText() can't be override?

I tried the following for copy, when pasting it - only the first line got pasted:

    codeArea.addEventFilter(KeyEvent.KEY_PRESSED, new EventHandler<KeyEvent>(){
        public void handle(KeyEvent event) {
            if(event.isControlDown()){
                if(event.getCode() == KeyCode.C){
                    if ( rectSelect != null ) {
                        //copy text to clipboard
                        ClipboardContent content = new ClipboardContent();
                        content.putString(rectSelect.getSelectedRectangleText());
                        Clipboard.getSystemClipboard().setContent(content);
                    } else {
                        codeArea.copy();
                    }
                }
            }
        }
    });

[Jugen]

Sorry, my bad - am working on a better implementation ....

[Jugen]

So here's a better and more comprehensive implementation including copy, paste, cut, and delete. It can still be improved though.

package org.fxmisc.richtext.demo;

import static javafx.scene.input.KeyCombination.SHIFT_DOWN;
import static javafx.scene.input.KeyCombination.SHORTCUT_DOWN;
import static org.fxmisc.wellbehaved.event.EventPattern.keyPressed;
import static org.fxmisc.wellbehaved.event.InputMap.consumeWhen;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import java.util.function.BooleanSupplier;
import java.util.function.Consumer;
import java.util.stream.Collectors;

import org.fxmisc.richtext.GenericStyledArea;
import org.fxmisc.richtext.SelectionImpl;
import org.fxmisc.richtext.SelectionPath;
import org.fxmisc.richtext.model.ReadOnlyStyledDocument;
import org.fxmisc.richtext.model.StyledDocument;
import org.fxmisc.richtext.model.TwoDimensional.Bias;
import org.fxmisc.wellbehaved.event.Nodes;

import javafx.beans.InvalidationListener;
import javafx.geometry.Bounds;
import javafx.geometry.Point2D;
import javafx.scene.control.IndexRange;
import javafx.scene.input.Clipboard;
import javafx.scene.input.ClipboardContent;
import javafx.scene.input.DataFormat;
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyEvent;
import javafx.scene.input.MouseEvent;
import javafx.scene.paint.Color;
import javafx.scene.shape.LineTo;

/**
 * Can do a Rectangle/Box selection with mouse or API, no keyboard.<br>
 * Can copy, paste, cut, and delete selection with styling or plain.
 * @author Jurgen
 */
public class RectangleSelection<PS, SEG, S> extends SelectionImpl<PS, SEG, S>
{
    /** Collection of paragraph start and end column ranges */
    private final List<IndexRange> selectedRanges = new ArrayList<>();
    private final DataFormat RECTANGLE_FORMAT = new DataFormat( "text/rectangle" );
    private final ReadOnlyStyledDocument<PS,SEG,S> NEWLINE;
    private final Consumer<Point2D> normalSelection;

    private double startX = -1.0, endX = -1.0;
    private double startY = -1.0, endY = -1.0;
    private boolean isActive, isAltDown;

    public RectangleSelection( String name, GenericStyledArea<PS, SEG, S> area )
    {
        super( name, area, 0, 0 );
        area.addSelection( this );

        NEWLINE = ReadOnlyStyledDocument.fromString
        (
            "\n", getArea().getInitialParagraphStyle(),
            getArea().getInitialTextStyle(),
            getArea().getSegOps()
        );

        /*
         *     Configure KEYBOARD events
         */
        BooleanSupplier hasSelection = () -> isActive();
        BooleanSupplier hasClipboard = () -> isActive() || Clipboard.getSystemClipboard().hasContent(RECTANGLE_FORMAT);

        // Modify keyboard behavior for copy, paste, cut, and delete
        Nodes.addInputMap( area, consumeWhen( keyPressed("c",SHORTCUT_DOWN), hasSelection, KE -> copy() ) );
        Nodes.addInputMap( area, consumeWhen( keyPressed("v",SHORTCUT_DOWN), hasClipboard, KE -> paste() ) );
        Nodes.addInputMap( area, consumeWhen( keyPressed("v",SHORTCUT_DOWN,SHIFT_DOWN), hasClipboard, KE -> pastePlain() ) );
        Nodes.addInputMap( area, consumeWhen( keyPressed("x",SHORTCUT_DOWN), hasSelection, KE -> cut() ) );
        Nodes.addInputMap( area, consumeWhen( keyPressed(KeyCode.DELETE), hasSelection, KE -> delete() ) );
/*
        // TODO Keys: ALT+SHIFT+[ UP, DOWN, LEFT, RIGHT ] -> extend selection & consume
        Nodes.addInputMap( area, consume
        (
            anyOf(keyPressed(UP,ALT_DOWN,SHIFT_DOWN), keyPressed(KP_UP,ALT_DOWN,SHIFT_DOWN)),
            KE -> adjustSelectionUp() // adjust top/bottom edge (depending on caret?) up 1 row
        ));
        Nodes.addInputMap( area, consume
        (
            anyOf(keyPressed(DOWN,ALT_DOWN,SHIFT_DOWN), keyPressed(KP_DOWN,ALT_DOWN,SHIFT_DOWN)),
            KE -> adjustSelectionDown() // adjust top/bottom edge (depending on caret?) down 1 row
        ));
        Nodes.addInputMap( area, consume
        (
            anyOf(keyPressed(LEFT,ALT_DOWN,SHIFT_DOWN), keyPressed(KP_LEFT,ALT_DOWN,SHIFT_DOWN)),
            KE -> adjustSelectionLeft() // adjust left/right edge (depending on caret?) left 1 column
        ));
        Nodes.addInputMap( area, consume
        (
            anyOf(keyPressed(RIGHT,ALT_DOWN,SHIFT_DOWN), keyPressed(KP_RIGHT,ALT_DOWN,SHIFT_DOWN)),
            KE -> adjustSelectionRight() // adjust left/right edge (depending on caret?) right 1 column
        ));
 */

        // Setup ALT key to activate and reset rectangle selection
        area.addEventFilter( KeyEvent.KEY_PRESSED, KE ->
        {
            if ( ! isAltDown && KE.isAltDown() )
            {
                isAltDown = true;  isActive = false;
            }
        });

        // Stop rectangle selection on ALT key release
        area.addEventFilter( KeyEvent.KEY_RELEASED, KE ->
        {
            if ( isAltDown && ! KE.isAltDown() ) isAltDown = false;
        });

        /*
         *     Configure MOUSE events
         */

        // On ALT+SHIFT+Press extend a rectangle from the caret to the mouse,
        // otherwise reset rectangle on mouse pressed after selection.
        area.addEventFilter( MouseEvent.MOUSE_PRESSED, ME ->
        {
            if ( isAltDown && ! isActive() && ME.isShiftDown() )
            {
                var end = new Point2D( ME.getX(), ME.getY() );
                getArea().getCaretBounds()
                    .map( b -> getArea().screenToLocal( b ) )
                    .map( b -> new Point2D( b.getCenterX(), b.getCenterY() ) )
                    .ifPresent( start ->
                    {
                        selectRange( start, end );
                        isActive = true;
                    });
                ME.consume();
            }
            else if ( ! isAltDown && isActive() )
            {
                deselect();
            }
        });

        // Get default selection behavior
        normalSelection = area.getOnNewSelectionDrag();

        // Configure CodeArea to use new selection behavior
        area.setOnNewSelectionDrag( this::processPoint );
        area.setOnNewSelectionDragFinished( ME ->
        {
            processPoint( new Point2D( ME.getX(), ME.getY() ) );
        });
    }

    // New selection behavior dependent on ALT key status
    private void processPoint( Point2D pos )
    {
        if ( ! isAltDown ) normalSelection.accept( pos );
        else if ( isActive() ) updateEndTo( pos );
        else // start new selection
        {
            selectRange( pos, pos );
            isActive = true;
        }
    }

    @Override public void selectAll() {}
    @Override public void selectParagraph( int paragraphIndex )    {}
    @Override public void deselect()
    {
        super.deselect();
        startX = -1.0; startY = -1.0;
        endX = -1.0; endY = -1.0;
        isActive = false;
    }

    private boolean isActive()
    {
        return isActive || getLength() > 0;
    }

    public void selectRange( Point2D start, Point2D end )
    {
        endX = end.getX(); endY = end.getY();
        startX = start.getX(); startY = start.getY();
        selectRange( getStartInsertIndex(), getEndInsertIndex() );
    }

    /**
     * <b>Note:</b> When using this method directly the rectangle/box's width will be the
     * distance between the start character's X position and the end character's X position.
     */
    @Override public void selectRange( int start, int end )
    {
        var reverselection = (startX > 0.0) ? startX > endX : start > end;
        var range = IndexRange.normalize( start, end );
        start = range.getStart();
        end = range.getEnd();

        super.selectRange( start, start ); // reset rectangle so that
        super.selectRange( start, end );   // all lines are repainted

        // Move caret to selection start/end depending on direction
        if ( reverselection ) getArea().moveTo( getStartPosition() );
        else getArea().moveTo( getEndPosition() );

        selectedRanges.clear();
    }

    public List<IndexRange> getRanges()
    {
        if ( selectedRanges.size() > 0 ) return selectedRanges;

        for ( int p = getStartParagraphIndex(); p <= getEndParagraphIndex(); p++ )
        {
            var centerY = getArea().screenToLocal( getArea().getParagraphBoundsOnScreen( p ).get() ).getCenterY();
            var startNdx = getInsertIndex( getLeftX(), centerY );
            var endNdx = getInsertIndex( getRightX(), centerY );

            selectedRanges.add( IndexRange.normalize( startNdx, endNdx ) );
        }

        return selectedRanges;
    }

    public String getSelectedRectangleText()
    {
        return getRanges().stream()
            .map( r -> getArea().getText( r ) )
            .collect( Collectors.joining( "\n" ) );
    }

    public List<String> getSelectedRectangleList()
    {
        return getRanges().stream()
            .map( r -> getArea().getText( r ) )
            .collect( Collectors.toList() );
    }

    public StyledDocument<PS,SEG,S> getSelectedRectangleDocument()
    {
        return getRanges().stream()
            .map( r -> getArea().subDocument( r ) )
            .reduce( (d1,d2) -> d1.concat( NEWLINE ).concat( d2 ) )
            .orElseGet( () -> NEWLINE.subSequence(0,0) );
    }

    public void copy()
    {
        if( getRanges().size() > 0 )
        {
            var content = new ClipboardContent();
            var selectedText = getSelectedRectangleText();
            content.put( RECTANGLE_FORMAT, selectedText );
            content.putString( selectedText );

            // Copy styling data if possible ....
            getArea().getStyleCodecs().ifPresent( codecs ->
            {
                var byteStream = new ByteArrayOutputStream();
                var dataStream = new DataOutputStream( byteStream );
                var codec = ReadOnlyStyledDocument.codec( codecs._1, codecs._2, getArea().getSegOps() );

                try {
                    codec.encode( dataStream, getSelectedRectangleDocument() );
                    content.put( dataFormat( codec.getName() ), byteStream.toByteArray() );
                }
                catch (IOException e)
                {
                    System.err.println("Codec error: Exception in encoding '" + codec.getName() + "':");
                    e.printStackTrace();
                }
            });

            Clipboard.getSystemClipboard().setContent( content );
        }
    }

    public void paste()
    {
        var clipboard = Clipboard.getSystemClipboard();
        var codecs = getArea().getStyleCodecs();

        if ( codecs.isPresent() )  // Paste with styling ... ?
        {
            var codec = codecs.map( cd -> ReadOnlyStyledDocument.codec( cd._1, cd._2, getArea().getSegOps() ) ).get();
            var bytes = (byte[]) clipboard.getContent( dataFormat( codec.getName() ) );

            // Did the clipboard return styling data ... ?
            if ( bytes != null ) try ( var dataStream = new DataInputStream( new ByteArrayInputStream(bytes) ) )
            {
                var doc = codec.decode( dataStream );

                if ( doc != null )
                {
                    var hasSelection = isActive();
                    // Get current cursor column position or if isActive get selection start position
                    var paragraph = hasSelection ? getStartParagraphIndex() : getArea().getCurrentParagraph();
                    var colPos = hasSelection ? getLeftColumn() : getArea().getCaretColumn();
                    var absPos = getArea().getAbsolutePosition( paragraph, 0 );
                    if ( hasSelection ) delete();

                    var pasteRows = doc.getParagraphs().size();
                    var multiChange = getArea().createMultiChange( pasteRows );
                    var areaParCount = getArea().getParagraphs().size();
                    var parLength = 0;

                    // For each paragraph in doc, insert in successive paragraphs at column position as a sub-document
                    for( var p = 0; p < pasteRows; p++ )
                    {
                        if ( paragraph < areaParCount ) parLength = getArea().getParagraph( paragraph ).length();
                        else { multiChange.insert( absPos -= 1, NEWLINE );  parLength = 0; } // add paragraph

                        // If paragraph length is smaller than target position then pad with spaces
                        if ( parLength >= colPos ) multiChange.insert( absPos+colPos, doc.subDocument( p ) );
                        else
                        {
                            var paddedDoc = ReadOnlyStyledDocument.fromString(
                                " ".repeat( colPos-parLength ), getArea().getInitialParagraphStyle(),
                                getArea().getInitialTextStyle(), getArea().getSegOps())
                                .concat( doc.subDocument( p ) );

                            multiChange.insert( absPos+parLength, paddedDoc );
                        }

                        absPos += parLength + 1;
                        paragraph++;
                    }

                    if ( multiChange.hasChanges() )
                    {
                        multiChange.commit();
                    }
                    return;
                }
            }
            catch ( IOException e )
            {
                System.err.println( "Codec error: Failed to decode '" + codec.getName() + "':" );
                e.printStackTrace();
            }
        }

        // No styling data found on clipboard so try paste plain text ....
        pastePlain();
    }

    private void pastePlain()
    {
        var clipboard = Clipboard.getSystemClipboard();
        var text = (String) clipboard.getContent( RECTANGLE_FORMAT );
        if ( text == null ) text = clipboard.getString();

        if ( text != null )
        {
            var hasSelection = isActive();
            // Get current cursor column position or if isActive get selection start position
            var paragraph = hasSelection ? getStartParagraphIndex() : getArea().getCurrentParagraph();
            var colPos = hasSelection ? getLeftColumn() : getArea().getCaretColumn();
            var absPos = getArea().getAbsolutePosition( paragraph, 0 );
            if ( hasSelection ) delete();

            var multiChange = getArea().createMultiChange();
            var areaParCount = getArea().getParagraphs().size();
            var parLength = 0;

            // For each line in text, insert at successive line at column position
            try ( var reader = new BufferedReader( new StringReader( text ) ) )
            {
                for ( var line = reader.readLine(); line != null; )
                {
                    if ( paragraph < areaParCount ) parLength = getArea().getParagraph( paragraph ).length();
                    else { multiChange.insertText( absPos -= 1, "\n" );  parLength = 0; } // add paragraph

                    // If paragraph length is smaller than target position then pad with spaces
                    if ( parLength < colPos ) multiChange.insertText
                    (
                        absPos+parLength, " ".repeat( colPos-parLength ) + line
                    );
                    else multiChange.insertText( absPos+colPos, line );
                    line = reader.readLine();
                    absPos += parLength + 1;
                    paragraph++;
                }

                if ( multiChange.hasChanges() )
                {
                    multiChange.commit();
                }
            }
            catch ( IOException EX ) {}
        }
    }

    public void cut()
    {
        copy();
        delete();
    }

    public void delete()
    {
        var selectedRanges = getRanges();
        var multiChange = getArea().createMultiChange( selectedRanges.size() );

        selectedRanges.stream()
            // reverse sort so ranges don't change if deleted
            .sorted( (a,b) -> Integer.compare( b.getEnd(), a.getEnd() ) )
            .forEach( r -> multiChange.deleteText( r ) );

        if ( multiChange.hasChanges() )
        {
            multiChange.commit();
        }
        deselect();
    }

    public void updateEndTo( Point2D end )
    {
        endX = end.getX(); endY = end.getY();
        var endIndex = getEndInsertIndex();

        if ( endIndex != getEndPosition() ) updateEndTo( endIndex );
        else updateStartTo( getStartInsertIndex() );
    }

    public void updateStartTo( Point2D start )
    {
        startX = start.getX(); startY = start.getY();
        var startIndex = getStartInsertIndex();

        if ( startIndex != getStartPosition() ) updateStartTo( startIndex );
        else updateEndTo( getEndInsertIndex() );
    }

    @Override public void configureSelectionPath( SelectionPath path )
    {
        path.setHighlightFill( Color.LIGHTSTEELBLUE );

        // Note that each paragraph that the selection covers has its own selection
        // path, which means that this executes for each paragraph's path individually.
        // The path is the shape of the selection for the current paragraph, which gets
        // modified below to form a rectangle instead of the usual selection shape.
        path.getElements().addListener( (InvalidationListener) invalidated ->
        {
            Bounds parentScreenBounds = path.getParent().localToScreen( path.getParent().getBoundsInLocal() );

            if ( parentScreenBounds != null )
            {
                // We need an offset to adjust for the paragraph graphic width
                double parentOffset = path.getParent().getBoundsInParent().getMinX();
                double rightEdge = getRightX() - parentOffset;    // right edge to trim the selection too
                double leftEdge = getLeftX() - parentOffset;    // left edge to push the selection too

                if ( rightEdge > 0 )
                {
                    // Trim the selection's right edge to the specified width
                    path.getElements().stream().skip( 1 ).limit( 2 ).forEach( ele -> ((LineTo) ele).setX( rightEdge ) );
                    // Push the selection left edge to FIRST line's selection left edge
                    path.getElements().stream().skip( 3 ).forEach( ele -> ((LineTo) ele).setX( leftEdge ) );
                }
            }
        } );

        super.configureSelectionPath( path );
    }


    private double getLeftX()
    {
        if ( startX < 0.0 ) return getArea()
            .getCharacterBoundsOnScreen( getStartPosition(), getStartPosition() )
            .map( b -> getArea().screenToLocal( b ) )
            .map( b -> b.getMinX() ).orElse( 0.0 );

        return Math.min( startX, endX );
    }

    private double getRightX()
    {
        if ( endX < 0.0 ) return getArea()
            .getCharacterBoundsOnScreen( getEndPosition(), getEndPosition() )
            .map( b -> getArea().screenToLocal( b ) )
            .map( b -> b.getMaxX() ).orElse( 0.0 );

        return Math.max( startX, endX );
    }


    private int getStartInsertIndex()
    {
        return getInsertIndex( getLeftX(), Math.min( startY, endY ) );
    }

    private int getEndInsertIndex()
    {
        return getInsertIndex( getRightX(), Math.max( startY, endY ) );
    }

    private int getInsertIndex( double x, double y )
    {
        return getArea().hit( x, y ).getInsertionIndex();
    }


    public int getLeftColumn()
    {
        return getMaxColumnFor( getLeftX() );
    }

    public int getRightColumn()
    {
        return getMaxColumnFor( getRightX() );
    }

    private int getMaxColumnFor( double x )
    {
        var maxPos = -1;

        for ( int p = getStartParagraphIndex(); p <= getEndParagraphIndex(); p++ )
        {
            var centerY = getArea().screenToLocal( getArea().getParagraphBoundsOnScreen( p ).get() ).getCenterY();
            var pos = getArea().offsetToPosition( getInsertIndex( x, centerY ), Bias.Forward );
            maxPos = Math.max( maxPos, pos.getMinor() );
        }
        return maxPos;
    }


    private DataFormat dataFormat( String name )
    {
        var format = DataFormat.lookupMimeType( name );
        if ( format != null ) return format;
        return new DataFormat( name );
    }
}

[Jugen]

Using it has also been simplified to a one liner, just do:

var rectSelect = new RectangleSelection<>( "rectangle-selection", codeArea );

That's all, with copy, paste, etc. configured by RectangleSelection.

[lekhoon99]

Thank you so much @Jugen , this is working perfectly for copy, paste, cut and delete now.

[lekhoon99]

@Jugen, just realized a small flaw: when I pressed ALT + mouse select and started dragging from first line to the bottom towards the next page in text area, the selection for the previous page is gone.
Any hints where I shall change this? I am trying to look into selectRange and the start end position.

[Jugen]

Could you please try the following and let me know .....

In RectangleSelection replace getRanges with:

public List<IndexRange> getRanges()
{
    if ( selectedRanges.size() > 0 ) return selectedRanges;

    int leftCol = getLeftColumn();
    int rightCol = getRightColumn();

    for ( int p = getStartParagraphIndex(); p <= getEndParagraphIndex(); p++ )
    {
        int parLen = getArea().getParagraph( p ).length();
        int startNdx = getArea().getAbsolutePosition( p, Math.min( parLen, leftCol ) );
        int endNdx = getArea().getAbsolutePosition( p, Math.min( parLen, rightCol ) );

        selectedRanges.add( new IndexRange( startNdx, endNdx ) );
    }

    return selectedRanges;
}

[lekhoon99]

@Jugen The text selection still does not behave as expected.
I actually mouse drag to select "12345" from line 1 to line 36, but only 27 lines are visible on screen. Once I drag till line 36, line 1-8 are no longer visible on screen. When I scroll back to the top (line 1), the previously selected text (line 1 to 8) are no longer being selected.

[Jugen]

Ahh, sorry I misunderstood the problem. The problem is related to this piece of code:

    public void updateEndTo( Point2D end )
    {
        endX = end.getX(); endY = end.getY();
        var endIndex = getEndInsertIndex();

        if ( endIndex != getEndPosition() ) updateEndTo( endIndex );
        // else updateStartTo( getStartInsertIndex() );  // comment this out to fix
    }

The side affect of this though is that you can't change selection direction. That is if you started selecting down & right, then you can't change to down & left or up & left/right.

[lekhoon99]

Thanks @Jugen, the selection works now, but copy, paste, cut and delete are broken :)
So, I tried this

public List<IndexRange> getRanges()
{
	if ( selectedRanges.size() > 0 ) return selectedRanges;

	int leftCol = getLeftColumn();
	int rightCol = getRightColumn();

	for ( int p = getStartParagraphIndex(); p <= getEndParagraphIndex(); p++ )
	{
		int parLen = getArea().getParagraph( p ).length();
		int startNdx = getArea().getAbsolutePosition( p, Math.min( parLen, leftCol ) );
		int endNdx = getArea().getAbsolutePosition( p, Math.min( parLen, rightCol ) );

		selectedRanges.add( new IndexRange( startNdx, endNdx ) );
	}
		
	return selectedRanges;
}

and this...

private int getMaxColumnFor( double x )
{
	var maxPos = -1;
/*
	for ( int p = getStartParagraphIndex(); p <= getEndParagraphIndex(); p++ )
	{
		var centerY = getArea().screenToLocal( getArea().getParagraphBoundsOnScreen( p ).get() ).getCenterY();
		var pos = getArea().offsetToPosition( getInsertIndex( x, centerY ), Bias.Forward );
		maxPos = Math.max( maxPos, pos.getMinor() );
	}
*/
	for ( int p = getStartParagraphIndex(); p <= getEndParagraphIndex(); p++ )
	{
		int parLen = getArea().getParagraph( p ).length();
		var pos = getArea().offsetToPosition( getArea().getAbsolutePosition( p, Math.min( parLen, Double.valueOf(x).intValue() ) ), Bias.Forward );
		maxPos = Math.max( maxPos, pos.getMinor() );
	}

	return maxPos;
}

Able to copy the lines but text are not being copied (copy - paste 36 empty lines). Need help again..

[Jugen]

You're on the right track with the above. Keep the changes for getRanges but replace getMaxColumnFor with this:

private int getMaxColumnFor( double x )
{
    var maxPos = -1;
    for ( int p = getStartParagraphIndex(); p <= getEndParagraphIndex(); p++ )
    {
        var pb = getArea().getParagraphBoundsOnScreen( p );
        if ( pb.isPresent() )
        {
            var centerY = getArea().screenToLocal( pb.get() ).getCenterY();
            var pos = getArea().offsetToPosition( getInsertIndex( x, centerY ), Bias.Forward );
            maxPos = Math.max( maxPos, pos.getMinor() );
        }
    }
    return maxPos;
}

[lekhoon99]

@Jugen This is great, the feature is on its way to getting perfect :)

public void updateStartTo( Point2D start ) seems not being used elsewhere, or did I miss anything?

Selection with up right/left seems to have similar issue when scrolling up to the top of screen

[Jugen]

You are right updateStartTo isn't used anywhere, you can remove it.

It turns out that updateEndTo is trickier than I thought, here's my latest attempt:

public void updateEndTo( Point2D end )
{
    endX = end.getX(); endY = end.getY();

    if ( endY >= startY )     // adjusting below start
    {
        if ( endX >= startX ) updateEndTo( getEndInsertIndex() );       // adjusting below & right
        else                                                            // adjusting below & left
        {
            // The selection start may be off screen so can't be determined with startXY, instead
            // the unchanged current start paragraph index is used with a left column estimate.
            int newStart = getAbsolutePosition( getStartParagraphIndex(), getLeftColumn() );
            selectRange( newStart, getEndInsertIndex() );
        }
    }
    else                     // adjusting above start
    {
        if ( endX <= startX ) updateStartTo( getStartInsertIndex() );   // adjusting above & left
        else                                                            // adjusting above & right
        {
            // The selection end may be off screen so can't be determined with endXY, instead
            // the unchanged current end paragraph index is used with a right column estimate.
            int newEnd = getAbsolutePosition( getEndParagraphIndex(), getRightColumn() );
            selectRange( getStartInsertIndex(), newEnd );
        }
    }
}

private int getAbsolutePosition( int paragraph, int targetCol )
{
    int parLen = getArea().getParagraph( paragraph ).length();
    int col = Math.min( targetCol, parLen );
    return getArea().getAbsolutePosition( paragraph, col );
}