custom text widget - selection.find api and double click select word. also middle click temp buffer

minigui.d

@@ -1307,8 +1307,9 @@ class Widget : ReflectableProperties {
 	/// ditto
 	void defaultEventHandler_mousedown(MouseDownEvent event) {
 		if(event.button == MouseButton.left) {
-			if(this.tabStop)
+			if(this.tabStop) {
 				this.focus();
+			}
 		}
 	}
 	/// ditto
@@ -12066,6 +12067,24 @@ class TextDisplayHelper : Widget {
 	private const(TextLayouter.State)*[] undoStack;
 	private const(TextLayouter.State)*[] redoStack;
 
+	private string preservedPrimaryText;
+	protected void selectionChanged() {
+		static if(UsingSimpledisplayX11)
+		with(l.selection()) {
+			if(!isEmpty()) {
+				getPrimarySelection(parentWindow.win, (in char[] txt) {
+					if(txt.length) {
+						preservedPrimaryText = txt.idup;
+						// writeln(preservedPrimaryText);
+					}
+
+					setPrimarySelection(parentWindow.win, getContentString());
+				});
+			}
+		}
+	}
+
+
 	bool readonly;
 	bool caretNavigation; // scroll lock can flip this
 	bool singleLine;
@@ -12187,6 +12206,8 @@ class TextDisplayHelper : Widget {
 			setAnchor();
 			moveToEndOfDocument();
 			setFocus();
+
+			selectionChanged();
 		}
 		redraw();
 	}
@@ -12262,6 +12283,7 @@ class TextDisplayHelper : Widget {
 		});
 
 		bool mouseDown;
