From 39cfd234ea84aa814137fb150c6909c99cd93ac3 Mon Sep 17 00:00:00 2001
From: Koen De Hondt <koen@dehondt.dev>
Date: Tue, 27 Oct 2026 12:38:36 +0100
Subject: [PATCH 1/4] Support multiple cursors.

---
 .../AlbTextEditorExamples.class.st            |  33 ++
 src/Album-Tests/AlbMultiCursorTest.class.st   | 470 ++++++++++++++++++
 .../AlbTextEditorHistoryTest.class.st         |  42 ++
 .../AlbTextEditorInserterTest.class.st        |   2 +-
 src/Album/AlbEditableMode.class.st            |   2 +
 .../AlbEditorAddCursorAboveShortcut.class.st  |  46 ++
 .../AlbEditorAddCursorBelowShortcut.class.st  |  46 ++
 .../AlbEditorDeselectAllShortcut.class.st     |   6 +-
 src/Album/AlbTextEditor.class.st              |  52 +-
 ...AlbTextEditorAbstractSegmentPiece.class.st | 100 ++--
 src/Album/AlbTextEditorDeleter.class.st       | 108 ++--
 ...ditorHistoryCursorMovementCommand.class.st |  21 +-
 src/Album/AlbTextEditorInserter.class.st      |  92 ++--
 .../AlbTextEditorLineSegmentHolder.class.st   |   4 +-
 src/Album/AlbTextEditorMouseHandler.class.st  |   9 +
 src/Album/AlbTextEditorNavigator.class.st     | 198 ++++++--
 src/Album/AlbTextEditorPaster.class.st        |   6 +-
 src/Album/AlbTextEditorSelecter.class.st      |   2 +
 .../AlbTextEditorShowCursorRequest.class.st   |  15 +-
 src/Album/AlbTextElement.class.st             | 126 +++--
 ...AlbTextWordPieceShowCursorHandler.class.st |  11 +-
 21 files changed, 1139 insertions(+), 252 deletions(-)
 create mode 100644 src/Album-Tests/AlbMultiCursorTest.class.st
 create mode 100644 src/Album/AlbEditorAddCursorAboveShortcut.class.st
 create mode 100644 src/Album/AlbEditorAddCursorBelowShortcut.class.st

diff --git a/src/Album-Examples/AlbTextEditorExamples.class.st b/src/Album-Examples/AlbTextEditorExamples.class.st
index 35049f5..e03617c 100644
--- a/src/Album-Examples/AlbTextEditorExamples.class.st
+++ b/src/Album-Examples/AlbTextEditorExamples.class.st
@@ -180,6 +180,39 @@ AlbTextEditorExamples class >> exampleMethodTextOpenEmbedElement [
 	space show
 ]
 
