Add keyboard message selection for screen reader users

Author: rezabakhshilaktasaraei

Telegram/SourceFiles/history/history_inner_widget.cpp

@@ -2411,6 +2411,9 @@ void HistoryInner::itemRemoved(not_null<const HistoryItem*> item) {
 	if (_accessibilityFocusedItem == item) {
 		_accessibilityFocusedItem = nullptr;
 	}
+	if (_accessibilitySelectionAnchor == item) {
+		_accessibilitySelectionAnchor = nullptr;
+	}
 	_accessibilityIdentities.remove(item);
 
 	if ((_dragSelFrom && _dragSelFrom->data() == item)
@@ -4065,47 +4068,64 @@ void HistoryInner::keyPressEvent(QKeyEvent *e) {
 				}
 			}
 		}
+		const auto modifiers = e->modifiers()
+			& ~(Qt::KeypadModifier | Qt::GroupSwitchModifier);
+		const auto plainKey = (modifiers == Qt::NoModifier);
+		const auto shiftRange = (modifiers == Qt::ShiftModifier)
+			&& (e->key() == Qt::Key_Up || e->key() == Qt::Key_Down);
 		auto newIndex = _accessibilityFocusedIndex;
 		switch (e->key()) {
 		case Qt::Key_Down:
-			newIndex = std::min(
-				(newIndex < 0) ? (count - 1) : (newIndex + 1),
-				count - 1);
+			if (plainKey || shiftRange) {
+				newIndex = std::min(
+					(newIndex < 0) ? (count - 1) : (newIndex + 1),
+					count - 1);
+			}
 			break;
 		case Qt::Key_Up:
-			newIndex = std::max(
-				(newIndex < 0) ? (count - 1) : (newIndex - 1),
-				0);
+			if (plainKey || shiftRange) {
+				newIndex = std::max(
+					(newIndex < 0) ? (count - 1) : (newIndex - 1),
+					0);
+			}
 			break;
 		case Qt::Key_PageDown: {
-			const auto pageHeight = _visibleAreaBottom
-				- _visibleAreaTop;
-			auto remaining = pageHeight;
-			while (newIndex + 1 < count && remaining > 0) {
-				++newIndex;
-				const auto rect = accessibilityChildRect(
-					newIndex);
-				remaining -= rect.height();
+			if (plainKey) {
+				const auto pageHeight = _visibleAreaBottom
+					- _visibleAreaTop;
+				auto remaining = pageHeight;
+				while (newIndex + 1 < count && remaining > 0) {
+					++newIndex;
+					const auto rect = accessibilityChildRect(
+						newIndex);
+					remaining -= rect.height();
+				}
 			}
 			break;
 		}
 		case Qt::Key_PageUp: {
-			const auto pageHeight = _visibleAreaBottom
-				- _visibleAreaTop;
-			auto remaining = pageHeight;
-			while (newIndex - 1 >= 0 && remaining > 0) {
-				--newIndex;
-				const auto rect = accessibilityChildRect(
-					newIndex);
-				remaining -= rect.height();
+			if (plainKey) {
+				const auto pageHeight = _visibleAreaBottom
+					- _visibleAreaTop;
+				auto remaining = pageHeight;
+				while (newIndex - 1 >= 0 && remaining > 0) {
+					--newIndex;
+					const auto rect = accessibilityChildRect(
+						newIndex);
+					remaining -= rect.height();
+				}
 			}
 			break;
 		}
 		case Qt::Key_Home:
-			newIndex = 0;
+			if (plainKey) {
+				newIndex = 0;
+			}
 			break;
 		case Qt::Key_End:
-			newIndex = count - 1;
+			if (plainKey) {
+				newIndex = count - 1;
+			}
 			break;
 		default:
 			break;
@@ -4124,6 +4144,13 @@ void HistoryInner::keyPressEvent(QKeyEvent *e) {
 				&& elementIndex < int(elements.size()))
 				? elements[elementIndex]->data().get()
 				: nullptr;
+			if (shiftRange) {
+				extendAccessibilitySelection(
+					_accessibilityFocusedIndex,
+					newIndex);
+			} else {
+				_accessibilitySelectionAnchor = nullptr;
+			}
 			setAccessibilityFocusedItem(newIndex, item);
 
 			const auto rect = accessibilityChildRect(newIndex);
@@ -4150,14 +4177,32 @@ void HistoryInner::keyPressEvent(QKeyEvent *e) {
 			return;
 		}
 
+		if (shiftRange) {
+			e->accept();
+			return;
+		}
+
 		if (e->key() == Qt::Key_Space) {
-			if (hasSelectedItems()) {
+			// Ctrl+Space toggles selection of the focused message and
+			// thereby enters "selection mode". While any message stays
+			// selected, plain Space keeps toggling (mirroring how mouse
+			// clicks work for sighted users once selection is active);
+			// with nothing selected it plays/pauses the focused media.
+			if (modifiers == Qt::ControlModifier) {
+				_accessibilitySelectionAnchor = nullptr;
 				toggleMessageSelection();
-			} else {
-				playPauseFocusedMedia();
+				e->accept();
+				return;
+			} else if (modifiers == Qt::NoModifier) {
+				if (hasSelectedItems()) {
+					_accessibilitySelectionAnchor = nullptr;
+					toggleMessageSelection();
+				} else {
+					playPauseFocusedMedia();
+				}
+				e->accept();
+				return;
 			}
-			e->accept();
-			return;
 		}
 	}
 
@@ -5813,30 +5858,109 @@ void HistoryInner::announceAccessibilityFocus(int index) {
 }
 
 void HistoryInner::toggleMessageSelection() {
-	if (!hasSelectedItems() || _accessibilityFocusedIndex < 0) {
-		return;
-	}
+	changeAccessibilitySelection(
+		_accessibilityFocusedIndex,
+		SelectAction::Invert);
+}
+
+void HistoryInner::changeAccessibilitySelection(
+		int index,
+		SelectAction action) {
 	const auto barIndex = accessibilityUnreadBarIndex();
-	if (barIndex >= 0 && _accessibilityFocusedIndex == barIndex) {
+	if (index < 0 || (barIndex >= 0 && index == barIndex)) {
 		return;
 	}
 	const auto elements = accessibleElements();
-	const auto elementIndex = (barIndex >= 0
-		&& _accessibilityFocusedIndex > barIndex)
-		? (_accessibilityFocusedIndex - 1)
-		: _accessibilityFocusedIndex;
+	const auto elementIndex = (barIndex >= 0 && index > barIndex)
+		? (index - 1)
+		: index;
 	if (elementIndex < 0 || elementIndex >= int(elements.size())) {
 		return;
 	}
 	const auto item = elements[elementIndex]->data();
+	// Detect the change by container size, not by the group membership
+	// flip: deselecting a partially selected album really mutates the
+	// selection while isSelectedAsGroup() stays false both before and
+	// after. Selection changes here are pure adds or removes, so an
+	// unchanged size means nothing changed and no repaint, top bar
+	// update or announcement is due.
+	const auto sizeBefore = _selected.size();
+	changeSelectionAsGroup(&_selected, item, action);
+	if (_selected.size() == sizeBefore) {
+		return;
+	}
 	clearTextSelection();
-	changeSelectionAsGroup(&_selected, item, SelectAction::Invert);
 	repaintItem(item);
 	_widget->updateTopBarSelection();
-	accessibilityChildStateChanged(
-		_accessibilityFocusedIndex,
-		{ .selected = true });
-	accessibilityChildNameChanged(_accessibilityFocusedIndex);
+	accessibilityChildStateChanged(index, { .selected = true });
+	accessibilityChildNameChanged(index);
+}
+
+void HistoryInner::extendAccessibilitySelection(
+		int oldIndex,
+		int newIndex) {
+	// Windows-Explorer-style Shift+arrow range selection. The anchor is
+	// the row the current range grows from: re-established here whenever
+	// it is missing, no longer listed or the selection is empty, so an
+	// interrupted or cancelled range simply starts a fresh one at the
+	// focused row. Growing away from the anchor selects the row being
+	// entered (and the origin row on the first step), stepping back
+	// towards it deselects the row being left.
+	const auto elements = accessibleElements();
+	const auto barIndex = accessibilityUnreadBarIndex();
+	const auto itemAt = [&](int index) -> HistoryItem* {
+		if (barIndex >= 0 && index == barIndex) {
+			return nullptr;
+		}
+		const auto elementIndex = (barIndex >= 0 && index > barIndex)
+			? (index - 1)
+			: index;
+		return (elementIndex >= 0
+			&& elementIndex < int(elements.size()))
+			? elements[elementIndex]->data().get()
+			: nullptr;
+	};
+	if (oldIndex < 0) {
+		_accessibilitySelectionAnchor = itemAt(newIndex);
+		changeAccessibilitySelection(newIndex, SelectAction::Select);
+		return;
+	}
+	auto anchorIndex = -1;
+	if (_accessibilitySelectionAnchor && hasSelectedItems()) {
+		for (auto i = 0, n = int(elements.size()); i != n; ++i) {
+			if (elements[i]->data().get()
+				== _accessibilitySelectionAnchor) {
+				anchorIndex = (barIndex >= 0 && i >= barIndex)
+					? (i + 1)
+					: i;
+				break;
+			}
+		}
+	}
+	if (anchorIndex < 0) {
+		_accessibilitySelectionAnchor = itemAt(oldIndex);
+		if (!_accessibilitySelectionAnchor) {
+			// Re-anchoring on the unread-bar row (it has no item): anchor
+			// to the row being entered instead, so the next Shift+arrow
+			// can resolve the anchor and shrink the range. Leaving the
+			// anchor null here would make every following step re-anchor
+			// at its own old index and always read as growing.
+			_accessibilitySelectionAnchor = itemAt(newIndex);
+		}
+		anchorIndex = oldIndex;
+	}
+	const auto growing = std::abs(newIndex - anchorIndex)
+		> std::abs(oldIndex - anchorIndex);
+	if (growing) {
+		if (oldIndex == anchorIndex) {
+			changeAccessibilitySelection(
+				oldIndex,
+				SelectAction::Select);
+		}
+		changeAccessibilitySelection(newIndex, SelectAction::Select);
+	} else {
+		changeAccessibilitySelection(oldIndex, SelectAction::Deselect);
+	}
 }
 
 void HistoryInner::playPauseFocusedMedia() {
@@ -6521,6 +6645,7 @@ void HistoryInner::applyAccessibilityFocus(
 		: nullptr;
 	const auto changed = (_accessibilityFocusedIndex != index)
 		|| (_accessibilityFocusedItem != item);
+	_accessibilitySelectionAnchor = nullptr;
 	_accessibilityFocusedIndex = index;
 	_accessibilityFocusedItem = item;
 	// Exactly one announcement: directly when the widget already has

Telegram/SourceFiles/history/history_inner_widget.h

@@ -515,6 +515,8 @@ class HistoryInner
 		not_null<SelectedItems*> toItems,
 		not_null<HistoryItem*> item,
 		SelectAction action) const;
+	void changeAccessibilitySelection(int index, SelectAction action);
+	void extendAccessibilitySelection(int oldIndex, int newIndex);
 	void forwardItem(FullMsgId itemId);
 	void forwardAsGroup(FullMsgId itemId);
 	void deleteItem(not_null<HistoryItem*> item);
@@ -558,6 +560,7 @@ class HistoryInner
 
 	int _accessibilityFocusedIndex = -1;
 	HistoryItem *_accessibilityFocusedItem = nullptr;
+	HistoryItem *_accessibilitySelectionAnchor = nullptr;
 	mutable base::flat_map<
 		not_null<const HistoryItem*>,
 		quintptr> _accessibilityIdentities;

Telegram/SourceFiles/history/history_widget.cpp

@@ -61,6 +61,7 @@ For license and copyright information please follow this link:
 #include "ui/controls/send_button.h"
 #include "ui/controls/send_as_button.h"
 #include "ui/controls/silent_toggle.h"
+#include "ui/screen_reader_mode.h"
 #include "ui/ui_utility.h"
 #include "inline_bots/inline_bot_result.h"
 #include "base/event_filter.h"
@@ -10462,7 +10463,10 @@ void HistoryWidget::updateTopBarSelection() {
 			|| isBotStart()
 			|| isBlocked()
 			|| !_richDraftPreview->isHidden()
-			|| (!_canSendTexts && !_editMsgId)) {
+			|| (!_canSendTexts && !_editMsgId)
+			|| (_list
+				&& _list->hasFocus()
+				&& Ui::ScreenReaderModeActive())) {
 			_list->setFocus();
 		} else {
 			_field->setFocus();

Telegram/SourceFiles/history/view/history_view_chat_section.cpp

@@ -41,6 +41,7 @@ For license and copyright information please follow this link:
 #include "ui/text/text_utilities.h"
 #include "ui/effects/message_sending_animation_controller.h"
 #include "ui/rect.h"
+#include "ui/screen_reader_mode.h"
 #include "ui/ui_utility.h"
 #include "base/timer_rpl.h"
 #include "api/api_bot.h"
@@ -3328,7 +3329,8 @@ void ChatWidget::listSelectionChanged(SelectedItems &&items) {
 	if ((state.count > 0) && _composeSearch) {
 		_composeSearch->hideAnimated();
 	}
-	if (items.empty()) {
+	if (items.empty()
+		&& !(_inner->hasFocus() && Ui::ScreenReaderModeActive())) {
 		doSetInnerFocus();
 	}
 }