+		bool mouseActuallyMoved;
 
 		this.addEventListener((scope ResizeEvent re) {
 			// FIXME: I should add a method to give this client area width thing
@@ -12294,6 +12316,9 @@ class TextDisplayHelper : Widget {
 						l.selection.setFocus();
 					else
 						l.selection.setAnchor();
+
+					selectionChanged();
+
 					if(setPosition)
 						l.selection.setUserXCoordinate();
 					scrollForCaret();
@@ -12378,18 +12403,40 @@ class TextDisplayHelper : Widget {
 		this.addEventListener((scope ClickEvent ce) {
 			if(ce.button == MouseButton.middle) {
 				parentWindow.win.getPrimarySelection((txt) {
-					l.selection.replaceContent(txt);
+					doStateCheckpoint();
+
+					if(txt == l.selection.getContentString && preservedPrimaryText.length)
+						l.selection.replaceContent(preservedPrimaryText);
+					else
+						l.selection.replaceContent(txt);
 					redraw();
 				});
 			}
 		});
 
+		this.addEventListener((scope DoubleClickEvent dce) {
+			if(dce.button == MouseButton.left) {
+				with(l.selection()) {
+					scope dg = delegate const(char)[] (scope return const(char)[] ch) {
+						if(ch == " " || ch == "\t" || ch == "\n" || ch == "\r")
+							return ch;
+						return null;
+					};
+					find(dg, 1, true).moveToEnd.setAnchor;
+					find(dg, 1, false).moveTo.setFocus;
+					selectionChanged();
+					redraw();
+				}
+			}
+		});
+
 		this.addEventListener((scope MouseDownEvent ce) {
 			if(ce.button == MouseButton.left) {
 				downAt = Point(ce.clientX - this.paddingLeft, ce.clientY - this.paddingTop);
 				l.selection.moveTo(adjustForSingleLine(smw.position + downAt));
 				l.selection.setAnchor();
 				mouseDown = true;
+				mouseActuallyMoved = false;
 				parentWindow.captureMouse(this);
 				this.redraw();
 			} else if(ce.button == MouseButton.right) {
@@ -12458,6 +12505,7 @@ class TextDisplayHelper : Widget {
 
 				l.selection.moveTo(adjustForSingleLine(smw.position + movedTo));
 				l.selection.setFocus();
+				mouseActuallyMoved = true;
 				this.redraw();
 			}
 		});
@@ -12472,6 +12520,9 @@ class TextDisplayHelper : Widget {
 				parentWindow.releaseMouseCapture();
 				stopAutoscrollTimer();
 				this.redraw();
+
+				if(mouseActuallyMoved)
+					selectionChanged();
 			}
 			//writeln(ce.clientX, ", ", ce.clientY, " = ", l.offsetOfClick(Point(ce.clientX, ce.clientY)));
 		});
@@ -12820,6 +12871,7 @@ abstract class EditableTextWidget : EditableTextWidgetParent {
 
 			void setupCustomTextEditing() {
 				textLayout = new TextLayouter(defaultTextStyle());
+
 				auto smw = new ScrollMessageWidget(this);
 				if(!showingHorizontalScroll)
 					smw.horizontalScrollBar.hide();

textlayouter.d

@@ -315,12 +315,14 @@ public struct Selection {
 	Selection setAnchor() {
 		impl.anchor = impl.position;
 		impl.focus = impl.position;
+		// layouter.notifySelectionChanged();
 		return this;
 	}
 
 	/// ditto
 	Selection setFocus() {
 		impl.focus = impl.position;
+		// layouter.notifySelectionChanged();
 		return this;
 	}
 
@@ -446,9 +448,127 @@ public struct Selection {
 		return this;
 	}
 
-	void find(scope const(char)[] text) {
+	/+
+	enum PlacementOfFind {
+		beginningOfHit,
+		endOfHit
 	}
 
+	enum IfNotFound {
+		changeNothing,
+		moveToEnd,
+		callDelegate
+	}
+
+	enum CaseSensitive {
+		yes,
+		no
+	}
+
+	void find(scope const(char)[] text, PlacementOfFind placeAt = PlacementOfFind.beginningOfHit, IfNotFound ifNotFound = IfNotFound.changeNothing) {
+	}
+	+/
+
+	/++
+		Does a custom search through the text.
+
+		Params:
+			predicate = a search filter. It passes you back a slice of your buffer filled with text at the current search position. You pass the slice of this buffer that matched your search, or `null` if there was no match here. You MUST return either null or a slice of the buffer that was passed to you. If you return an empty slice of of the buffer (buffer[0..0] for example), it cancels the search.
+
+			The window buffer will try to move one code unit at a time. It may straddle code point boundaries - you need to account for this in your predicate.
+
+			windowBuffer = a buffer to temporarily hold text for comparison. You should size this for the text you're trying to find
+
+			searchBackward = determines the direction of the search. If true, it searches from the start of current selection backward to the beginning of the document. If false, it searches from the end of current selection forward to the end of the document.
+		Returns:
+			an object representing the search results and letting you manipulate the selection based upon it
+
+	+/
+	FindResult find(
+		scope const(char)[] delegate(scope return const(char)[] buffer) predicate,
+		int windowBufferSize,
+		bool searchBackward,
+	) {
+		assert(windowBufferSize != 0, "you must pass a buffer of some size");
+
+		char[] windowBuffer = new char[](windowBufferSize); // FIXME i don't need to actually copy in the current impl
+
+		int currentSpot = impl.position;
+
+		const finalSpot = searchBackward ? currentSpot : cast(int) layouter.text.length;
+
+		if(searchBackward) {
+			currentSpot -= windowBuffer.length;
+			if(currentSpot < 0)
+				currentSpot = 0;
+		}
+
+		auto endingSpot = currentSpot + windowBuffer.length;
+		if(endingSpot > finalSpot)
+			endingSpot = finalSpot;
+
+		keep_searching:
+		windowBuffer[0 .. endingSpot - currentSpot] = layouter.text[currentSpot .. endingSpot];
+		auto result = predicate(windowBuffer[0 .. endingSpot - currentSpot]); 
+		if(result !is null) {
+			// we're done, it was found
+			auto offsetStart = result is null ? currentSpot : cast(int) (result.ptr - windowBuffer.ptr);
+			assert(offsetStart >= 0 && offsetStart < windowBuffer.length);
+			return FindResult(this, currentSpot + offsetStart, result !is null, currentSpot + cast(int) (offsetStart + result.length));
+		} else if((searchBackward && currentSpot > 0) || (!searchBackward && endingSpot < finalSpot)) {
+			// not found, keep searching
+			if(searchBackward) {
+				currentSpot--;
+				endingSpot--;
+			} else {
+				currentSpot++;
+				endingSpot++;
+			}
+			goto keep_searching;
+		} else {
+			// not found, at end of search
+			return FindResult(this, currentSpot, false, currentSpot /* zero length result */);
+		}
+
+		assert(0);
+	}
+
+	/// ditto
+	static struct FindResult {
+		private Selection selection;
+		private int position;
+		private bool found;
+		private int endPosition;
+
+		///
+		bool wasFound() {
+			return found;
+		}
+
+		///
+		Selection moveTo() {
+			selection.impl.position = position;
+			return selection;
+		}
+
+		///
+		Selection moveToEnd() {
+			selection.impl.position = endPosition;
+			return selection;
+		}
+
+		///
+		void selectHit() {
+			selection.impl.position = position;
+			selection.setAnchor();
+			selection.impl.position = endPosition;
+			selection.setFocus();
+		}
+	}
+
+
+
+	/+
 	/+ +
 		Searches by regex.
 
@@ -459,6 +579,7 @@ public struct Selection {
 	void find(RegEx)(RegEx re) {
 
 	}
+	+/
 
 	/+ Manipulating the data in the selection +/
 
@@ -863,6 +984,26 @@ public struct Selection {
 	}
 }
 
+unittest {
+	auto l = new TextLayouter(new class TextStyle {
+		mixin Defaults;
+	});
+
+	l.appendText("this is a test string again");
+	auto s = l.selection();
+	auto result = s.find(b => (b == "a") ? b : null, 1, false);
+	assert(result.wasFound);
+	assert(result.position == 8);
+	assert(result.endPosition == 9);
+	result.selectHit();
+	assert(s.getContentString() == "a");
+	result.moveToEnd();
+	result = s.find(b => (b == "a") ? b : null, 1, false); // should find next
+	assert(result.wasFound);
+	assert(result.position == 22);
+	assert(result.endPosition == 23);
+}
+
 private struct SelectionImpl {
 	// you want multiple selections at most points
 	int id;
@@ -942,6 +1083,21 @@ class TextLayouter {
 		assert(last == text.length); // and all chars in the array must be covered by a style block
 	}
 
+	/+
+	private void notifySelectionChanged() {
+		if(onSelectionChanged !is null)
+			onSelectionChanged(this);
+	}
+
+	/++
+		A delegate called when the current selection is changed through api or user action.
+
+		History:
+			Added July 10, 2024
+	+/
+	void delegate(TextLayouter l) onSelectionChanged;
+	+/
+
 	/++
 		Gets the object representing the given selection.