+{ #category : #examples }
+AlbTextEditorExamples class >> exampleMultiCursorEditing [
+	"Open an editor with a cursor at the start of every line: type to edit all lines at once.
+	Alt-click (Option-click on macOS) toggles a cursor,
+	Ctrl+Alt+Up/Down (Cmd+Option+Up/Down on macOS) adds a cursor above/below,
+	Escape keeps only the primary cursor"
+
+	<script>
+
+	| space editorElement editor text lineStarts |
+	text := String cr join: #(
+		'red := Color red.'
+		'green := Color green.'
+		'blue := Color blue.'
+		'yellow := Color yellow.' ).
+	editorElement := self newElement.
+	editorElement text: text asRopedText.
+	editorElement editor text attributes: { (BlFontSizeAttribute size: 18) }.
+	editor := editorElement editor.
+	lineStarts := OrderedCollection with: 0.
+	text withIndexDo: [ :each :index | each = Character cr ifTrue: [ lineStarts add: index ] ].
+	editor navigator
+		moveTo: lineStarts first;
+		apply.
+	lineStarts allButFirst do: [ :each | editor addCursorAt: each ].
+	space := BlSpace new.
+	space title: 'Album multi-cursor: Option/Alt-click, Cmd/Ctrl+Option+Up/Down, Esc'.
+	space extent: 700 @ 300.
+	space root addChild: editorElement.
+	space show.
+	editorElement infinite requestFocus
+]
+
 { #category : #examples }
 AlbTextEditorExamples class >> exampleTextOpen [
 	<script>
diff --git a/src/Album-Tests/AlbMultiCursorTest.class.st b/src/Album-Tests/AlbMultiCursorTest.class.st
new file mode 100644
index 0000000..7904826
--- /dev/null
+++ b/src/Album-Tests/AlbMultiCursorTest.class.st
@@ -0,0 +1,470 @@
+"
+I test multi-cursor editing in Album.
+
+Editor states are written in a compact notation: the text with a | at every cursor position.
+For example 'a|b|c' is the text abc with cursors at positions 1 and 2.
+#editorFrom: builds an editor from such a spec (the first | is the primary cursor), #specOf: renders an editor back.
+"
+Class {
+	#name : #AlbMultiCursorTest,
+	#superclass : #TestCase,
+	#category : #'Album-Tests-Operators'
+}
+
+{ #category : #helpers }
+AlbMultiCursorTest >> backspaceOracle: aSpec [
+	"The expected spec after deleting the character before every cursor: remove the character preceding each |, then merge cursors that meet"
+
+	| result |
+	result := OrderedCollection new.
+	aSpec do: [ :each |
+		each = $|
+			ifTrue: [
+				(result notEmpty and: [ result last ~= $| ]) ifTrue: [ result removeLast ].
+				(result notEmpty and: [ result last = $| ]) ifFalse: [ result add: $| ] ]
+			ifFalse: [ result add: each ] ].
+	^ String withAll: result
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> cursorElementsIn: anEditorElement [
+
+	| found |
+	anEditorElement forceLayout.
+	found := OrderedCollection new.
+	anEditorElement allChildrenBreadthFirstDo: [ :each |
+		(each isKindOf: AlbCursorElement) ifTrue: [ found add: each ] ].
+	^ found
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> editorFrom: aSpec [
+	"Return a text editor on the text of aSpec with a cursor at every | position. The first one is the primary cursor"
+
+	| positions text editor navigator |
+	positions := OrderedCollection new.
+	text := String streamContents: [ :out |
+		aSpec do: [ :each |
+			each = $|
+				ifTrue: [ positions add: out position ]
+				ifFalse: [ out nextPut: each ] ] ].
+	editor := AlbTextEditor new.
+	editor text: text asRopedText.
+	navigator := editor navigator.
+	navigator moveTo: positions first.
+	positions allButFirst do: [ :each | navigator addCursorAt: each ].
+	navigator apply.
+	^ editor
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> elementFrom: aSpec [
+	"Return a laid out editor element, for operations that need the rendered text"
+
+	| anElement aSpace |
+	anElement := AlbEditorElement new.
+	anElement constraintsDo: [ :c |
+		c horizontal exact: 400.
+		c vertical exact: 300 ].
+	aSpace := BlSpace new.
+	aSpace root addChild: anElement.
+	anElement text: (self editorFrom: aSpec) text.
+	anElement forceLayout.
+	self setCursorsOf: anElement editor from: aSpec.
+	anElement forceLayout.
+	^ anElement
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> lines: aCollectionOfStrings [
+
+	^ String cr join: aCollectionOfStrings
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> randomSpecUsing: aRandom [
+	"Return a random spec of up to 12 characters with at least one cursor"
+
+	| text positions |
+	text := String new: (aRandom nextInteger: 13) - 1.
+	1 to: text size do: [ :i | text at: i put: ('ab c' at: (aRandom nextInteger: 4)) ].
+	positions := (0 to: text size) select: [ :each | aRandom next < 0.3 ].
+	positions ifEmpty: [ positions := { (aRandom nextInteger: text size + 1) - 1 } ].
+	^ String streamContents: [ :out |
+		0 to: text size do: [ :i |
+			(positions includes: i) ifTrue: [ out nextPut: $| ].
+			i < text size ifTrue: [ out nextPut: (text at: i + 1) ] ] ]
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> setCursorsOf: anEditor from: aSpec [
+
+	| positions index navigator |
+	positions := OrderedCollection new.
+	index := 0.
+	aSpec do: [ :each |
+		each = $|
+			ifTrue: [ positions add: index ]
+			ifFalse: [ index := index + 1 ] ].
+	navigator := anEditor navigator.
+	navigator moveTo: positions first.
+	positions allButFirst do: [ :each | navigator addCursorAt: each ].
+	navigator apply
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> specOf: anEditor [
+	"Return the text of anEditor with a | at every cursor position"
+
+	| spec |
+	spec := anEditor text asString.
+	anEditor cursors reverseDo: [ :each |
+		spec := (spec first: each position) , '|' , (spec allButFirst: each position) ].
+	^ spec
+]
+
+{ #category : #'tests - cursors' }
+AlbMultiCursorTest >> test_add_cursor_at_existing_position_is_ignored [
+
+	| editor |
+	editor := self editorFrom: 'a|bc'.
+	editor addCursorAt: 1.
+	self assert: (self specOf: editor) equals: 'a|bc'.
+	self deny: editor hasMultipleCursors
+]
+
+{ #category : #'tests - shortcuts' }
+AlbMultiCursorTest >> test_add_cursor_below_and_above [
+
+	| element editor |
+	element := self elementFrom: (self lines: #( 'abc' 'd|ef' 'ghi' )).
+	editor := element editor.
+	AlbEditorAddCursorBelowShortcut new performOnEditor: editor element: element dueTo: nil.
+	element forceLayout.
+	AlbEditorAddCursorAboveShortcut new performOnEditor: editor element: element dueTo: nil.
+	self assert: (self specOf: editor) equals: (self lines: #( 'a|bc' 'd|ef' 'g|hi' ))
+]
+
+{ #category : #'tests - deleting' }
+AlbMultiCursorTest >> test_backspace_at_every_cursor [
+
+	| editor |
+	editor := self editorFrom: 'ab|cd|'.
+	editor deleter
+		oneBeforeCursor;
+		delete.
+	self assert: (self specOf: editor) equals: 'a|c|'
+]
+
+{ #category : #'tests - deleting' }
+AlbMultiCursorTest >> test_backspace_merges_cursors_that_meet [
+
+	| editor |
+	editor := self editorFrom: 'a|b|c'.
+	editor deleter
+		oneBeforeCursor;
+		delete.
+	self assert: (self specOf: editor) equals: '|c'.
+	self deny: editor hasMultipleCursors
+]
+
+{ #category : #'tests - cursors' }
+AlbMultiCursorTest >> test_cursors_are_sorted_and_primary_is_kept [
+
+	| editor |
+	editor := self editorFrom: 'ab|c|d'.
+	editor addCursorAt: 0.
+	self assert: (editor cursors collect: [ :each | each position ]) equals: #( 0 2 3 ).
+	self assert: editor cursor position equals: 2.
+	self assert: editor hasMultipleCursors
+]
+
+{ #category : #'tests - rendering' }
+AlbMultiCursorTest >> test_cursors_in_the_same_word_are_all_displayed [
+
+	| element positions |
+	element := self elementFrom: 'o|n|e two'.
+	positions := (self cursorElementsIn: element) collect: [ :each | each parent text asString -> each textPosition ].
+	self assert: positions asSet equals: { 'one' -> 1. 'one' -> 2 } asSet
+]
+
+{ #category : #'tests - shortcuts' }
+AlbMultiCursorTest >> test_escape_keeps_only_the_primary_cursor [
+
+	| element |
+	element := self elementFrom: 'a|b|c|'.
+	AlbEditorDeselectAllShortcut new performOnEditor: element editor element: element dueTo: nil.
+	self assert: (self specOf: element editor) equals: 'a|bc'
+]
+
+{ #category : #'tests - deleting' }
+AlbMultiCursorTest >> test_forward_delete_at_every_cursor [
+
+	| editor |
+	editor := self editorFrom: '|ab|cd'.
+	editor deleter
+		oneAfterCursor;
+		delete.
+	self assert: (self specOf: editor) equals: '|b|d'
+]
+
+{ #category : #'tests - deleting' }
+AlbMultiCursorTest >> test_forward_delete_merges_cursors_that_meet [
+
+	| editor |
+	editor := self editorFrom: '|a|bc'.
+	editor deleter
+		oneAfterCursor;
+		delete.
+	self assert: (self specOf: editor) equals: '|c'
+]
+
+{ #category : #'tests - inserting' }
+AlbMultiCursorTest >> test_insert_at_every_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|b|c|'.
+	editor inserter
+		atCursor;
+		string: 'X';
+		insert.
+	self assert: (self specOf: editor) equals: 'aX|bX|cX|'
+]
+
+{ #category : #'tests - inserting' }
+AlbMultiCursorTest >> test_insert_at_start_and_end [
+
+	| editor |
+	editor := self editorFrom: '|abc|'.
+	editor inserter
+		atCursor;
+		string: '#';
+		insert.
+	self assert: (self specOf: editor) equals: '#|abc#|'
+]
+
+{ #category : #'tests - inserting' }
+AlbMultiCursorTest >> test_insert_several_characters_at_adjacent_cursors [
+
+	| editor |
+	editor := self editorFrom: 'a|b|'.
+	editor inserter
+		atCursor;
+		string: 'xyz';
+		insert.
+	self assert: (self specOf: editor) equals: 'axyz|bxyz|'
+]
+
+{ #category : #'tests - cursors' }
+AlbMultiCursorTest >> test_last_cursor_is_never_removed [
+
+	| editor |
+	editor := self editorFrom: 'a|bc'.
+	editor navigator
+		removeCursorAt: 1;
+		apply.
+	self assert: (self specOf: editor) equals: 'a|bc'
+]
+
+{ #category : #'tests - inserting' }
+AlbMultiCursorTest >> test_line_ending_keeps_the_indentation_of_each_cursor_line [
+
+	| editor |
+	editor := self editorFrom: (self lines: { String tab , 'a|'. 'b|' }).
+	editor inserter
+		atCursor;
+		crLineEndingWithWhitespace;
+		insert.
+	self assert: (self specOf: editor) equals: (self lines: { String tab , 'a'. String tab , '|'. 'b'. '|' })
+]
+
+{ #category : #'tests - rendering' }
+AlbMultiCursorTest >> test_merged_cursors_remove_their_elements [
+
+	| element |
+	element := self elementFrom: 'a|b|cd|'.
+	element editor deleter
+		oneBeforeCursor;
+		delete.
+	self assert: (self specOf: element editor) equals: '|c|'.
+	self assert: (self cursorElementsIn: element) size equals: 2
+]
+
+{ #category : #'tests - cursors' }
+AlbMultiCursorTest >> test_moveTo_keeps_a_single_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|b|c|'.
+	editor navigator
+		moveTo: 0;
+		apply.
+	self assert: (self specOf: editor) equals: '|abc'
+]
+
+{ #category : #'tests - navigating' }
+AlbMultiCursorTest >> test_move_down_moves_every_cursor [
+
+	| element |
+	element := self elementFrom: (self lines: #( 'a|bc|' 'def' 'ghi' )).
+	element editor navigator
+		moveDown;
+		apply.
+	self assert: (self specOf: element editor) equals: (self lines: #( 'abc' 'd|ef|' 'ghi' ))
+]
+
+{ #category : #'tests - navigating' }
+AlbMultiCursorTest >> test_move_left_and_right_move_every_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|bc|d'.
+	editor navigator
+		moveRight;
+		apply.
+	self assert: (self specOf: editor) equals: 'ab|cd|'.
+	editor navigator
+		moveLeft;
+		apply.
+	editor navigator
+		moveLeft;
+		apply.
+	self assert: (self specOf: editor) equals: '|ab|cd'
+]
+
+{ #category : #'tests - navigating' }
+AlbMultiCursorTest >> test_move_left_merges_cursors_at_text_start [
+
+	| editor |
+	editor := self editorFrom: '|a|b'.
+	editor navigator
+		moveLeft;
+		apply.
+	self assert: (self specOf: editor) equals: '|ab'
+]
+
+{ #category : #'tests - navigating' }
+AlbMultiCursorTest >> test_move_to_line_start_and_end_per_cursor [
+
+	| editor |
+	editor := self editorFrom: (self lines: #( 'ab|c' 'd|ef' )).
+	editor navigator
+		moveToLineEnd;
+		apply.
+	self assert: (self specOf: editor) equals: (self lines: #( 'abc|' 'def|' )).
+	editor navigator
+		moveToLineStart;
+		apply.
+	self assert: (self specOf: editor) equals: (self lines: #( '|abc' '|def' ))
+]
+
+{ #category : #'tests - rendering' }
+AlbMultiCursorTest >> test_one_cursor_element_per_cursor [
+
+	| element cursorElements |
+	element := self elementFrom: (self lines: #( 'o|ne t|wo' 'thr|ee' )).
+	cursorElements := self cursorElementsIn: element.
+	self assert: cursorElements size equals: 3.
+	self assert: (cursorElements select: [ :each | each == element cursorElement ]) size equals: 1
+]
+
+{ #category : #'tests - inserting' }
+AlbMultiCursorTest >> test_paste_at_every_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|b|'.
+	editor paster
+		text: '--';
+		atCursor;
+		paste.
+	self assert: (self specOf: editor) equals: 'a--|b--|'
+]
+
+{ #category : #'tests - oracle' }
+AlbMultiCursorTest >> test_random_backspaces_match_oracle [
+
+	| random |
+	random := Random seed: 7.
+	200 timesRepeat: [
+		| spec editor |
+		spec := self randomSpecUsing: random.
+		editor := self editorFrom: spec.
+		editor deleter
+			oneBeforeCursor;
+			delete.
+		self assert: (self specOf: editor) equals: (self backspaceOracle: spec) ]
+]
+
+{ #category : #'tests - oracle' }
+AlbMultiCursorTest >> test_random_insertions_match_oracle [
+
+	| random |
+	random := Random seed: 42.
+	200 timesRepeat: [
+		| spec editor |
+		spec := self randomSpecUsing: random.
+		editor := self editorFrom: spec.
+		editor inserter
+			atCursor;
+			string: 'xy';
+			insert.
+		self
+			assert: (self specOf: editor)
+			equals: (spec copyReplaceAll: '|' with: 'xy|') ]
+]
+
+{ #category : #'tests - cursors' }
+AlbMultiCursorTest >> test_removeSecondaryCursors [
+
+	| editor |
+	editor := self editorFrom: 'a|b|c|'.
+	editor removeSecondaryCursors.
+	self assert: (self specOf: editor) equals: 'a|bc'
+]
+
+{ #category : #'tests - cursors' }
+AlbMultiCursorTest >> test_remove_primary_cursor_promotes_a_secondary_one [
+
+	| editor |
+	editor := self editorFrom: '|ab|c'.
+	editor navigator
+		removeCursorAt: 0;
+		apply.
+	self assert: (self specOf: editor) equals: 'ab|c'.
+	self assert: editor cursor position equals: 2
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_selecting_keeps_only_the_primary_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|b|c'.
+	editor select: 0 to: 2.
+	self deny: editor hasMultipleCursors.
+	self assert: editor cursor position equals: 1
+]
+
+{ #category : #'tests - history' }
+AlbMultiCursorTest >> test_undo_and_redo_insertion_restore_every_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|b|c'.
+	editor inserter
+		atCursor;
+		string: 'X';
+		insert.
+	editor undo.
+	self assert: (self specOf: editor) equals: 'a|b|c'.
+	editor redo.
+	self assert: (self specOf: editor) equals: 'aX|bX|c'
+]
+
+{ #category : #'tests - history' }
+AlbMultiCursorTest >> test_undo_deletion_restores_every_cursor [
+
+	| editor |
+	editor := self editorFrom: 'ab|cd|'.
+	editor deleter
+		oneBeforeCursor;
+		delete.
+	editor undo.
+	self assert: (self specOf: editor) equals: 'ab|cd|'
+]
diff --git a/src/Album-Tests/AlbTextEditorHistoryTest.class.st b/src/Album-Tests/AlbTextEditorHistoryTest.class.st
index a6ef9d1..81a7191 100644
--- a/src/Album-Tests/AlbTextEditorHistoryTest.class.st
+++ b/src/Album-Tests/AlbTextEditorHistoryTest.class.st
@@ -4,6 +4,24 @@ Class {
 	#category : #'Album-Tests-TextEditor'
 }
 
+{ #category : #tests }
+AlbTextEditorHistoryTest >> test_insert_at_two_indices_and_undo_then_redo [
+
+	| editorElement editor |
+	editorElement := 'abcdef' asRopedText onAlbum.
+	editor := editorElement editor.
+	editor inserter
+		at: 1;
+		at: 3;
+		string: 'X';
+		insert.
+	self assert: editor text asString equals: 'aXbcXdef'.
+	editor undo.
+	self assert: editor text asString equals: 'abcdef'.
+	editor redo.
+	self assert: editor text asString equals: 'aXbcXdef'
+]
+
 { #category : #tests }
 AlbTextEditorHistoryTest >> test_insert_one_char_and_undo [
 
@@ -57,6 +75,30 @@ AlbTextEditorHistoryTest >> test_insert_open_close_parentheses_with_selection_an
 	self assert: editor text asString equals: 'abc'.
 ]
 
+{ #category : #tests }
+AlbTextEditorHistoryTest >> test_insert_open_close_parentheses_with_selection_and_undo_then_redo [
+
+	| editorElement editor |
+	editorElement := '' asRopedText onAlbum.
+	editor := editorElement editor.
+	editor inserter
+		at: 0;
+		string: 'abc';
+		insert.
+	editor selecter all select.
+	editor inserter
+		atCursor;
+		string: '(';
+		withoutSelectionDelete;
+		surroundings: (AlbTextEditorSurroundMap newFromArray: { '('. ')'. nil });
+		insert.
+	self assert: editor text asString equals: '(abc)'.
+	editor undo.
+	self assert: editor text asString equals: 'abc'.
+	editor redo.
+	self assert: editor text asString equals: '(abc)'
+]
+
 { #category : #tests }
 AlbTextEditorHistoryTest >> test_insert_select_remove_and_undo_then_redo2 [
 
diff --git a/src/Album-Tests/AlbTextEditorInserterTest.class.st b/src/Album-Tests/AlbTextEditorInserterTest.class.st
index c5eded4..e1039d1 100644
--- a/src/Album-Tests/AlbTextEditorInserterTest.class.st
+++ b/src/Album-Tests/AlbTextEditorInserterTest.class.st
@@ -97,7 +97,7 @@ AlbTextEditorInserterTest >> test_filter_insert_Hello123_onlyLetters [
 AlbTextEditorInserterTest >> test_insert_Hello_atCursorAt_0_and_1_selection_no [
 	
 	| anEditor anEditorElement |
-	"Album is mono cursor, only last moveTo is actually done"
+	"moveTo: keeps a single cursor, so only the last moveTo: counts (see AlbMultiCursorTest for #addCursorAt:)"
 	anEditorElement := self newEditorElementWithMultilineText.
 	anEditor := anEditorElement editor.
 	space deferAndSettle: [
diff --git a/src/Album/AlbEditableMode.class.st b/src/Album/AlbEditableMode.class.st
index 3046a98..d77a9b0 100644
--- a/src/Album/AlbEditableMode.class.st
+++ b/src/Album/AlbEditableMode.class.st
@@ -52,6 +52,8 @@ AlbEditableMode >> defaultShortcuts [
 		  AlbEditorMoveCursorRightShortcut new.
 		  AlbEditorMoveCursorUpShortcut new.
 		  AlbEditorMoveCursorDownShortcut new.
+		  AlbEditorAddCursorAboveShortcut new.
+		  AlbEditorAddCursorBelowShortcut new.
 		  AlbEditorMoveCursorToPreviousWordShortcut new.
 		  AlbEditorMoveCursorToNextWordShortcut new.
 		  AlbEditorMoveCursorToLineStartShortcut new.
diff --git a/src/Album/AlbEditorAddCursorAboveShortcut.class.st b/src/Album/AlbEditorAddCursorAboveShortcut.class.st
new file mode 100644
index 0000000..eb86a83
--- /dev/null
+++ b/src/Album/AlbEditorAddCursorAboveShortcut.class.st
@@ -0,0 +1,46 @@
+"
+I add a cursor one line above the top-most cursor (Ctrl+Alt+Up, or Cmd+Alt+Up on macOS).
+"
+Class {
+	#name : #AlbEditorAddCursorAboveShortcut,
+	#superclass : #AlbEditorShortcut,
+	#category : #'Album-Shortcuts'
+}
+
+{ #category : #'api - combination' }
+AlbEditorAddCursorAboveShortcut >> combinationForMacOS [
+
+	^ BlKeyCombination builder meta alt arrowUp build
+]
+
+{ #category : #accessing }
+AlbEditorAddCursorAboveShortcut >> description [
+
+	^ 'Adds a cursor one line above the top-most cursor.'
+]
+
+{ #category : #initialization }
+AlbEditorAddCursorAboveShortcut >> initialize [
+
+	super initialize.
+	combination := BlKeyCombination builder control alt arrowUp build
+]
+
+{ #category : #accessing }
+AlbEditorAddCursorAboveShortcut >> name [
+
+	^ 'Add cursor above'
+]
+
+{ #category : #evaluation }
+AlbEditorAddCursorAboveShortcut >> performOnEditor: aTextEditor element: anEditorElement dueTo: aShortcutEvent [
+
+	| anIndex |
+	anIndex := aTextEditor navigator
+		findTextIndexAboveCursor: aTextEditor cursors first
+		ifAbsent: [ ^ self ].
+	aTextEditor deselecter
+		all;
+		deselect.
+	aTextEditor addCursorAt: anIndex
+]
diff --git a/src/Album/AlbEditorAddCursorBelowShortcut.class.st b/src/Album/AlbEditorAddCursorBelowShortcut.class.st
new file mode 100644
index 0000000..29ae1bb
--- /dev/null
+++ b/src/Album/AlbEditorAddCursorBelowShortcut.class.st
@@ -0,0 +1,46 @@
+"
+I add a cursor one line below the bottom-most cursor (Ctrl+Alt+Down, or Cmd+Alt+Down on macOS).
+"
+Class {
+	#name : #AlbEditorAddCursorBelowShortcut,
+	#superclass : #AlbEditorShortcut,
+	#category : #'Album-Shortcuts'
+}
+
+{ #category : #'api - combination' }
+AlbEditorAddCursorBelowShortcut >> combinationForMacOS [
+
+	^ BlKeyCombination builder meta alt arrowDown build
+]
+
+{ #category : #accessing }
+AlbEditorAddCursorBelowShortcut >> description [
+
+	^ 'Adds a cursor one line below the bottom-most cursor.'
+]
+
+{ #category : #initialization }
+AlbEditorAddCursorBelowShortcut >> initialize [
+
+	super initialize.
+	combination := BlKeyCombination builder control alt arrowDown build
+]
+
+{ #category : #accessing }
+AlbEditorAddCursorBelowShortcut >> name [
+
+	^ 'Add cursor below'
+]
+
+{ #category : #evaluation }
+AlbEditorAddCursorBelowShortcut >> performOnEditor: aTextEditor element: anEditorElement dueTo: aShortcutEvent [
+
+	| anIndex |
+	anIndex := aTextEditor navigator
+		findTextIndexBelowCursor: aTextEditor cursors last
+		ifAbsent: [ ^ self ].
+	aTextEditor deselecter
+		all;
+		deselect.
+	aTextEditor addCursorAt: anIndex
+]
diff --git a/src/Album/AlbEditorDeselectAllShortcut.class.st b/src/Album/AlbEditorDeselectAllShortcut.class.st
index ba41e3a..3f7e191 100644
--- a/src/Album/AlbEditorDeselectAllShortcut.class.st
+++ b/src/Album/AlbEditorDeselectAllShortcut.class.st
@@ -6,7 +6,8 @@ Class {
 
 { #category : #accessing }
 AlbEditorDeselectAllShortcut >> description [
-	^ 'Deselects any currently selected text.'
+
+	^ 'Deselects any currently selected text and keeps only the primary cursor.'
 ]
 
 { #category : #initialization }
@@ -24,5 +25,6 @@ AlbEditorDeselectAllShortcut >> name [
 { #category : #evaluation }
 AlbEditorDeselectAllShortcut >> performOnEditor: aTextEditor element: aEditorElement dueTo: aShortcutEvent [
 
-	aTextEditor selectNone
+	aTextEditor selectNone.
+	aTextEditor removeSecondaryCursors
 ]
diff --git a/src/Album/AlbTextEditor.class.st b/src/Album/AlbTextEditor.class.st
index 45f528d..ee98d1c 100644
--- a/src/Album/AlbTextEditor.class.st
+++ b/src/Album/AlbTextEditor.class.st
@@ -17,7 +17,8 @@ Class {
 		'isFocused',
 		'cursor',
 		'hasEventHandlerAttribute',
-		'layoutPositionsRange'
+		'layoutPositionsRange',
+		'secondaryCursors'
 	],
 	#classInstVars : [
 		'isDebug'
@@ -42,6 +43,15 @@ AlbTextEditor class >> isDebug: aBoolean [
 	isDebug := aBoolean
 ]
 
+{ #category : #'cursor - management' }
+AlbTextEditor >> addCursorAt: aTextIndex [
+	"Add a cursor at a given text index. Nothing happens if a cursor is already there"
+
+	self navigator
+		addCursorAt: aTextIndex;
+		apply
+]
+
 { #category : #'api - shortcuts' }
 AlbTextEditor >> addEditorShortcut: aTextEditorShortcut [
 
@@ -132,10 +142,10 @@ AlbTextEditor >> cursor: aCursor [
 
 { #category : #accessing }
 AlbTextEditor >> cursors [
+	"Return all cursors (the primary one included) sorted by text position"
 
-	self deprecated: 'Use #cursor'.
-
-	^  { self cursor } 
+	<return: #Array of: #AlbTextEditorCursor>
+	^ ((self secondaryCursors copyWith: self cursor) asSortedCollection: [ :a :b | a position <= b position ]) asArray
 ]
 
 { #category : #'text - copy/paste' }
@@ -260,6 +270,12 @@ AlbTextEditor >> hasEventHandlerAttribute [
 	^ hasEventHandlerAttribute ifNil: [ false ]
 ]
 
+{ #category : #testing }
+AlbTextEditor >> hasMultipleCursors [
+
+	^ self secondaryCursors notEmpty
+]
+
 { #category : #'text - selection' }
 AlbTextEditor >> hasSelection [
 	"Return true of there is at least one selected character, false otherwise"
@@ -285,17 +301,15 @@ AlbTextEditor >> history: aTextEditorHistory [
 AlbTextEditor >> initialize [
 
 	super initialize.
-
 	hasEventHandlerAttribute := false.
 	filter := AlbTextEditorNoInputFilter new.
 	cursor := self defaultCursor.
+	secondaryCursors := OrderedCollection new.
 	selection := self defaultSelection.
 	selectionRecorder := self defaultSelectionRecorder.
 	shortcuts := AlbTextEditorShortcuts new.
 	history := AlbTextEditorHistory new.
-
 	isFocused := false.
-
 	self text: self defaultText
 ]
 
@@ -765,6 +779,16 @@ AlbTextEditor >> removeEditorShortcuts: aCollectionOfTextEditorShortcut [
 	aCollectionOfTextEditorShortcut do: [ :eachShortcut | self removeEditorShortcut: eachShortcut ]
 ]
 
+{ #category : #'cursor - management' }
+AlbTextEditor >> removeSecondaryCursors [
+	"Keep only the primary cursor"
+
+	self hasMultipleCursors ifFalse: [ ^ self ].
+	self navigator
+		removeSecondaryCursors;
+		apply
+]
+
 { #category : #'api - save state' }
 AlbTextEditor >> restoreState: aTextEditorMemento [
 
@@ -773,26 +797,21 @@ AlbTextEditor >> restoreState: aTextEditorMemento [
 
 { #category : #accessing }
 AlbTextEditor >> restoreText: aText [
-
 	"before changing the text we must unsubscribe from existing one"
-
 	text ifNotNil: [ text unsubscribe: self ].
 	self history setUpToStart.
 	cursor := self defaultCursor.
-
+	secondaryCursors := OrderedCollection new.
 	text := aText.
 	" then subscribe to internal text state change (insertion/deletion/attribute change) "
 	self initializeText: text.
-
 	"Replacing text instance means that we can not guarantee structural integrity
 	of existing cache and have to rebuild it invalidating the whole underlying model structure"
 	segmentCollector
 		ifNil: [ segmentCollector := self newSegmentCollector ]
 		ifNotNil: [ segmentCollector resetCache ].
 	segmentCollector text: text.
-
 	self onTextReplaced.
-
 	"notify UI about structural update"
 	self notifyChanged
 ]
@@ -811,6 +830,13 @@ AlbTextEditor >> saveState: aTextEditorMemento [
 	^ aTextEditorMemento saveStateOf: self
 ]
 
+{ #category : #'accessing - cursors' }
+AlbTextEditor >> secondaryCursors [
+	"Return the additional cursors, besides the primary #cursor"
+
+	^ secondaryCursors ifNil: [ secondaryCursors := OrderedCollection new ]
+]
+
 { #category : #accessing }
 AlbTextEditor >> segmentCollector [
 	<return: #AlbTextEditorSegmentCollector>
diff --git a/src/Album/AlbTextEditorAbstractSegmentPiece.class.st b/src/Album/AlbTextEditorAbstractSegmentPiece.class.st
index dda7d18..ee573db 100644
--- a/src/Album/AlbTextEditorAbstractSegmentPiece.class.st
+++ b/src/Album/AlbTextEditorAbstractSegmentPiece.class.st
@@ -5,21 +5,16 @@ Class {
 	#classTraits : 'TAlbTextEditorTextualPiece classTrait',
 	#instVars : [
 		'segment',
-		'currentCursor'
+		'currentCursor',
+		'currentCursors'
 	],
 	#category : #'Album-Model-Segment'
 }
 
 { #category : #updating }
 AlbTextEditorAbstractSegmentPiece >> addCursor: aPieceElement of: aLineSegment in: anEditorElement [
-	| globalCursor |
-	"if text editor cursor is currently within this segment piece then convert it to a local one"
 
-	globalCursor := anEditorElement cursor.
-	(globalCursor insideSubText: self of: aLineSegment) ifFalse: [^self ].
-	currentCursor := self globalCursorToLocal: globalCursor.
-	"tell to add the new cursor"
-	self onCursorAdded: currentCursor to: aPieceElement in: anEditorElement
+	self syncCursors: aPieceElement of: aLineSegment in: anEditorElement
 ]
 
 { #category : #'instance creation' }
@@ -44,6 +39,19 @@ AlbTextEditorAbstractSegmentPiece >> currentCursor: aCursor [
 	currentCursor := aCursor
 ]
 
+{ #category : #accessing }
+AlbTextEditorAbstractSegmentPiece >> currentCursors [
+	"Return the local cursors displayed by this piece, as associations local cursor -> isPrimary"
+
+	^ currentCursors
+]
+
+{ #category : #accessing }
+AlbTextEditorAbstractSegmentPiece >> currentCursors: aCollection [
+
+	currentCursors := aCollection
+]
+
 { #category : #'api - cursor' }
 AlbTextEditorAbstractSegmentPiece >> globalCursorToLocal: aSingleCursor [
 	"Convert a global cursor as specified in the editor to a local one"
@@ -72,6 +80,16 @@ AlbTextEditorAbstractSegmentPiece >> isText [
 	^ false
 ]
 
+{ #category : #cursor }
+AlbTextEditorAbstractSegmentPiece >> localCursorsOf: aLineSegment in: anEditorElement [
+	"Return the editor cursors located in this piece, converted to local ones, as associations local cursor -> isPrimary"
+
+	| aPrimaryCursor |
+	aPrimaryCursor := anEditorElement editor cursor.
+	^ (anEditorElement editor cursors select: [ :eachCursor | eachCursor insideSubText: self of: aLineSegment ])
+		collect: [ :eachCursor | (self globalCursorToLocal: eachCursor) -> (eachCursor == aPrimaryCursor) ]
+]
+
 { #category : #'cursor - hooks' }
 AlbTextEditorAbstractSegmentPiece >> onCursorAdded: aCursor to: aPieceElement in: anEditorElement [
 	"Is sent when a cursor is added to a given piece element within provided editor element"
@@ -83,6 +101,17 @@ AlbTextEditorAbstractSegmentPiece >> onCursorAdded: aCursor to: aPieceElement in
 			cursorPosition: aCursor position)
 ]
 
+{ #category : #cursor }
+AlbTextEditorAbstractSegmentPiece >> onCursorAdded: aCursor to: aPieceElement in: anEditorElement primary: isPrimary [
+	"Is sent when a cursor is added to a given piece element within provided editor element"
+
+	aPieceElement dispatchEvent: (AlbTextEditorShowCursorRequest new
+		 editorElement: anEditorElement;
+		 hasFocus: anEditorElement isFocused;
+		 cursorPosition: aCursor position;
+		 isPrimary: isPrimary)
+]
+
 { #category : #'cursor - hooks' }
 AlbTextEditorAbstractSegmentPiece >> onCursorRemoved: aCursor from: aPieceElement in: anEditorElement [
 	"Is sent when a cursor is removed from a given piece element within provided editor element"
@@ -96,9 +125,10 @@ AlbTextEditorAbstractSegmentPiece >> onCursorRemoved: aCursor from: aPieceElemen
 { #category : #updating }
 AlbTextEditorAbstractSegmentPiece >> removeCursor: aPieceElement of: aLineSegment in: anEditorElement [
 
-	currentCursor ifNil: [ ^ self ].
-	self onCursorRemoved: currentCursor from: aPieceElement in: anEditorElement.
-	"update the current cursor"
+	currentCursors
+		ifNotNil: [ :theCursors | theCursors do: [ :each | self onCursorRemoved: each key from: aPieceElement in: anEditorElement ] ]
+		ifNil: [ currentCursor ifNotNil: [ self onCursorRemoved: currentCursor from: aPieceElement in: anEditorElement ] ].
+	currentCursors := nil.
 	currentCursor := nil
 ]
 
@@ -123,44 +153,36 @@ AlbTextEditorAbstractSegmentPiece >> segment: anObject [
 
 { #category : #updating }
 AlbTextEditorAbstractSegmentPiece >> setCursor: aPieceElement of: aLineSegment in: anEditorElement [
-	| aFocusRequest localCursor globalCursor |
-	"get the global cursor "
-	globalCursor := anEditorElement cursor.
-	"if text editor cursor is currently within this segment piece then convert it to a local one"
-	(globalCursor insideSubText: self of: aLineSegment) ifTrue: [ localCursor := self globalCursorToLocal: globalCursor ].
-	
-	"update current cursors"
-	currentCursor := localCursor.
-
-	"tell to add new cursors"
-	currentCursor ifNotNil: [ self onCursorAdded: currentCursor to: aPieceElement in: anEditorElement ].
 
+	| aFocusRequest |
+	self syncCursors: aPieceElement of: aLineSegment in: anEditorElement.
 	"set the focus"
 	aFocusRequest := anEditorElement isFocused
 		ifTrue: [ AlbTextEditorFocusRequest new ]
 		ifFalse: [ AlbTextEditorBlurRequest new ].
-	aPieceElement
-		dispatchEvent: (aFocusRequest editorElement: anEditorElement)
+	aPieceElement dispatchEvent: (aFocusRequest editorElement: anEditorElement)
+]
+
+{ #category : #cursor }
+AlbTextEditorAbstractSegmentPiece >> syncCursors: aPieceElement of: aLineSegment in: anEditorElement [
+	"Display exactly the editor cursors located in this piece"
+
+	self removeCursor: aPieceElement of: aLineSegment in: anEditorElement.
+	currentCursors := self localCursorsOf: aLineSegment in: anEditorElement.
+	currentCursors ifEmpty: [ ^ currentCursors := nil ].
+	currentCursor := (currentCursors detect: [ :each | each value ] ifNone: [ currentCursors first ]) key.
+	currentCursors do: [ :each |
+		self
+			onCursorAdded: each key
+			to: aPieceElement
+			in: anEditorElement
+			primary: each value ]
 ]
 
 { #category : #updating }
 AlbTextEditorAbstractSegmentPiece >> updateCursor: aPieceElement of: aLineSegment in: anEditorElement [
-	| globalCursor localCursor |
-self flag: 'to be checked because of failing tests AlbTextEditorNavigatorTest>>test_cursor_add_at_1_in_multiline'.
-	"if text editor cursor is currently within this segment piece then convert it to a local one"
-
-	globalCursor := anEditorElement cursor.
-
-	(globalCursor insideSubText: self of: aLineSegment) ifTrue: [ localCursor := self globalCursorToLocal: globalCursor ].
-	
-	"tell to remove the deleted cursor"
-	currentCursor ifNotNil: [ self onCursorRemoved: currentCursor from: aPieceElement in: anEditorElement ].
-
-	"update the current cursor"
-	currentCursor := localCursor.
 
-	"tell to add the new cursor"
-	currentCursor ifNotNil: [ self onCursorAdded: currentCursor to: aPieceElement in: anEditorElement ]
+	self syncCursors: aPieceElement of: aLineSegment in: anEditorElement
 ]
 
 { #category : #updating }
diff --git a/src/Album/AlbTextEditorDeleter.class.st b/src/Album/AlbTextEditorDeleter.class.st
index 0b14192..3200250 100644
--- a/src/Album/AlbTextEditorDeleter.class.st
+++ b/src/Album/AlbTextEditorDeleter.class.st
@@ -78,15 +78,13 @@ AlbTextEditorDeleter >> computeSelectionMovement: aMonotoneSelection [
 
 { #category : #'api - processing' }
 AlbTextEditorDeleter >> delete [
-	"Perform deletion operation"
+	"Perform deletion operation. All intervals are deleted as a single undoable step"
 
-	shouldUpdateCursor
-		ifTrue: [ self updateCursors ].
-
-	shouldUpdateSelection
-		ifTrue: [ self updateSelection ].
-
-	deletionIntervals reverseDo: [ :aMonotoneSelection | self privateDelete: aMonotoneSelection from to: aMonotoneSelection to]
+	editor history groupDuring: [
+		shouldUpdateCursor ifTrue: [ self updateCursors ].
+		shouldUpdateSelection ifTrue: [ self updateSelection ].
+		deletionIntervals reverseDo: [ :aMonotoneSelection |
+			self privateDelete: aMonotoneSelection from to: aMonotoneSelection to ] ]
 ]
 
 { #category : #'api - configuration' }
@@ -115,33 +113,31 @@ AlbTextEditorDeleter >> isDeleter [
 
 { #category : #'api - configuration' }
 AlbTextEditorDeleter >> oneAfterCursor [
-	"Delete one symbol after the cursor"
-		
-	| aCursor |
-	aCursor := self cursor.
-	self
-		from: aCursor position
-		to: ((aCursor position + 1) min: self text size)
+	"Delete one symbol after every cursor"
+
+	editor cursors do: [ :eachCursor |
+		self
+			from: eachCursor position
+			to: ((eachCursor position + 1) min: self text size) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorDeleter >> oneAfterCursorIfOutsideOfSelection [
-	"Delete one symbol after the cursor but only if there is no selection nearby"
-		
-	| aCursor |
-	aCursor := self cursor.
-	(self selection contains: aCursor position)
-		ifFalse: [
-			self
-				from: aCursor position
-				to: ((aCursor position + 1) min: self text size) ]
+	"Delete one symbol after every cursor but only if there is no selection nearby"
+
+	editor cursors do: [ :eachCursor |
+		(self selection contains: eachCursor position)
+			ifFalse: [
+				self
+					from: eachCursor position
+					to: ((eachCursor position + 1) min: self text size) ] ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorDeleter >> oneBeforeCursor [
-	"Delete one symbol before the cursor"
+	"Delete one symbol before every cursor"
 
-	self oneBeforeCursor: self cursor
+	editor cursors do: [ :eachCursor | self oneBeforeCursor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
@@ -155,12 +151,11 @@ AlbTextEditorDeleter >> oneBeforeCursor: aCursor [
 
 { #category : #'api - configuration' }
 AlbTextEditorDeleter >> oneBeforeCursorIfOutsideOfSelection [
-	"Delete one symbol before the cursor but only if there is no selection nearby"
+	"Delete one symbol before every cursor but only if there is no selection nearby"
 
-	| aCursor |
-	aCursor := self cursor.
-	(self selection contains: aCursor position)
-		ifFalse: [ self oneBeforeCursor: aCursor ]
+	editor cursors do: [ :eachCursor |
+		(self selection contains: eachCursor position)
+			ifFalse: [ self oneBeforeCursor: eachCursor ] ]
 ]
 
 { #category : #private }
@@ -193,37 +188,40 @@ AlbTextEditorDeleter >> selected [
 
 { #category : #'api - configuration' }
 AlbTextEditorDeleter >> surroundings: aDictionaryOrArray [
-	"Delete the surrounding around the cursor (if there is any) but only if the cursor is not part of the selection"
-	| theAssociations aCursor |
-	
+	"Delete the surrounding around every cursor (if there is any) but only if the cursor is not part of the selection"
+
+	| theAssociations |
 	theAssociations := aDictionaryOrArray isArray
 		ifFalse: [ aDictionaryOrArray associations ]
 		ifTrue: [ aDictionaryOrArray ].
-	
-	aCursor := self cursor.
-	(self selection contains: aCursor position)
-		ifFalse: [
-			theAssociations
-				detect: [ :eachReplacement |
-					(self hasString: eachReplacement key beforeCursor: aCursor)
-						and: [ self hasString: eachReplacement value afterCursor: aCursor ] ]
-				ifFound: [ :aReplacement |
-					self
-						from: aCursor position - aReplacement key size
-						to: aCursor position + aReplacement value size ] ]
+	editor cursors do: [ :eachCursor |
+		(self selection contains: eachCursor position)
+			ifFalse: [
+				theAssociations
+					detect: [ :eachReplacement |
+						(self hasString: eachReplacement key beforeCursor: eachCursor)
+							and: [ self hasString: eachReplacement value afterCursor: eachCursor ] ]
+					ifFound: [ :aReplacement |
+						self
+							from: eachCursor position - aReplacement key size
+							to: eachCursor position + aReplacement value size ] ] ]
 ]
 
 { #category : #private }
 AlbTextEditorDeleter >> updateCursors [
-	| aCursor aCursorDelta |
-	
-	aCursor := self cursor.
-	aCursorDelta := self computeCursorMovement: aCursor.
-	aCursorDelta isZero
-		ifFalse: [ self editor navigator
-			dueTo: self;
-			move: aCursor by: aCursorDelta;
-			apply ]
+
+	| aNavigator hasMoves |
+	aNavigator := self editor navigator
+		dueTo: self;
+		yourself.
+	hasMoves := false.
+	editor cursors do: [ :eachCursor |
+		| aCursorDelta |
+		aCursorDelta := self computeCursorMovement: eachCursor.
+		aCursorDelta isZero ifFalse: [
+			hasMoves := true.
+			aNavigator move: eachCursor by: aCursorDelta ] ].
+	hasMoves ifTrue: [ aNavigator apply ]
 ]
 
 { #category : #private }
diff --git a/src/Album/AlbTextEditorHistoryCursorMovementCommand.class.st b/src/Album/AlbTextEditorHistoryCursorMovementCommand.class.st
index ee1252b..ea41a14 100644
--- a/src/Album/AlbTextEditorHistoryCursorMovementCommand.class.st
+++ b/src/Album/AlbTextEditorHistoryCursorMovementCommand.class.st
@@ -20,11 +20,18 @@ AlbTextEditorHistoryCursorMovementCommand >> fromIndices: anObject [
 
 { #category : #'api - undo/redo' }
 AlbTextEditorHistoryCursorMovementCommand >> redoOn: aTextEditor [
+
+	self restoreCursorsAt: toIndices on: aTextEditor
+]
+
+{ #category : #private }
+AlbTextEditorHistoryCursorMovementCommand >> restoreCursorsAt: aCollectionOfIndices on: aTextEditor [
+
 	| aNavigator |
-	
+	aCollectionOfIndices ifEmpty: [ ^ self ].
 	aNavigator := aTextEditor navigator.
-	fromIndices do: [ :eachIndex | aNavigator removeAt: eachIndex ].
-	toIndices do: [ :eachIndex | aNavigator moveTo: eachIndex ].
+	aNavigator moveTo: aCollectionOfIndices first.
+	aCollectionOfIndices allButFirst do: [ :eachIndex | aNavigator addCursorAt: eachIndex ].
 	aNavigator apply
 ]
 
@@ -40,10 +47,6 @@ AlbTextEditorHistoryCursorMovementCommand >> toIndices: anObject [
 
 { #category : #'api - undo/redo' }
 AlbTextEditorHistoryCursorMovementCommand >> undoOn: aTextEditor [
-	| aNavigator |
-	
-	aNavigator := aTextEditor navigator.
-	toIndices do: [ :eachIndex | aNavigator removeAt: eachIndex ].
-	fromIndices do: [ :eachIndex | aNavigator moveTo: eachIndex ].
-	aNavigator apply
+
+	self restoreCursorsAt: fromIndices on: aTextEditor
 ]
diff --git a/src/Album/AlbTextEditorInserter.class.st b/src/Album/AlbTextEditorInserter.class.st
index 24c6edf..10b6a1b 100644
--- a/src/Album/AlbTextEditorInserter.class.st
+++ b/src/Album/AlbTextEditorInserter.class.st
@@ -42,7 +42,9 @@ AlbTextEditorInserter >> at: anIndex [
 
 { #category : #'api - configuration' }
 AlbTextEditorInserter >> atCursor [
-	self at: self cursor position
+	"Insert at every cursor"
+
+	editor cursors do: [ :eachCursor | self at: eachCursor position ]
 ]
 
 { #category : #'api - configuration' }
@@ -95,9 +97,12 @@ AlbTextEditorInserter >> computeSelection: aSelection afterInserted: aText at: a
 { #category : #'api - configuration' }
 AlbTextEditorInserter >> crLineEndingWithWhitespace [
 	"Insert a Cr line ending
-	additionally adding a whitespace from the previous line according to a cursor"
+	additionally adding a whitespace from the previous line according to each insertion location"
 
-	self text: String cr, (self findWhitespaceOfLineBefore: self cursor position)
+	insertionIndices ifEmpty: [ ^ self text: String cr , (self findWhitespaceOfLineBefore: self cursor position) ].
+	insertionIndices do: [ :eachAssociation |
+		eachAssociation value: String cr , (self findWhitespaceOfLineBefore: eachAssociation key) ].
+	text := insertionIndices first value
 ]
 
 { #category : #private }
@@ -201,8 +206,8 @@ AlbTextEditorInserter >> insert [
 						(self hasString: eachAssociation value afterCursor: (AlbTextEditorCursor position: anIndex))
 							ifTrue: [ 
 								shouldUpdateCursor ifTrue: [ 
-									self cursor position = anIndex ifTrue: [ 
-										theCursorMovements add: self cursor -> (anIndex + eachAssociation value size) ] ] ]
+									(editor cursors detect: [ :each | each position = anIndex ] ifNone: [ nil ]) ifNotNil: [ :aCursor | 
+										theCursorMovements add: aCursor -> (anIndex + eachAssociation value size) ] ] ]
 							ifFalse: [ 
 								theInsertions add: { 
 										(#index -> anIndex).
@@ -279,9 +284,12 @@ AlbTextEditorInserter >> lineEnding [
 { #category : #'api - configuration' }
 AlbTextEditorInserter >> lineEndingWithWhitespace [
 	"Insert a line ending (Cr, Lf or CrLf depending on the current platform)
-	additionally  adding a whitespace from the previous line according to a cursor"
+	additionally adding a whitespace from the previous line according to each insertion location"
 
-	self text: OSPlatform current lineEnding, (self findWhitespaceOfLineBefore: self cursor position)
+	insertionIndices ifEmpty: [ ^ self text: OSPlatform current lineEnding , (self findWhitespaceOfLineBefore: self cursor position) ].
+	insertionIndices do: [ :eachAssociation |
+		eachAssociation value: OSPlatform current lineEnding , (self findWhitespaceOfLineBefore: eachAssociation key) ].
+	text := insertionIndices first value
 ]
 
 { #category : #'api - configuration' }
@@ -357,46 +365,48 @@ AlbTextEditorInserter >> privateInsertStrings: aCollectionOfString atAll: aColle
 
 { #category : #private }
 AlbTextEditorInserter >> privateUpdateCursorsAfterInsertion: aText at: anIndex [
-	| aCursor aCursorDelta |
-	
-	aCursor := self cursor.
-	aCursorDelta := 
-			self
-				computeIndexMovement: aCursor position
-				afterInserted: aText
-				at: anIndex.
-
-	aCursorDelta isZero
-		ifFalse: [
-			editor navigator
-				context: self context;
-				dueTo: self;
-				move: aCursor by: aCursorDelta;
-				apply ]
+
+	| aNavigator hasMoves |
+	aNavigator := editor navigator
+		context: self context;
+		dueTo: self;
+		yourself.
+	hasMoves := false.
+	editor cursors do: [ :eachCursor |
+		| aCursorDelta |
+		aCursorDelta := self
+			computeIndexMovement: eachCursor position
+			afterInserted: aText
+			at: anIndex.
+		aCursorDelta isZero ifFalse: [
+			hasMoves := true.
+			aNavigator move: eachCursor by: aCursorDelta ] ].
+	hasMoves ifTrue: [ aNavigator apply ]
 ]
 
 { #category : #private }
 AlbTextEditorInserter >> privateUpdateCursorsAfterInsertion: aText withSurround: aSurroundText at: aTextIndex [
-	| theIndices aCursor aCursorDelta |
 
+	| theIndices aNavigator hasMoves |
 	theIndices := self privateComputeCursorIndices: aText withSurround: aSurroundText at: aTextIndex.
-
-	aCursor := self cursor.
-	aCursorDelta := self
-		computeIndexMovement: aCursor position
-		afterInserted: aText
-		at: theIndices first.
-
-	aCursorDelta := aCursorDelta + (self
-		computeIndexMovement: aCursor position
-		afterInserted: aSurroundText
-		at: theIndices second + aText size).
-
-	aCursorDelta isZero
-		ifFalse: [ editor navigator
-			dueTo: self;
-			move: aCursor by: aCursorDelta;
-			apply ]
+	aNavigator := editor navigator
+		dueTo: self;
+		yourself.
+	hasMoves := false.
+	editor cursors do: [ :eachCursor |
+		| aCursorDelta |
+		aCursorDelta := self
+			computeIndexMovement: eachCursor position
+			afterInserted: aText
+			at: theIndices first.
+		aCursorDelta := aCursorDelta + (self
+			computeIndexMovement: eachCursor position
+			afterInserted: aSurroundText
+			at: theIndices second + aText size).
+		aCursorDelta isZero ifFalse: [
+			hasMoves := true.
+			aNavigator move: eachCursor by: aCursorDelta ] ].
+	hasMoves ifTrue: [ aNavigator apply ]
 ]
 
 { #category : #'private - accessing' }
diff --git a/src/Album/AlbTextEditorLineSegmentHolder.class.st b/src/Album/AlbTextEditorLineSegmentHolder.class.st
index 28f34f4..2b13e90 100644
--- a/src/Album/AlbTextEditorLineSegmentHolder.class.st
+++ b/src/Album/AlbTextEditorLineSegmentHolder.class.st
@@ -147,7 +147,7 @@ AlbTextEditorLineSegmentHolder >> hasCursor [
 
 	| aTextEditor |
 	aTextEditor := self infiniteElement editor.
-	^ aTextEditor cursor insideSegment: segment
+	^ aTextEditor cursors anySatisfy: [ :eachCursor | eachCursor insideSegment: segment ]
 ]
 
 { #category : #'private - testing' }
@@ -315,6 +315,8 @@ AlbTextEditorLineSegmentHolder >> updateSegment: anEditorSegment [
 						https://github.com/feenkcom/gtoolkit/issues/892"
 				                    eachSegmentPiece currentCursor:
 					                    eachPiece currentCursor.
+				                    eachSegmentPiece currentCursors:
+					                    eachPiece currentCursors.
 				                    theSegmentElements do: [ :eachSegmentElement |
 					                    eachPiece
 						                    updateText: eachSegmentElement
diff --git a/src/Album/AlbTextEditorMouseHandler.class.st b/src/Album/AlbTextEditorMouseHandler.class.st
index a9edad1..1b2afa0 100644
--- a/src/Album/AlbTextEditorMouseHandler.class.st
+++ b/src/Album/AlbTextEditorMouseHandler.class.st
@@ -29,6 +29,15 @@ AlbTextEditorMouseHandler >> mouseDownEvent: anEvent [
 		              findTextIndexAtScreenPosition: aScreenPosition
 		              ifAbsent: [ nil ].
 
+	"Alt (Option on macOS) click toggles an additional cursor"
+	(anEvent modifiers isAlt and: [ aTextIndex notNil and: [ element isEditable ] ]) ifTrue: [
+		editor deselecter all deselect.
+		(editor cursors anySatisfy: [ :each | each position = aTextIndex ])
+			ifTrue: [ aNavigator removeCursorAt: aTextIndex ]
+			ifFalse: [ aNavigator addCursorAt: aTextIndex ].
+		element requestFocus.
+		aNavigator apply.
+		^ self ].
 	anEvent modifiers isShift
 		ifTrue: [
 			aTextIndex ifNotNil: [
diff --git a/src/Album/AlbTextEditorNavigator.class.st b/src/Album/AlbTextEditorNavigator.class.st
index 8148b1f..54d0e72 100644
--- a/src/Album/AlbTextEditorNavigator.class.st
+++ b/src/Album/AlbTextEditorNavigator.class.st
@@ -13,7 +13,10 @@ Class {
 		'operations',
 		'dueTo',
 		'shouldHistorize',
-		'nextTextPosition'
+		'nextPositions',
+		'cursorsToAdd',
+		'positionsToRemove',
+		'shouldRemoveSecondaries'
 	],
 	#category : #'Album-Model-Operators'
 }
@@ -33,19 +36,53 @@ AlbTextEditorNavigator >> addAtScreenPosition: aScreenPosition [
 	self moveToScreenPosition: aScreenPosition 
 ]
 
+{ #category : #'cursor - management' }
+AlbTextEditorNavigator >> addCursorAt: aTextPosition [
+	"Add a new cursor at a given text position, in addition to the existing ones"
+
+	self privateAssertPosition: aTextPosition.
+	cursorsToAdd add: aTextPosition
+]
+
 { #category : #'api - processing' }
 AlbTextEditorNavigator >> apply [
-	| prevTextPosition |
-	
-	prevTextPosition := self cursor position.
-	nextTextPosition := prevTextPosition.
-	operations do: [ :anOperation| anOperation performOn: self ].
-	
+
+	| previousPositions toRemove moves |
+	previousPositions := editor cursors collect: [ :each | each position ].
+	operations do: [ :anOperation | anOperation performOn: self ].
+
+	toRemove := self privateCursorsToRemove.
+	moves := OrderedCollection new.
+	nextPositions keysAndValuesDo: [ :aCursor :aPosition |
+		(toRemove includes: aCursor) ifFalse: [
+			moves add: aCursor -> (aCursor position -> (self privateNormalizePosition: aPosition)) ] ].
+
+	"first remove the cursors from their old location, then update the model,
+	and only then add them back, so that cursors sharing a segment do not hide each other"
+	toRemove do: [ :each | self notifyCursorRemoved: each ].
+	moves do: [ :each | self notifyCursorRemoved: (AlbTextEditorCursor position: each value key) ].
+
+	moves do: [ :each |
+		each key position: each value value.
+		shouldResetDesiredCoordinate ifTrue: [ each key resetDesiredCoordinate ] ].
+	editor secondaryCursors removeAll: toRemove.
+	cursorsToAdd do: [ :aPosition |
+		editor secondaryCursors add: (AlbTextEditorCursor position: (self privateNormalizePosition: aPosition)) ].
+	self privateMergeCursors.
+
+	self selection ifEmpty: [ editor cursors do: [ :each | self notifyCursorAdded: each ] ].
+
+	moves do: [ :each |
+		each value key ~= each value value ifTrue: [
+			editor dispatchEvent: (AlbCursorMovedEvent
+				 cursor: each key
+				 from: each value key
+				 to: each value value
+				 dueTo: (dueTo ifNil: [ self ])) ] ].
 	shouldHistorize ifTrue: [
 		editor history
-			cursorsMovedFrom: {prevTextPosition} to: { nextTextPosition } ].
-
-	self privateMoveCursor: self cursor to: nextTextPosition.
+			cursorsMovedFrom: previousPositions
+			to: (editor cursors collect: [ :each | each position ]) ].
 	dueTo := nil
 ]
 
@@ -61,11 +98,15 @@ AlbTextEditorNavigator >> dueTo: aTextEditorOperator [
 
 { #category : #initialization }
 AlbTextEditorNavigator >> initialize [
+
 	super initialize.
 	operations := OrderedCollection new.
+	nextPositions := IdentityDictionary new.
+	cursorsToAdd := OrderedCollection new.
+	positionsToRemove := OrderedCollection new.
+	shouldRemoveSecondaries := false.
 	shouldResetDesiredCoordinate := true.
-	shouldHistorize := false.
-
+	shouldHistorize := false
 ]
 
 { #category : #'api - configuration' }
@@ -84,97 +125,110 @@ AlbTextEditorNavigator >> move: aCursor to: aTextPosition [
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveBy: aDelta [
-	"Move all cursors by a given delta. The operation is only applied on existing cursor, not the ones that will be added"
+	"Move all cursors by a given delta. The operation is only applied on existing cursors, not the ones that will be added"
 
-	operations add: ((AlbTextEditorNavigatorMoveByOperation cursor: self cursor) delta: aDelta)
+	editor cursors do: [ :eachCursor |
+		operations add: ((AlbTextEditorNavigatorMoveByOperation cursor: eachCursor) delta: aDelta) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveDown [
 	"Move all cursors down one line"
 
-	operations add: (AlbTextEditorNavigatorMoveDownOperation cursor: self cursor)
+	editor cursors do: [ :eachCursor |
+		operations add: (AlbTextEditorNavigatorMoveDownOperation cursor: eachCursor) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveLeft [
+	"Move all cursors one to the left"
 
-	| delta |
-	delta := -1.
-	(self hasString: String crlf beforeCursor: self cursor) ifTrue: [ delta := -2 ].
-	operations add: ((AlbTextEditorNavigatorMoveByOperation cursor: self cursor) delta: delta)
+	editor cursors do: [ :eachCursor |
+		| delta |
+		delta := -1.
+		(self hasString: String crlf beforeCursor: eachCursor) ifTrue: [ delta := -2 ].
+		operations add: ((AlbTextEditorNavigatorMoveByOperation cursor: eachCursor) delta: delta) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveRight [
 	"Move all cursors one to the right"
-	| delta |
-	delta := 1.
-	(self hasString: String crlf afterCursor: self cursor) ifTrue: [ delta := 2 ].
-	operations add: ((AlbTextEditorNavigatorMoveByOperation cursor: self cursor) delta: delta)
+
+	editor cursors do: [ :eachCursor |
+		| delta |
+		delta := 1.
+		(self hasString: String crlf afterCursor: eachCursor) ifTrue: [ delta := 2 ].
+		operations add: ((AlbTextEditorNavigatorMoveByOperation cursor: eachCursor) delta: delta) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveTo: aTextPosition [
 	"Move all cursors to a given position (basically, remove all cursors except one)"
-	self privateAssertPosition: aTextPosition.
-
-	operations add: ((AlbTextEditorNavigatorMoveToOperation cursor: self cursor) position: aTextPosition).
 
+	self privateAssertPosition: aTextPosition.
+	shouldRemoveSecondaries := true.
+	operations add: ((AlbTextEditorNavigatorMoveToOperation cursor: self cursor) position: aTextPosition)
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveToEndNextWord [
 	"Move all cursors to the end of the next word"
 
-	operations add: (AlbTextEditorNavigatorMoveToEndNextWordOperation cursor: self cursor)
+	editor cursors do: [ :eachCursor |
+		operations add: (AlbTextEditorNavigatorMoveToEndNextWordOperation cursor: eachCursor) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveToLineEnd [
 	"Move all cursors to the end of their corresponding lines"
 
-	operations add: (AlbTextEditorNavigatorMoveToLineEndOperation cursor: self cursor)
+	editor cursors do: [ :eachCursor |
+		operations add: (AlbTextEditorNavigatorMoveToLineEndOperation cursor: eachCursor) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveToLineStart [
 	"Move all cursors to the start of their corresponding lines"
 
-	operations add: (AlbTextEditorNavigatorMoveToLineStartOperation cursor: self cursor)
+	editor cursors do: [ :eachCursor |
+		operations add: (AlbTextEditorNavigatorMoveToLineStartOperation cursor: eachCursor) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveToScreenPosition: aScreenPosition [
 	"Move all cursors to a given screen position (basically, remove all cursors except one)"
-	operations add: ((AlbTextEditorNavigatorMoveAtScreenPositionOperation cursor: self cursor) screenPosition: aScreenPosition).
+
+	shouldRemoveSecondaries := true.
+	operations add: ((AlbTextEditorNavigatorMoveAtScreenPositionOperation cursor: self cursor) screenPosition: aScreenPosition)
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveToStartPreviousWord [
 	"Move all cursors to the start of the previous word"
 
-	operations add: (AlbTextEditorNavigatorMoveToStartPreviousWordOperation cursor: self cursor)
+	editor cursors do: [ :eachCursor |
+		operations add: (AlbTextEditorNavigatorMoveToStartPreviousWordOperation cursor: eachCursor) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveUp [
 	"Move all cursors up one line"
 
-	operations add: (AlbTextEditorNavigatorMoveUpOperation cursor: self cursor)
+	editor cursors do: [ :eachCursor |
+		operations add: (AlbTextEditorNavigatorMoveUpOperation cursor: eachCursor) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveWithin: anInterval [
 	"Move all cursors so that they end up within a given text interval.
-	The operation is only applied on existing cursor, not the ones that will be added"
-	| aCursor |
-
-	aCursor := self cursor.
-	aCursor position < anInterval first
-		ifTrue: [ self move: aCursor to: anInterval first ]
-		ifFalse: [ aCursor position > anInterval last
-			ifTrue: [ self move: aCursor to: anInterval last ] ]
+	The operation is only applied on existing cursors, not the ones that will be added"
+
+	editor cursors do: [ :eachCursor |
+		eachCursor position < anInterval first
+			ifTrue: [ self move: eachCursor to: anInterval first ]
+			ifFalse: [
+				eachCursor position > anInterval last
+					ifTrue: [ self move: eachCursor to: anInterval last ] ] ]
 ]
 
 { #category : #'private - accessing' }
@@ -184,6 +238,43 @@ AlbTextEditorNavigator >> privateAssertPosition: aTextPosition [
 		description: [ 'Cursor position ({1}) must be within the interval [0.. {2}]' format: { aTextPosition . self text size } ].
 ]
 
+{ #category : #private }
+AlbTextEditorNavigator >> privateCursorsToRemove [
+	"Return the cursors to be removed by this navigation. The primary cursor is never part of it:
+	if it must be removed while other cursors survive, one of them is promoted to primary first"
+
+	<return: #IdentitySet>
+	| toRemove |
+	toRemove := IdentitySet new.
+	shouldRemoveSecondaries ifTrue: [ toRemove addAll: editor secondaryCursors ].
+	positionsToRemove do: [ :aPosition |
+		editor cursors
+			detect: [ :each | each position = aPosition ]
+			ifFound: [ :aCursor | toRemove add: aCursor ] ].
+	(toRemove includes: editor cursor) ifFalse: [ ^ toRemove ].
+	toRemove remove: editor cursor.
+	(editor secondaryCursors reject: [ :each | toRemove includes: each ]) ifNotEmpty: [ :theSurvivors |
+		| anOldPrimary |
+		anOldPrimary := editor cursor.
+		editor secondaryCursors remove: theSurvivors first.
+		editor cursor: theSurvivors first.
+		editor secondaryCursors add: anOldPrimary.
+		toRemove add: anOldPrimary ].
+	^ toRemove
+]
+
+{ #category : #private }
+AlbTextEditorNavigator >> privateMergeCursors [
+	"Remove secondary cursors sharing their position with another cursor (the primary one wins)"
+
+	| theOccupiedPositions |
+	theOccupiedPositions := Set with: editor cursor position.
+	editor secondaryCursors copy do: [ :eachCursor |
+		(theOccupiedPositions includes: eachCursor position)
+			ifTrue: [ editor secondaryCursors remove: eachCursor ]
+			ifFalse: [ theOccupiedPositions add: eachCursor position ] ]
+]
+
 { #category : #private }
 AlbTextEditorNavigator >> privateMoveCursor: aCursor to: aTextIndex [
 
@@ -216,12 +307,35 @@ AlbTextEditorNavigator >> privateNormalizePosition: aTextPosition [
 
 { #category : #'private - registration' }
 AlbTextEditorNavigator >> privateRegisterForMove: aCursor by: aDelta [
-	nextTextPosition := self cursor position + aDelta
+
+	nextPositions at: aCursor put: aCursor position + aDelta
 ]
 
 { #category : #'private - registration' }
 AlbTextEditorNavigator >> privateRegisterForMove: aCursor to: aTextPosition [
-	nextTextPosition := aTextPosition
+
+	nextPositions at: aCursor put: aTextPosition
+]
+
+{ #category : #'cursor - management' }
+AlbTextEditorNavigator >> removeAt: aTextPosition [
+	"Remove the cursor at a given text position (used by the history)"
+
+	self removeCursorAt: aTextPosition
+]
+
+{ #category : #'cursor - management' }
+AlbTextEditorNavigator >> removeCursorAt: aTextPosition [
+	"Remove the cursor at a given text position. The last remaining cursor is never removed"
+
+	positionsToRemove add: aTextPosition
+]
+
+{ #category : #'cursor - management' }
+AlbTextEditorNavigator >> removeSecondaryCursors [
+	"Keep only the primary cursor"
+
+	shouldRemoveSecondaries := true
 ]
 
 { #category : #'api - events' }
diff --git a/src/Album/AlbTextEditorPaster.class.st b/src/Album/AlbTextEditorPaster.class.st
index e2bfe12..f30d4df 100644
--- a/src/Album/AlbTextEditorPaster.class.st
+++ b/src/Album/AlbTextEditorPaster.class.st
@@ -26,8 +26,10 @@ AlbTextEditorPaster >> at: anIndex [
 ]
 
 { #category : #'api - configuration' }
-AlbTextEditorPaster >> atCursor [	
-	self at: self cursor position
+AlbTextEditorPaster >> atCursor [
+	"Paste at every cursor"
+
+	editor cursors do: [ :eachCursor | self at: eachCursor position ]
 ]
 
 { #category : #'api - configuration' }
diff --git a/src/Album/AlbTextEditorSelecter.class.st b/src/Album/AlbTextEditorSelecter.class.st
index 4aa0d0a..ee2d992 100644
--- a/src/Album/AlbTextEditorSelecter.class.st
+++ b/src/Album/AlbTextEditorSelecter.class.st
@@ -463,6 +463,8 @@ AlbTextEditorSelecter >> privateSelect: aFromTextIndex to: aToTextIndex [
 AlbTextEditorSelecter >> select [
 
 	| toBeSelected |
+	"selections are not combined with multiple cursors: selecting keeps the primary cursor only"
+	editor removeSecondaryCursors.
 
 	self privatePerformSelectAndDeselectCommands: commands.
 	commands removeAll.
diff --git a/src/Album/AlbTextEditorShowCursorRequest.class.st b/src/Album/AlbTextEditorShowCursorRequest.class.st
index ef410fe..672c885 100644
--- a/src/Album/AlbTextEditorShowCursorRequest.class.st
+++ b/src/Album/AlbTextEditorShowCursorRequest.class.st
@@ -3,7 +3,8 @@ Class {
 	#superclass : #AlbTextEditorRequest,
 	#instVars : [
 		'cursorPosition',
-		'hasFocus'
+		'hasFocus',
+		'isPrimary'
 	],
 	#category : #'Album-UI-Requests'
 }
@@ -34,3 +35,15 @@ AlbTextEditorShowCursorRequest >> hasFocus [
 AlbTextEditorShowCursorRequest >> hasFocus: anObject [
 	hasFocus := anObject
 ]
+
+{ #category : #accessing }
+AlbTextEditorShowCursorRequest >> isPrimary [
+
+	^ isPrimary ifNil: [ true ]
+]
+
+{ #category : #accessing }
+AlbTextEditorShowCursorRequest >> isPrimary: aBoolean [
+
+	isPrimary := aBoolean
+]
diff --git a/src/Album/AlbTextElement.class.st b/src/Album/AlbTextElement.class.st
index 3cf6872..a54a08f 100644
--- a/src/Album/AlbTextElement.class.st
+++ b/src/Album/AlbTextElement.class.st
@@ -3,7 +3,8 @@ Class {
 	#superclass : #BlTextElement,
 	#instVars : [
 		'cursorElement',
-		'segmentPiece'
+		'segmentPiece',
+		'secondaryCursorElements'
 	],
 	#category : #'Album-UI'
 }
@@ -12,13 +13,41 @@ Class {
 AlbTextElement >> addCursorAt: aTextPosition inEditorElement: anEditorElement [
 
 	<return: #AlbCursorElement>
-	^ self cursorAt: aTextPosition ifFound: #yourself ifNone: [ 
-		  cursorElement ifNil: [ 
-			  cursorElement := anEditorElement cursorElement.
-			  cursorElement removeFromParent.
-			  self addChild: cursorElement ].
-		  cursorElement textPosition: aTextPosition.
-		  cursorElement ]
+	^ self addCursorAt: aTextPosition inEditorElement: anEditorElement primary: true
+]
+
+{ #category : #cursor }
+AlbTextElement >> addCursorAt: aTextPosition inEditorElement: anEditorElement primary: isPrimary [
+	"The primary cursor uses the unique cursor element of the editor element, secondary ones get their own element"
+
+	<return: #AlbCursorElement>
+	| aBackground aCursorElement |
+	isPrimary ifTrue: [
+		cursorElement ifNil: [
+			cursorElement := anEditorElement cursorElement.
+			cursorElement removeFromParent.
+			self addChild: cursorElement ].
+		cursorElement textPosition: aTextPosition.
+		^ cursorElement ].
+	self secondaryCursorElements
+		detect: [ :each | each textPosition = aTextPosition ]
+		ifFound: [ :anExisting | ^ anExisting ].
+	aBackground := anEditorElement cursorElement focusedBackground.
+	aCursorElement := AlbCursorElement new
+		focusedBackground: aBackground;
+		textPosition: aTextPosition;
+		yourself.
+	self secondaryCursorElements add: aCursorElement.
+	self addChild: aCursorElement.
+	^ aCursorElement
+]
+
+{ #category : #cursor }
+AlbTextElement >> allCursorElements [
+
+	^ cursorElement
+		ifNil: [ self secondaryCursorElements asArray ]
+		ifNotNil: [ (Array with: cursorElement) , self secondaryCursorElements asArray ]
 ]
 
 { #category : #'cursor - asserting' }
@@ -39,10 +68,12 @@ AlbTextElement >> assertCursorPosition: anIndex [
 { #category : #'cursor - accessing' }
 AlbTextElement >> cursorAt: aTextPosition ifFound: aFoundBlock ifNone: aNoneBlock [
 
-	cursorElement ifNil: [ ^ aNoneBlock value ].
-	cursorElement textPosition = aTextPosition ifFalse: [ ^ aNoneBlock value ].
-
-	^ aFoundBlock value: cursorElement
+	(cursorElement notNil and: [ cursorElement textPosition = aTextPosition ])
+		ifTrue: [ ^ aFoundBlock value: cursorElement ].
+	^ self secondaryCursorElements
+		detect: [ :each | each textPosition = aTextPosition ]
+		ifFound: aFoundBlock
+		ifNone: aNoneBlock
 ]
 
 { #category : #initialization }
@@ -56,7 +87,7 @@ AlbTextElement >> defaultMinWidth [
 { #category : #'cursor - accessing' }
 AlbTextElement >> hasCursor [
 
-	^ cursorElement notNil
+	^ cursorElement notNil or: [ self secondaryCursorElements notEmpty ]
 ]
 
 { #category : #'cursor - accessing' }
@@ -72,8 +103,8 @@ AlbTextElement >> hasCursorAt: aTextPosition [
 
 { #category : #'cursor - management' }
 AlbTextElement >> hideCursor [
-	cursorElement ifNil: [ ^self ].
-	cursorElement visibility: BlVisibility gone
+
+	self allCursorElements do: [ :each | each visibility: BlVisibility gone ]
 ]
 
 { #category : #initialization }
@@ -92,21 +123,24 @@ AlbTextElement >> initializeMeasurement [
 
 { #category : #layout }
 AlbTextElement >> layoutCursor: aBounds context: aBlElementBoundsUpdateContext [
-		| cursorPos textPosX maxTextPosX minTextPosX textPos |
-		cursorElement ifNil: [ ^self ].
-		"we make sure that the cursor is within text bounds (we allow to add a cursor outside of the text bounds)"
-		cursorPos := cursorElement textPosition min: self text size max: 0.0.
-		
-		maxTextPosX := ((self measuredWidth - (cursorElement measuredWidth))) max: 0.0.
-		minTextPosX := cursorElement measuredWidth negated.
-		
-		textPosX := (self screenPositionAt: cursorPos) x.
-		textPosX := ((textPosX - (cursorElement measuredWidth // 2)) min: maxTextPosX) max: minTextPosX.
-		textPos := (textPosX max: 0.0) @ self padding top.
-		
-		cursorElement
-			applyLayoutIn: (textPos extent: (cursorElement measuredWidth @ ((cursorElement measuredHeight - self padding height) max: 0.0)))
-			context: aBlElementBoundsUpdateContext
+
+	self allCursorElements do: [ :each | self layoutCursorElement: each context: aBlElementBoundsUpdateContext ]
+]
+
+{ #category : #layout }
+AlbTextElement >> layoutCursorElement: aCursorElement context: aBlElementBoundsUpdateContext [
+
+	| cursorPos textPosX maxTextPosX minTextPosX textPos |
+	"we make sure that the cursor is within text bounds (we allow to add a cursor outside of the text bounds)"
+	cursorPos := aCursorElement textPosition min: self text size max: 0.0.
+	maxTextPosX := self measuredWidth - aCursorElement measuredWidth max: 0.0.
+	minTextPosX := aCursorElement measuredWidth negated.
+	textPosX := (self screenPositionAt: cursorPos) x.
+	textPosX := textPosX - (aCursorElement measuredWidth // 2) min: maxTextPosX max: minTextPosX.
+	textPos := (textPosX max: 0.0) @ self padding top.
+	aCursorElement
+		applyLayoutIn: (textPos extent: aCursorElement measuredWidth @ (aCursorElement measuredHeight - self padding height max: 0.0))
+		context: aBlElementBoundsUpdateContext
 ]
 
 { #category : #accessing }
@@ -131,15 +165,27 @@ AlbTextElement >> onLayout: aBounds context: aBlElementBoundsUpdateContext [
 
 { #category : #'cursor - management' }
 AlbTextElement >> removeCursorAt: aTextIndex [
-	"Remove cursor at a goven position"
+	"Remove cursor at a given position"
 
-	^ self
-		cursorAt: aTextIndex
-		ifFound: [ :c |
-			cursorElement removeFromParent.
-			cursorElement := nil.
-			c ]
-		ifNone: [ self error: 'Cursor at ', aTextIndex asString, ' does not exist' ]
+	(cursorElement notNil and: [ cursorElement textPosition = aTextIndex ]) ifTrue: [
+		| aRemoved |
+		aRemoved := cursorElement.
+		cursorElement removeFromParent.
+		cursorElement := nil.
+		^ aRemoved ].
+	^ self secondaryCursorElements
+		detect: [ :each | each textPosition = aTextIndex ]
+		ifFound: [ :aSecondary |
+			self secondaryCursorElements remove: aSecondary.
+			aSecondary removeFromParent.
+			aSecondary ]
+		ifNone: [ self error: 'Cursor at ' , aTextIndex asString , ' does not exist' ]
+]
+
+{ #category : #cursor }
+AlbTextElement >> secondaryCursorElements [
+
+	^ secondaryCursorElements ifNil: [ secondaryCursorElements := OrderedCollection new ]
 ]
 
 { #category : #accessing }
@@ -159,8 +205,8 @@ AlbTextElement >> segmentPiece: aSegmentPiece [
 
 { #category : #'cursor - management' }
 AlbTextElement >> showCursor [
-	cursorElement ifNil: [ ^self ].
-	cursorElement visibility: BlVisibility visible
+
+	self allCursorElements do: [ :each | each visibility: BlVisibility visible ]
 ]
 
 { #category : #'text - accessing' }
diff --git a/src/Album/AlbTextWordPieceShowCursorHandler.class.st b/src/Album/AlbTextWordPieceShowCursorHandler.class.st
index 8da3c20..2c280fa 100644
--- a/src/Album/AlbTextWordPieceShowCursorHandler.class.st
+++ b/src/Album/AlbTextWordPieceShowCursorHandler.class.st
@@ -12,12 +12,11 @@ AlbTextWordPieceShowCursorHandler >> eventClass [
 { #category : #'api - event managing' }
 AlbTextWordPieceShowCursorHandler >> handleEvent: anEvent [
 
-	| aCursorElement |
-	aCursorElement := anEvent currentTarget
-		                  addCursorAt: anEvent cursorPosition
-		                  inEditorElement: anEvent editorElement.
-	(anEvent hasFocus and: [ 
-		 anEvent editorElement selection isEmpty ])
+	anEvent currentTarget
+		addCursorAt: anEvent cursorPosition
+		inEditorElement: anEvent editorElement
+		primary: anEvent isPrimary.
+	(anEvent hasFocus and: [ anEvent editorElement selection isEmpty ])
 		ifTrue: [ anEvent currentTarget showCursor ]
 		ifFalse: [ anEvent currentTarget hideCursor ]
 ]

From 51b6992a7bae12e33daaad4121075abd5f015998 Mon Sep 17 00:00:00 2001
From: Koen De Hondt <koen@dehondt.dev>
Date: Tue, 27 Oct 2026 16:41:06 +0100
Subject: [PATCH 2/4] Combine selections with multiple cursors

Keyboard selection (Shift+arrows, word and line start/end) now
extends or shrinks a selection at every cursor instead of collapsing
to the primary one. Typing, paste and deletion apply to every
selection.

- AlbTextEditorSelecter: extension operations build one command per
  cursor (new private...For: methods) and move all cursors with a
  single navigator apply
- AlbTextEditorNavigator: optional merging of cursors within the same
  selection (withMergingWithinSelection), keeping one cursor at the
  selection edge; the selecter triggers it once the editor selection
  is up to date
- Explicit ranges (select all, mouse drag, Shift-click) still keep a
  single cursor

Requires the BlSelectionTree>>delete: fix in Bloc.

Replace test_selecting_keeps_only_the_primary_cursor with 10 selection
tests in AlbMultiCursorTest.
---
 src/Album-Tests/AlbMultiCursorTest.class.st   | 167 ++++++++-
 src/Album/AlbExtendSelectionCommand.class.st  |   6 +-
 src/Album/AlbTextEditor.class.st              |   1 +
 ...AlbTextEditorAbstractSegmentPiece.class.st |   8 +-
 src/Album/AlbTextEditorNavigator.class.st     |  81 ++++-
 src/Album/AlbTextEditorSelecter.class.st      | 324 ++++++++++--------
 6 files changed, 423 insertions(+), 164 deletions(-)

diff --git a/src/Album-Tests/AlbMultiCursorTest.class.st b/src/Album-Tests/AlbMultiCursorTest.class.st
index 7904826..2d5c459 100644
--- a/src/Album-Tests/AlbMultiCursorTest.class.st
+++ b/src/Album-Tests/AlbMultiCursorTest.class.st
@@ -96,6 +96,16 @@ AlbMultiCursorTest >> randomSpecUsing: aRandom [
 			i < text size ifTrue: [ out nextPut: (text at: i + 1) ] ] ]
 ]
 
+{ #category : #helpers }
+AlbMultiCursorTest >> selectionOf: anEditor [
+	"Return the selected intervals as from -> to associations"
+
+	| theBounds |
+	theBounds := OrderedCollection new.
+	anEditor selection do: [ :each | theBounds add: each from -> each to ].
+	^ theBounds asArray
+]
+
 { #category : #helpers }
 AlbMultiCursorTest >> setCursorsOf: anEditor from: aSpec [
 
@@ -156,6 +166,22 @@ AlbMultiCursorTest >> test_backspace_at_every_cursor [
 	self assert: (self specOf: editor) equals: 'a|c|'
 ]
 
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_backspace_deletes_every_selection [
+
+	| editor |
+	editor := self editorFrom: '|one |two |three'.
+	editor selecter
+		extendToNextWordEnd;
+		select.
+	editor deleter
+		selected;
+		oneBeforeCursorIfOutsideOfSelection;
+		delete.
+	self assert: (self specOf: editor) equals: '| | |'.
+	self assert: editor selection isEmpty
+]
+
 { #category : #'tests - deleting' }
 AlbMultiCursorTest >> test_backspace_merges_cursors_that_meet [
 
@@ -197,6 +223,45 @@ AlbMultiCursorTest >> test_escape_keeps_only_the_primary_cursor [
 	self assert: (self specOf: element editor) equals: 'a|bc'
 ]
 
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_extend_selection_at_every_cursor [
+
+	| editor |
+	editor := self editorFrom: '|one |two |three'.
+	editor selecter
+		moveOneToRight;
+		select.
+	editor selecter
+		moveOneToRight;
+		select.
+	self assert: (self specOf: editor) equals: 'on|e tw|o th|ree'.
+	self assert: (self selectionOf: editor) equals: { 0 -> 2. 4 -> 6. 8 -> 10 }
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_extend_selection_down_at_every_cursor [
+
+	| element |
+	element := self elementFrom: (self lines: #( '|abc' 'def' '|ghi' 'jkl' )).
+	element editor selecter
+		moveOneDown;
+		select.
+	self assert: (self specOf: element editor) equals: (self lines: #( 'abc' '|def' 'ghi' '|jkl' )).
+	self assert: (self selectionOf: element editor) equals: { 0 -> 4. 8 -> 12 }
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_extend_selection_to_word_end_at_every_cursor [
+
+	| editor |
+	editor := self editorFrom: '|one |two |three'.
+	editor selecter
+		extendToNextWordEnd;
+		select.
+	self assert: (self specOf: editor) equals: 'one| two| three|'.
+	self assert: (self selectionOf: editor) equals: { 0 -> 3. 4 -> 7. 8 -> 13 }
+]
+
 { #category : #'tests - deleting' }
 AlbMultiCursorTest >> test_forward_delete_at_every_cursor [
 
@@ -433,13 +498,109 @@ AlbMultiCursorTest >> test_remove_primary_cursor_promotes_a_secondary_one [
 ]
 
 { #category : #'tests - selecting' }
-AlbMultiCursorTest >> test_selecting_keeps_only_the_primary_cursor [
+AlbMultiCursorTest >> test_select_all_keeps_a_single_cursor [
+	"An explicit range replaces the cursors, as in VS Code"
 
 	| editor |
 	editor := self editorFrom: 'a|b|c'.
-	editor select: 0 to: 2.
+	editor selecter
+		all;
+		select.
+	self assert: (self specOf: editor) equals: 'abc|'.
+	self assert: (self selectionOf: editor) equals: { 0 -> 3 }
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_selections_that_meet_merge_their_cursors [
+	"The cursor kept is the one at the edge of the merged selection; it becomes primary"
+
+	| editor |
+	editor := self editorFrom: 'a|bc|def'.
+	editor selecter
+		moveOneToRight;
+		select.
+	editor selecter
+		moveOneToRight;
+		select.
+	self assert: (self specOf: editor) equals: 'abcde|f'.
+	self assert: (self selectionOf: editor) equals: { 1 -> 5 }.
 	self deny: editor hasMultipleCursors.
-	self assert: editor cursor position equals: 1
+	editor selecter
+		moveOneToLeft;
+		select.
+	self assert: (self selectionOf: editor) equals: { 1 -> 4 }
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_shrink_selection_at_every_cursor [
+
+	| editor |
+	editor := self editorFrom: '|one |two |three'.
+	editor selecter
+		moveOneToRight;
+		select.
+	editor selecter
+		moveOneToRight;
+		select.
+	editor selecter
+		moveOneToLeft;
+		select.
+	self assert: (self specOf: editor) equals: 'o|ne t|wo t|hree'.
+	self assert: (self selectionOf: editor) equals: { 0 -> 1. 4 -> 5. 8 -> 9 }
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_typing_over_selections_keeps_one_cursor_element_per_cursor [
+
+	| element |
+	element := self elementFrom: '|one |two |three'.
+	element editor selecter
+		extendToNextWordEnd;
+		select.
+	element editor inserter
+		atCursor;
+		string: 'X';
+		insert.
+	self assert: (self specOf: element editor) equals: 'X| X| X|'.
+	self assert: (self cursorElementsIn: element) size equals: 3
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_typing_over_selections_undo_and_redo [
+	"As with a single cursor, replacing selected text is undone in two steps: the insertion, then the deletion"
+
+	| editor |
+	editor := self editorFrom: '|one |two |three'.
+	editor selecter
+		extendToNextWordEnd;
+		select.
+	editor inserter
+		atCursor;
+		string: 'X';
+		insert.
+	editor undo.
+	self assert: (self specOf: editor) equals: '| | |'.
+	editor undo.
+	self assert: (self specOf: editor) equals: 'one| two| three|'.
+	editor redo.
+	editor redo.
+	self assert: (self specOf: editor) equals: 'X| X| X|'
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_typing_replaces_every_selection [
+
+	| editor |
+	editor := self editorFrom: '|one |two |three'.
+	editor selecter
+		extendToNextWordEnd;
+		select.
+	editor inserter
+		atCursor;
+		string: 'X';
+		insert.
+	self assert: (self specOf: editor) equals: 'X| X| X|'.
+	self assert: editor selection isEmpty
 ]
 
 { #category : #'tests - history' }
diff --git a/src/Album/AlbExtendSelectionCommand.class.st b/src/Album/AlbExtendSelectionCommand.class.st
index 47f83f1..ed1ad00 100644
--- a/src/Album/AlbExtendSelectionCommand.class.st
+++ b/src/Album/AlbExtendSelectionCommand.class.st
@@ -7,8 +7,7 @@ Class {
 		'toDeselect',
 		'toMoveCursor',
 		'toAddCursor',
-		'shouldResetDesiredCoordinate',
-		'toRemoveCursors'
+		'shouldResetDesiredCoordinate'
 	],
 	#category : #'Album-Model-Operators'
 }
@@ -18,7 +17,7 @@ AlbExtendSelectionCommand >> editor: anEditor [
 	editor := anEditor
 ]
 
-{ #category : #accessing }
+{ #category : #initialization }
 AlbExtendSelectionCommand >> initialize [
 	super initialize.
 
@@ -26,7 +25,6 @@ AlbExtendSelectionCommand >> initialize [
 	toDeselect := OrderedCollection new.
 	toMoveCursor := nil.
 	toAddCursor := nil.
-	toRemoveCursors := OrderedCollection new.
 	shouldResetDesiredCoordinate := true
 ]
 
diff --git a/src/Album/AlbTextEditor.class.st b/src/Album/AlbTextEditor.class.st
index ee98d1c..1c834d6 100644
--- a/src/Album/AlbTextEditor.class.st
+++ b/src/Album/AlbTextEditor.class.st
@@ -797,6 +797,7 @@ AlbTextEditor >> restoreState: aTextEditorMemento [
 
 { #category : #accessing }
 AlbTextEditor >> restoreText: aText [
+
 	"before changing the text we must unsubscribe from existing one"
 	text ifNotNil: [ text unsubscribe: self ].
 	self history setUpToStart.
diff --git a/src/Album/AlbTextEditorAbstractSegmentPiece.class.st b/src/Album/AlbTextEditorAbstractSegmentPiece.class.st
index ee573db..55ea3a4 100644
--- a/src/Album/AlbTextEditorAbstractSegmentPiece.class.st
+++ b/src/Album/AlbTextEditorAbstractSegmentPiece.class.st
@@ -106,10 +106,10 @@ AlbTextEditorAbstractSegmentPiece >> onCursorAdded: aCursor to: aPieceElement in
 	"Is sent when a cursor is added to a given piece element within provided editor element"
 
 	aPieceElement dispatchEvent: (AlbTextEditorShowCursorRequest new
-		 editorElement: anEditorElement;
-		 hasFocus: anEditorElement isFocused;
-		 cursorPosition: aCursor position;
-		 isPrimary: isPrimary)
+		editorElement: anEditorElement;
+		hasFocus: anEditorElement isFocused;
+		cursorPosition: aCursor position;
+		isPrimary: isPrimary)
 ]
 
 { #category : #'cursor - hooks' }
diff --git a/src/Album/AlbTextEditorNavigator.class.st b/src/Album/AlbTextEditorNavigator.class.st
index 54d0e72..38da4f2 100644
--- a/src/Album/AlbTextEditorNavigator.class.st
+++ b/src/Album/AlbTextEditorNavigator.class.st
@@ -16,7 +16,8 @@ Class {
 		'nextPositions',
 		'cursorsToAdd',
 		'positionsToRemove',
-		'shouldRemoveSecondaries'
+		'shouldRemoveSecondaries',
+		'shouldMergeWithinSelection'
 	],
 	#category : #'Album-Model-Operators'
 }
@@ -68,17 +69,17 @@ AlbTextEditorNavigator >> apply [
 	editor secondaryCursors removeAll: toRemove.
 	cursorsToAdd do: [ :aPosition |
 		editor secondaryCursors add: (AlbTextEditorCursor position: (self privateNormalizePosition: aPosition)) ].
-	self privateMergeCursors.
+	self privateMergeCursors do: [ :each | self notifyCursorRemoved: each ].
 
 	self selection ifEmpty: [ editor cursors do: [ :each | self notifyCursorAdded: each ] ].
 
 	moves do: [ :each |
 		each value key ~= each value value ifTrue: [
 			editor dispatchEvent: (AlbCursorMovedEvent
-				 cursor: each key
-				 from: each value key
-				 to: each value value
-				 dueTo: (dueTo ifNil: [ self ])) ] ].
+				cursor: each key
+				from: each value key
+				to: each value value
+				dueTo: (dueTo ifNil: [ self ])) ] ].
 	shouldHistorize ifTrue: [
 		editor history
 			cursorsMovedFrom: previousPositions
@@ -105,6 +106,7 @@ AlbTextEditorNavigator >> initialize [
 	cursorsToAdd := OrderedCollection new.
 	positionsToRemove := OrderedCollection new.
 	shouldRemoveSecondaries := false.
+	shouldMergeWithinSelection := false.
 	shouldResetDesiredCoordinate := true.
 	shouldHistorize := false
 ]
@@ -238,6 +240,22 @@ AlbTextEditorNavigator >> privateAssertPosition: aTextPosition [
 		description: [ 'Cursor position ({1}) must be within the interval [0.. {2}]' format: { aTextPosition . self text size } ].
 ]
 
+{ #category : #private }
+AlbTextEditorNavigator >> privateCursorToKeepAmong: aCollectionOfCursors within: aMonotoneSelection [
+	"Prefer a cursor at an edge of the selection: the primary one if it is there, otherwise the one at the end"
+
+	| atEdges |
+	atEdges := aCollectionOfCursors select: [ :eachCursor |
+		eachCursor position = aMonotoneSelection from or: [ eachCursor position = aMonotoneSelection to ] ].
+	atEdges ifEmpty: [ atEdges := aCollectionOfCursors ].
+	^ atEdges
+		detect: [ :eachCursor | eachCursor == editor cursor ]
+		ifNone: [
+			atEdges
+				detect: [ :eachCursor | eachCursor position = aMonotoneSelection to ]
+				ifNone: [ atEdges first ] ]
+]
+
 { #category : #private }
 AlbTextEditorNavigator >> privateCursorsToRemove [
 	"Return the cursors to be removed by this navigation. The primary cursor is never part of it:
@@ -265,14 +283,32 @@ AlbTextEditorNavigator >> privateCursorsToRemove [
 
 { #category : #private }
 AlbTextEditorNavigator >> privateMergeCursors [
-	"Remove secondary cursors sharing their position with another cursor (the primary one wins)"
-
-	| theOccupiedPositions |
-	theOccupiedPositions := Set with: editor cursor position.
+	"Merge cursors that meet and return the removed ones:
+	- cursors sharing a position (the primary one wins)
+	- cursors within the same selection (one cursor per selection is kept, at its edge)"
+
+	<return: #Collection of: #AlbTextEditorCursor>
+	| removed occupiedPositions |
+	removed := OrderedCollection new.
+	occupiedPositions := Set with: editor cursor position.
 	editor secondaryCursors copy do: [ :eachCursor |
-		(theOccupiedPositions includes: eachCursor position)
-			ifTrue: [ editor secondaryCursors remove: eachCursor ]
-			ifFalse: [ theOccupiedPositions add: eachCursor position ] ]
+		(occupiedPositions includes: eachCursor position)
+			ifTrue: [
+				editor secondaryCursors remove: eachCursor.
+				removed add: eachCursor ]
+			ifFalse: [ occupiedPositions add: eachCursor position ] ].
+	shouldMergeWithinSelection ifFalse: [ ^ removed ].
+	self selection do: [ :eachMonotoneSelection |
+		| inside keeper |
+		inside := editor cursors select: [ :eachCursor |
+			eachCursor position between: eachMonotoneSelection from and: eachMonotoneSelection to ].
+		inside size > 1 ifTrue: [
+			keeper := self privateCursorToKeepAmong: inside within: eachMonotoneSelection.
+			inside do: [ :eachCursor |
+				eachCursor == keeper ifFalse: [
+					self privateRemoveCursor: eachCursor keeping: keeper.
+					removed add: eachCursor ] ] ] ].
+	^ removed
 ]
 
 { #category : #private }
@@ -317,6 +353,17 @@ AlbTextEditorNavigator >> privateRegisterForMove: aCursor to: aTextPosition [
 	nextPositions at: aCursor put: aTextPosition
 ]
 
+{ #category : #private }
+AlbTextEditorNavigator >> privateRemoveCursor: aCursor keeping: aKeptCursor [
+	"Remove aCursor from the editor. If it is the primary cursor, the kept one becomes primary"
+
+	aCursor == editor cursor
+		ifTrue: [
+			editor secondaryCursors remove: aKeptCursor.
+			editor cursor: aKeptCursor ]
+		ifFalse: [ editor secondaryCursors remove: aCursor ]
+]
+
 { #category : #'cursor - management' }
 AlbTextEditorNavigator >> removeAt: aTextPosition [
 	"Remove the cursor at a given text position (used by the history)"
@@ -359,6 +406,14 @@ AlbTextEditorNavigator >> withHistorization [
 	shouldHistorize := true
 ]
 
+{ #category : #accessing }
+AlbTextEditorNavigator >> withMergingWithinSelection [
+	"Also merge cursors that end up within the same selection, keeping one per selection.
+	Only meaningful while selections are being extended: other operations may move cursors before the selection is updated"
+
+	shouldMergeWithinSelection := true
+]
+
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> withResettingDesiredCoordinate [
 	shouldResetDesiredCoordinate := true
diff --git a/src/Album/AlbTextEditorSelecter.class.st b/src/Album/AlbTextEditorSelecter.class.st
index ee2d992..4844da8 100644
--- a/src/Album/AlbTextEditorSelecter.class.st
+++ b/src/Album/AlbTextEditorSelecter.class.st
@@ -44,65 +44,30 @@ AlbTextEditorSelecter >> extendToIndex: anIndex [
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> extendToLineEnd [
-	"Extend selection to the end of the line"
-	|  cmd globalCursor delta |
+	"Extend the selection of every cursor to the end of its line"
 
-	globalCursor := self cursor.
-	delta := (self findTextIndexAtLineEnd: globalCursor) - globalCursor position.
-	cmd := (self
-			privateExtendSelectionRightAt: globalCursor position
-			by: delta) toMoveCursor: globalCursor by: delta.
-	
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateExtendToLineEndFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> extendToLineStart [
+	"Extend the selection of every cursor to the start of its line"
 
-	"Extend selection to the start of the line"
-
-	| cmd delta globalCursor |
-
-	globalCursor := self cursor.
-	delta := globalCursor position
-	         - (self findTextIndexAtLineStart: globalCursor).
-	cmd := (self
-		        privateExtendSelectionLeftAt: globalCursor position
-		        by: delta) toMoveCursor: globalCursor by: delta negated.
-
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateExtendToLineStartFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> extendToNextWordEnd [
-	"Extend selection to the end of the next word"
-	| aCursor aDelta cmd |
+	"Extend the selection of every cursor to the end of the next word"
 
-	aCursor := self cursor.
-	aDelta := (self findWordEndAfter: aCursor position) - aCursor position.
-	cmd := (self
-			privateExtendSelectionRightAt: aCursor position
-			by: aDelta)
-				toMoveCursor: aCursor
-				by: aDelta.
-	
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateExtendToNextWordEndFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> extendToPreviousWordStart [
-	"Extend selection to start of the previous word"
-	| aCursor aDelta cmd |
+	"Extend the selection of every cursor to the start of the previous word"
 
-	aCursor := self cursor.
-	aDelta := aCursor position - (self findWordEnlargedStartBefore: aCursor position).
-	cmd := (self
-			privateExtendSelectionLeftAt: aCursor position
-			by: aDelta)
-				toMoveCursor: aCursor
-				by: aDelta negated.
-	
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateExtendToPreviousWordStartFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
@@ -168,100 +133,30 @@ AlbTextEditorSelecter >> initialize [
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> moveOneDown [
-	"Select and move a cursor one line down"
-	| aCursor newCursorPosition cmd |
+	"Extend or shrink the selection of every cursor by one line down"
 
-	aCursor := self cursor.
-	newCursorPosition := self
-		findTextIndexBelowCursor: aCursor
-		ifAbsent: [
-			(self isCursorOnTheLastLine: aCursor)
-				ifTrue: [ self text size ]
-				ifFalse: [ aCursor position ] ].
-
-	(self selection anySatisfy: [ :aSelection | aCursor position = aSelection from ])
-		ifTrue: [
-			| aDelta |
-			aDelta := newCursorPosition - aCursor position.
-			cmd := AlbExtendSelectionCommand new 
-				editor: editor;
-				toDeselect: { BlSelection from: aCursor position to: newCursorPosition };
-				toMoveCursor: aCursor by: aDelta ]
-		ifFalse: [
-			| aDelta |
-			aDelta := (newCursorPosition min: self text size) - aCursor position.
-			cmd := AlbExtendSelectionCommand new 
-				editor: editor;
-				toSelect: { BlSelection from: aCursor position to: (newCursorPosition min: self text size) };
-				toMoveCursor: aCursor by: aDelta;
-				withoutResettingDesiredCoordinate ].
-		
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateMoveOneDownFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> moveOneToLeft [
-	"Select and move a cursor one character to the left"
-	| cmd aCursor |
+	"Extend or shrink the selection of every cursor by one character to the left"
 
-	aCursor := self cursor.
-	cmd := (self
-			privateExtendSelectionLeftAt: aCursor position
-			by: 1)
-				toMoveCursor: aCursor
-				by: -1.
-			
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateMoveOneToLeftFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> moveOneToRight [
-	"Select and move a cursor one character to the right"
-	| cmd aCursor |
+	"Extend or shrink the selection of every cursor by one character to the right"
 
-	aCursor := self cursor.
-	cmd := (self
-			privateExtendSelectionRightAt: aCursor position
-			by: 1)
-				toMoveCursor: aCursor
-				by: 1.
-	
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateMoveOneToRightFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> moveOneUp [
-	"Select and move a cursor one line up"
-	| aCursor newCursorPosition cmd |
-	
-	aCursor := self cursor.
-	newCursorPosition := self
-		findTextIndexAboveCursor: aCursor
-		ifAbsent: [
-			(self isCursorOnTheFirstLine: aCursor)
-				ifTrue: [ 0 ]
-				ifFalse: [ aCursor position ] ].
-
-	"the cursor is on the right side of the selection, we should deselect from the new potential position to its current location"
-	(self selection anySatisfy: [ :aSelection | aCursor position = aSelection to ])
-		ifTrue: [
-			| aDelta |
-			aDelta := aCursor position - newCursorPosition.
-			cmd := AlbExtendSelectionCommand new 
-				editor: editor;
-				toDeselect: { BlSelection from: newCursorPosition to: aCursor position };
-				toMoveCursor: aCursor by: aDelta negated ]
-		ifFalse: [
-			"the cursor is on the left side of the selection or is not inside any selection, we should extend it to the new potential location"
-			| aDelta |
-			aDelta := aCursor position - newCursorPosition.
-			cmd := AlbExtendSelectionCommand new 
-				editor: editor;
-				toSelect: { BlSelection from: newCursorPosition to: aCursor position };
-				toMoveCursor: aCursor by: aDelta negated;
-				withoutResettingDesiredCoordinate ].
+	"Extend or shrink the selection of every cursor by one line up"
 
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateMoveOneUpFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
@@ -385,6 +280,63 @@ AlbTextEditorSelecter >> privateExtendSelectionRightAt: aTextPosition by: anAmou
 		toDeselect: toDeselect
 ]
 
+{ #category : #private }
+AlbTextEditorSelecter >> privateExtendToLineEndFor: globalCursor [
+	"Extend selection to the end of the line"
+
+	| cmd delta |
+	delta := (self findTextIndexAtLineEnd: globalCursor) - globalCursor position.
+	cmd := (self
+			privateExtendSelectionRightAt: globalCursor position
+			by: delta) toMoveCursor: globalCursor by: delta.
+	
+	commands add: cmd
+]
+
+{ #category : #private }
+AlbTextEditorSelecter >> privateExtendToLineStartFor: globalCursor [
+	"Extend selection to the start of the line"
+
+	| cmd delta |
+	delta := globalCursor position - (self findTextIndexAtLineStart: globalCursor).
+	cmd := (self
+		privateExtendSelectionLeftAt: globalCursor position
+		by: delta)
+			toMoveCursor: globalCursor
+			by: delta negated.
+	commands add: cmd
+]
+
+{ #category : #private }
+AlbTextEditorSelecter >> privateExtendToNextWordEndFor: aCursor [
+	"Extend selection to the end of the next word"
+
+	| aDelta cmd |
+	aDelta := (self findWordEndAfter: aCursor position) - aCursor position.
+	cmd := (self
+			privateExtendSelectionRightAt: aCursor position
+			by: aDelta)
+				toMoveCursor: aCursor
+				by: aDelta.
+	
+	commands add: cmd
+]
+
+{ #category : #private }
+AlbTextEditorSelecter >> privateExtendToPreviousWordStartFor: aCursor [
+	"Extend selection to start of the previous word"
+
+	| aDelta cmd |
+	aDelta := aCursor position - (self findWordEnlargedStartBefore: aCursor position).
+	cmd := (self
+			privateExtendSelectionLeftAt: aCursor position
+			by: aDelta)
+				toMoveCursor: aCursor
+				by: aDelta negated.
+	
+	commands add: cmd
+]
+
 { #category : #private }
 AlbTextEditorSelecter >> privateFrom: aFromIndex to: aToIndex [
 
@@ -394,19 +346,111 @@ AlbTextEditorSelecter >> privateFrom: aFromIndex to: aToIndex [
 	selection select: aFromIndex to: aToIndex
 ]
 
+{ #category : #private }
+AlbTextEditorSelecter >> privateMoveOneDownFor: aCursor [
+	"Select and move a cursor one line down"
+
+	| newCursorPosition cmd |
+	newCursorPosition := self
+		findTextIndexBelowCursor: aCursor
+		ifAbsent: [
+			(self isCursorOnTheLastLine: aCursor)
+				ifTrue: [ self text size ]
+				ifFalse: [ aCursor position ] ].
+
+	(self selection anySatisfy: [ :aSelection | aCursor position = aSelection from ])
+		ifTrue: [
+			| aDelta |
+			aDelta := newCursorPosition - aCursor position.
+			cmd := AlbExtendSelectionCommand new 
+				editor: editor;
+				toDeselect: { BlSelection from: aCursor position to: newCursorPosition };
+				toMoveCursor: aCursor by: aDelta ]
+		ifFalse: [
+			| aDelta |
+			aDelta := (newCursorPosition min: self text size) - aCursor position.
+			cmd := AlbExtendSelectionCommand new 
+				editor: editor;
+				toSelect: { BlSelection from: aCursor position to: (newCursorPosition min: self text size) };
+				toMoveCursor: aCursor by: aDelta;
+				withoutResettingDesiredCoordinate ].
+		
+	commands add: cmd
+]
+
+{ #category : #private }
+AlbTextEditorSelecter >> privateMoveOneToLeftFor: aCursor [
+	"Select and move a cursor one character to the left"
+
+	| cmd |
+	cmd := (self
+			privateExtendSelectionLeftAt: aCursor position
+			by: 1)
+				toMoveCursor: aCursor
+				by: -1.
+			
+	commands add: cmd
+]
+
+{ #category : #private }
+AlbTextEditorSelecter >> privateMoveOneToRightFor: aCursor [
+	"Select and move a cursor one character to the right"
+
+	| cmd |
+	cmd := (self
+			privateExtendSelectionRightAt: aCursor position
+			by: 1)
+				toMoveCursor: aCursor
+				by: 1.
+	
+	commands add: cmd
+]
+
+{ #category : #private }
+AlbTextEditorSelecter >> privateMoveOneUpFor: aCursor [
+	"Select and move a cursor one line up"
+
+	| newCursorPosition cmd |
+	newCursorPosition := self
+		findTextIndexAboveCursor: aCursor
+		ifAbsent: [
+			(self isCursorOnTheFirstLine: aCursor)
+				ifTrue: [ 0 ]
+				ifFalse: [ aCursor position ] ].
+
+	"the cursor is on the right side of the selection, we should deselect from the new potential position to its current location"
+	(self selection anySatisfy: [ :aSelection | aCursor position = aSelection to ])
+		ifTrue: [
+			| aDelta |
+			aDelta := aCursor position - newCursorPosition.
+			cmd := AlbExtendSelectionCommand new 
+				editor: editor;
+				toDeselect: { BlSelection from: newCursorPosition to: aCursor position };
+				toMoveCursor: aCursor by: aDelta negated ]
+		ifFalse: [
+			"the cursor is on the left side of the selection or is not inside any selection, we should extend it to the new potential location"
+			| aDelta |
+			aDelta := aCursor position - newCursorPosition.
+			cmd := AlbExtendSelectionCommand new 
+				editor: editor;
+				toSelect: { BlSelection from: newCursorPosition to: aCursor position };
+				toMoveCursor: aCursor by: aDelta negated;
+				withoutResettingDesiredCoordinate ].
+
+	commands add: cmd
+]
+
 { #category : #private }
 AlbTextEditorSelecter >> privatePerformSelectAndDeselectCommands: theCommands [
-	| aDeselecter  |
 
+	| aDeselecter aNavigator |
 	aDeselecter := editor deselecter.
-
 	theCommands do: [ :aCommand |
 		aCommand toDeselectDo: [ :eachSelectionToDeselect |
 			aDeselecter
 				from: eachSelectionToDeselect from
 				to: eachSelectionToDeselect to ] ].
 	aDeselecter deselect.
-
 	theCommands do: [ :aCommand |
 		aCommand toSelectDo: [ :eachSelectionToSelect |
 			self
@@ -415,23 +459,20 @@ AlbTextEditorSelecter >> privatePerformSelectAndDeselectCommands: theCommands [
 	
 	shouldUpdateCursor
 		ifFalse: [ ^ self ].
-	
+	theCommands
+		ifEmpty: [ ^ self ].
+	"Move all cursors with a single navigator"
+	aNavigator := editor navigator.
+	aNavigator dueTo: self.
+	(theCommands allSatisfy: [ :aCommand | aCommand shouldResetDesiredCoordinate ])
+		ifTrue: [ aNavigator withResettingDesiredCoordinate ]
+		ifFalse: [ aNavigator withoutResettingDesiredCoordinate ].
 	theCommands do: [ :aCommand |
-		| aNavigator |
-		aNavigator := editor navigator.
-		aNavigator dueTo: self.
-		
-		aCommand shouldResetDesiredCoordinate
-			ifTrue: [ aNavigator withResettingDesiredCoordinate ]
-			ifFalse: [ aNavigator withoutResettingDesiredCoordinate ].
-		
 		aCommand toMoveCursorDo: [ :eachCursor :anAmount |
 			aNavigator move: eachCursor by: anAmount ].
 		aCommand toAddCursorDo: [ :aCursorPosition |
-			aNavigator moveTo: aCursorPosition ].
-		"aCommand toRemoveCursorsDo: [ :aCursor |
-			aNavigator remove: aCursor ]".
-		aNavigator apply ].
+			aNavigator moveTo: aCursorPosition ] ].
+	aNavigator apply
 ]
 
 { #category : #private }
@@ -463,8 +504,6 @@ AlbTextEditorSelecter >> privateSelect: aFromTextIndex to: aToTextIndex [
 AlbTextEditorSelecter >> select [
 
 	| toBeSelected |
-	"selections are not combined with multiple cursors: selecting keeps the primary cursor only"
-	editor removeSecondaryCursors.
 
 	self privatePerformSelectAndDeselectCommands: commands.
 	commands removeAll.
@@ -481,7 +520,12 @@ AlbTextEditorSelecter >> select [
 	toBeSelected do: [ :aMonotoneSelection | 
 		aMonotoneSelection interval size > 1 ifTrue: [ self privateSelect: aMonotoneSelection from to: aMonotoneSelection to ] ].
 	
-	selection ifNotEmpty: [ self notifyCursorRemoved: self cursor ]
+	"now that the editor selection is up to date, keep one cursor per selection"
+	editor hasMultipleCursors ifTrue: [
+		editor navigator
+			withMergingWithinSelection;
+			apply ].
+	selection ifNotEmpty: [ editor cursors do: [ :eachCursor | self notifyCursorRemoved: eachCursor ] ]
 	
 	" do not send updateCursors to self here otherwise, navigator moveUp is broken " 
 ]

From 92ea8611fb03726583d2c86f0464d4ad268ddead Mon Sep 17 00:00:00 2001
From: Koen De Hondt <koen@dehondt.dev>
Date: Tue, 27 Oct 2026 16:51:19 +0100
Subject: [PATCH 3/4] Distribute pasted lines over cursors and fix
 multi-selection copy/cut

Paste: when there are several cursors and the pasted text has exactly
as many lines, each cursor gets one line, in text order. Otherwise the
whole text is pasted at every cursor, as before. A trailing line
ending does not count as an extra line.

Copy/cut: copySelected and cutSelected used the span from the first
to the last selection, so with several selections they copied (and
cut) the unselected text in between. Each selection is now copied
separately, one per line (new AlbTextEditor>>selectedTexts), and cut
removes only the selected ranges. A single selection behaves as
before.

Cleanup:
- AlbTextEditorNavigator: initialize shouldMergeWithinSelection to
  false instead of testing it against true
- AlbTextEditorSelecter: remove commented-out code from
  privatePerformSelectAndDeselectCommands:
- AlbExtendSelectionCommand: remove the unused toRemoveCursors slot
- Formatting of the new private...For: methods in AlbTextEditorSelecter

Add 8 copy/paste tests to AlbMultiCursorTest. Tests touching the
system clipboard restore it afterwards.
---
 src/Album-Tests/AlbMultiCursorTest.class.st | 120 +++++++++++++++++++-
 src/Album/AlbTextEditor.class.st            |  34 ++++--
 src/Album/AlbTextEditorPaster.class.st      |  29 ++++-
 3 files changed, 167 insertions(+), 16 deletions(-)

diff --git a/src/Album-Tests/AlbMultiCursorTest.class.st b/src/Album-Tests/AlbMultiCursorTest.class.st
index 2d5c459..1944656 100644
--- a/src/Album-Tests/AlbMultiCursorTest.class.st
+++ b/src/Album-Tests/AlbMultiCursorTest.class.st
@@ -81,6 +81,15 @@ AlbMultiCursorTest >> lines: aCollectionOfStrings [
 	^ String cr join: aCollectionOfStrings
 ]
 
+{ #category : #helpers }
+AlbMultiCursorTest >> preservingClipboardDo: aBlock [
+	"Evaluate aBlock and restore the system clipboard afterwards, so that tests do not overwrite it"
+
+	| aSavedText |
+	aSavedText := Clipboard clipboardText asString.
+	aBlock ensure: [ Clipboard clipboardText: aSavedText ]
+]
+
 { #category : #helpers }
 AlbMultiCursorTest >> randomSpecUsing: aRandom [
 	"Return a random spec of up to 12 characters with at least one cursor"
@@ -194,6 +203,27 @@ AlbMultiCursorTest >> test_backspace_merges_cursors_that_meet [
 	self deny: editor hasMultipleCursors
 ]
 
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_copy_selections_and_paste_them_one_per_cursor [
+
+	self preservingClipboardDo: [
+		| editor |
+		editor := self editorFrom: (self lines: #( '|one = 1' '|two = 2' '|three = 3' )).
+		editor selecter
+			extendToNextWordEnd;
+			select.
+		editor copySelected.
+		self assert: Clipboard clipboardText asString lines asArray equals: #( 'one' 'two' 'three' ).
+		editor deselecter
+			all;
+			deselect.
+		editor navigator
+			moveToLineEnd;
+			apply.
+		editor paste.
+		self assert: (self specOf: editor) equals: (self lines: #( 'one = 1one|' 'two = 2two|' 'three = 3three|' )) ]
+]
+
 { #category : #'tests - cursors' }
 AlbMultiCursorTest >> test_cursors_are_sorted_and_primary_is_kept [
 
@@ -214,6 +244,35 @@ AlbMultiCursorTest >> test_cursors_in_the_same_word_are_all_displayed [
 	self assert: positions asSet equals: { 'one' -> 1. 'one' -> 2 } asSet
 ]
 
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_cut_removes_every_selection [
+
+	self preservingClipboardDo: [
+		| editor |
+		editor := self editorFrom: '|one |two |three'.
+		editor selecter
+			extendToNextWordEnd;
+			select.
+		editor cutSelected.
+		self assert: (self specOf: editor) equals: '| | |'.
+		self assert: editor selection isEmpty.
+		self assert: Clipboard clipboardText asString lines asArray equals: #( 'one' 'two' 'three' ) ]
+]
+
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_cut_single_selection_is_unchanged [
+
+	self preservingClipboardDo: [
+		| editor |
+		editor := self editorFrom: 'one |two three'.
+		editor selecter
+			extendToNextWordEnd;
+			select.
+		editor cutSelected.
+		self assert: (self specOf: editor) equals: 'one | three'.
+		self assert: Clipboard clipboardText asString equals: 'two' ]
+]
+
 { #category : #'tests - shortcuts' }
 AlbMultiCursorTest >> test_escape_keeps_only_the_primary_cursor [
 
@@ -431,7 +490,7 @@ AlbMultiCursorTest >> test_one_cursor_element_per_cursor [
 	self assert: (cursorElements select: [ :each | each == element cursorElement ]) size equals: 1
 ]
 
-{ #category : #'tests - inserting' }
+{ #category : #'tests - copy/paste' }
 AlbMultiCursorTest >> test_paste_at_every_cursor [
 
 	| editor |
@@ -443,6 +502,54 @@ AlbMultiCursorTest >> test_paste_at_every_cursor [
 	self assert: (self specOf: editor) equals: 'a--|b--|'
 ]
 
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_paste_ignores_a_trailing_line_ending [
+
+	| editor |
+	editor := self editorFrom: 'a|b|'.
+	editor paster
+		text: (self lines: #( 'X' 'Y' '' ));
+		atCursor;
+		paste.
+	self assert: (self specOf: editor) equals: 'aX|bY|'
+]
+
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_paste_multiple_lines_with_a_single_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|b'.
+	editor paster
+		text: (self lines: #( 'X' 'Y' ));
+		atCursor;
+		paste.
+	self assert: (self specOf: editor) equals: (self lines: #( 'aX' 'Y|b' ))
+]
+
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_paste_one_line_per_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|b|c|'.
+	editor paster
+		text: (self lines: #( 'X' 'Y' 'Z' ));
+		atCursor;
+		paste.
+	self assert: (self specOf: editor) equals: 'aX|bY|cZ|'
+]
+
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_paste_whole_text_when_line_count_differs [
+
+	| editor |
+	editor := self editorFrom: 'a|b|'.
+	editor paster
+		text: (self lines: #( 'X' 'Y' 'Z' ));
+		atCursor;
+		paste.
+	self assert: (self specOf: editor) equals: (self lines: #( 'aX' 'Y' 'Z|bX' 'Y' 'Z|' ))
+]
+
 { #category : #'tests - oracle' }
 AlbMultiCursorTest >> test_random_backspaces_match_oracle [
 
@@ -510,6 +617,17 @@ AlbMultiCursorTest >> test_select_all_keeps_a_single_cursor [
 	self assert: (self selectionOf: editor) equals: { 0 -> 3 }
 ]
 
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_selected_texts_one_per_selection [
+
+	| editor |
+	editor := self editorFrom: '|one |two |three'.
+	editor selecter
+		extendToNextWordEnd;
+		select.
+	self assert: editor selectedTexts equals: #( 'one' 'two' 'three' )
+]
+
 { #category : #'tests - selecting' }
 AlbMultiCursorTest >> test_selections_that_meet_merge_their_cursors [
 	"The cursor kept is the one at the edge of the merged selection; it becomes primary"
diff --git a/src/Album/AlbTextEditor.class.st b/src/Album/AlbTextEditor.class.st
index 1c834d6..efcbef9 100644
--- a/src/Album/AlbTextEditor.class.st
+++ b/src/Album/AlbTextEditor.class.st
@@ -116,14 +116,11 @@ AlbTextEditor >> copy: aFromIndex to: aToIndex [
 
 { #category : #'text - copy/paste' }
 AlbTextEditor >> copySelected [
-	"Copy currently selected text to the clipboard"
-	
+	"Copy currently selected text to the clipboard. Several selections are copied one per line"
+
 	self selection isEmpty
 		ifTrue: [ ^ self ].
-		
-	self
-		copy: self selection from
-		to: self selection to
+	Clipboard clipboardText: (String cr join: self selectedTexts)
 ]
 
 { #category : #accessing }
@@ -163,14 +160,20 @@ AlbTextEditor >> cut: aFromIndex to: aToIndex [
 { #category : #'text - copy/paste' }
 AlbTextEditor >> cutSelected [
 	"Copy currently selected text to the clipboard and remove it from the editor.
+	Several selections are copied one per line and each of them is removed.
 	Note: I update the cursor location and selection"
-	
+
 	self selection isEmpty
 		ifTrue: [ ^ self ].
-	
-	self
-		cut: self selection from
-		to: self selection to
+	self selectedTexts size > 1
+		ifFalse: [
+			^ self
+				cut: self selection from
+				to: self selection to ].
+	self copySelected.
+	self deleter
+		selected;
+		delete
 ]
 
 { #category : #initialization }
@@ -883,6 +886,15 @@ AlbTextEditor >> selectedText [
 		  ifFalse: [ self text from: 1 to: 0 ]
 ]
 
+{ #category : #'text - copy/paste' }
+AlbTextEditor >> selectedTexts [
+	"Return the text of every selected interval, in text order"
+
+	^ Array streamContents: [ :aStream |
+		self selection do: [ :eachMonotoneSelection |
+			aStream nextPut: (self text from: eachMonotoneSelection from + 1 to: eachMonotoneSelection to) asString ] ]
+]
+
 { #category : #'api - modification' }
 AlbTextEditor >> selecter [
 	<return: #AlbTextEditorSelecter>
diff --git a/src/Album/AlbTextEditorPaster.class.st b/src/Album/AlbTextEditorPaster.class.st
index f30d4df..fb69b85 100644
--- a/src/Album/AlbTextEditorPaster.class.st
+++ b/src/Album/AlbTextEditorPaster.class.st
@@ -67,18 +67,39 @@ AlbTextEditorPaster >> isEmpty [
 	^ text isEmpty
 ]
 
+{ #category : #private }
+AlbTextEditorPaster >> linesPerInsertion [
+	"Return one line of the pasted text per insertion location, in text order, when there are
+	several locations and exactly as many lines. Return an empty collection otherwise:
+	the whole text is then pasted at every location"
+
+	| theLines |
+	insertionIndices size > 1
+		ifFalse: [ ^ #() ].
+	theLines := text asString lines.
+	^ theLines size = insertionIndices size
+		ifTrue: [ theLines ]
+		ifFalse: [ #() ]
+]
+
 { #category : #'api - processing' }
 AlbTextEditorPaster >> paste [
-	| anInserter |
-	
+
+	| anInserter theLines |
 	anInserter := editor inserter.
 	anInserter inputFilter: inputFilter.
 	anInserter text: text.
 	anInserter shouldDeleteSelected: shouldDeleteSelected.
 	anInserter shouldUpdateCursor: shouldUpdateCursor.
 	anInserter shouldUpdateSelection: shouldUpdateSelection.
-	insertionIndices do: [ :anIndex | anInserter at: anIndex ].
-
+	theLines := self linesPerInsertion.
+	theLines
+		ifEmpty: [ insertionIndices do: [ :anIndex | anInserter at: anIndex ] ]
+		ifNotEmpty: [
+			insertionIndices with: theLines do: [ :anIndex :aLine |
+				anInserter
+					text: aLine;
+					at: anIndex ] ].
 	anInserter insert
 ]
 

From 9bc7e939dcb3f3c244a58cc195213b5d3f74f492 Mon Sep 17 00:00:00 2001
From: Koen De Hondt <koen@dehondt.dev>
Date: Fri, 30 Oct 2026 14:24:53 +0100
Subject: [PATCH 4/4] Adapt multi-cursor tests to settle-based layout

Newer Bloc forbids #forceLayout on elements attached to a space.
AlbMultiCursorTest now subclasses BlSpaceTestCase: element-based tests
add the editor to the test space and perform edits within
space deferAndSettle:, and cursor elements are collected after
space settle.
---
 src/Album-Tests/AlbMultiCursorTest.class.st | 58 ++++++++++-----------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/src/Album-Tests/AlbMultiCursorTest.class.st b/src/Album-Tests/AlbMultiCursorTest.class.st
index 1944656..fb8b68c 100644
--- a/src/Album-Tests/AlbMultiCursorTest.class.st
+++ b/src/Album-Tests/AlbMultiCursorTest.class.st
@@ -7,7 +7,7 @@ For example 'a|b|c' is the text abc with cursors at positions 1 and 2.
 "
 Class {
 	#name : #AlbMultiCursorTest,
-	#superclass : #TestCase,
+	#superclass : #BlSpaceTestCase,
 	#category : #'Album-Tests-Operators'
 }
 
@@ -30,7 +30,7 @@ AlbMultiCursorTest >> backspaceOracle: aSpec [
 AlbMultiCursorTest >> cursorElementsIn: anEditorElement [
 
 	| found |
-	anEditorElement forceLayout.
+	space settle.
 	found := OrderedCollection new.
 	anEditorElement allChildrenBreadthFirstDo: [ :each |
 		(each isKindOf: AlbCursorElement) ifTrue: [ found add: each ] ].
@@ -59,19 +59,16 @@ AlbMultiCursorTest >> editorFrom: aSpec [
 
 { #category : #helpers }
 AlbMultiCursorTest >> elementFrom: aSpec [
-	"Return a laid out editor element, for operations that need the rendered text"
+	"Return an editor element shown in the test space, for operations that need the rendered text"
 
-	| anElement aSpace |
+	| anElement |
 	anElement := AlbEditorElement new.
 	anElement constraintsDo: [ :c |
 		c horizontal exact: 400.
 		c vertical exact: 300 ].
-	aSpace := BlSpace new.
-	aSpace root addChild: anElement.
 	anElement text: (self editorFrom: aSpec) text.
-	anElement forceLayout.
-	self setCursorsOf: anElement editor from: aSpec.
-	anElement forceLayout.
+	space deferAndSettle: [ space root addChild: anElement ].
+	space deferAndSettle: [ self setCursorsOf: anElement editor from: aSpec ].
 	^ anElement
 ]
 
@@ -158,9 +155,8 @@ AlbMultiCursorTest >> test_add_cursor_below_and_above [
 	| element editor |
 	element := self elementFrom: (self lines: #( 'abc' 'd|ef' 'ghi' )).
 	editor := element editor.
-	AlbEditorAddCursorBelowShortcut new performOnEditor: editor element: element dueTo: nil.
-	element forceLayout.
-	AlbEditorAddCursorAboveShortcut new performOnEditor: editor element: element dueTo: nil.
+	space deferAndSettle: [ AlbEditorAddCursorBelowShortcut new performOnEditor: editor element: element dueTo: nil ].
+	space deferAndSettle: [ AlbEditorAddCursorAboveShortcut new performOnEditor: editor element: element dueTo: nil ].
 	self assert: (self specOf: editor) equals: (self lines: #( 'a|bc' 'd|ef' 'g|hi' ))
 ]
 
@@ -278,7 +274,7 @@ AlbMultiCursorTest >> test_escape_keeps_only_the_primary_cursor [
 
 	| element |
 	element := self elementFrom: 'a|b|c|'.
-	AlbEditorDeselectAllShortcut new performOnEditor: element editor element: element dueTo: nil.
+	space deferAndSettle: [ AlbEditorDeselectAllShortcut new performOnEditor: element editor element: element dueTo: nil ].
 	self assert: (self specOf: element editor) equals: 'a|bc'
 ]
 
@@ -302,9 +298,10 @@ AlbMultiCursorTest >> test_extend_selection_down_at_every_cursor [
 
 	| element |
 	element := self elementFrom: (self lines: #( '|abc' 'def' '|ghi' 'jkl' )).
-	element editor selecter
-		moveOneDown;
-		select.
+	space deferAndSettle: [
+		element editor selecter
+			moveOneDown;
+			select ].
 	self assert: (self specOf: element editor) equals: (self lines: #( 'abc' '|def' 'ghi' '|jkl' )).
 	self assert: (self selectionOf: element editor) equals: { 0 -> 4. 8 -> 12 }
 ]
@@ -407,9 +404,10 @@ AlbMultiCursorTest >> test_merged_cursors_remove_their_elements [
 
 	| element |
 	element := self elementFrom: 'a|b|cd|'.
-	element editor deleter
-		oneBeforeCursor;
-		delete.
+	space deferAndSettle: [
+		element editor deleter
+			oneBeforeCursor;
+			delete ].
 	self assert: (self specOf: element editor) equals: '|c|'.
 	self assert: (self cursorElementsIn: element) size equals: 2
 ]
@@ -430,9 +428,10 @@ AlbMultiCursorTest >> test_move_down_moves_every_cursor [
 
 	| element |
 	element := self elementFrom: (self lines: #( 'a|bc|' 'def' 'ghi' )).
-	element editor navigator
-		moveDown;
-		apply.
+	space deferAndSettle: [
+		element editor navigator
+			moveDown;
+			apply ].
 	self assert: (self specOf: element editor) equals: (self lines: #( 'abc' 'd|ef|' 'ghi' ))
 ]
 
@@ -672,13 +671,14 @@ AlbMultiCursorTest >> test_typing_over_selections_keeps_one_cursor_element_per_c
 
 	| element |
 	element := self elementFrom: '|one |two |three'.
-	element editor selecter
-		extendToNextWordEnd;
-		select.
-	element editor inserter
-		atCursor;
-		string: 'X';
-		insert.
+	space deferAndSettle: [
+		element editor selecter
+			extendToNextWordEnd;
+			select.
+		element editor inserter
+			atCursor;
+			string: 'X';
+			insert ].
 	self assert: (self specOf: element editor) equals: 'X| X| X|'.
 	self assert: (self cursorElementsIn: element) size equals: 3
 ]