From 2e6dc81391c5dbb787cfd793ad5823904b3b9c94 Mon Sep 17 00:00:00 2001 From: Richard Qin Date: Mon, 26 Oct 2026 20:37:52 +0800 Subject: feat(tui): add document navigation and text selection --- ricochet/src/tui/document_view.hh | 107 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 107 insertions(+) create mode 100644 ricochet/src/tui/document_view.hh (limited to 'ricochet/src/tui/document_view.hh') diff --git a/ricochet/src/tui/document_view.hh b/ricochet/src/tui/document_view.hh new file mode 100644 index 0000000..587f419 --- /dev/null +++ b/ricochet/src/tui/document_view.hh @@ -0,0 +1,107 @@ +/* + * Ricochet - A minimalist CLI web browser for fast, distraction-free navigation. + * Copyright (C) 2026 Richard Qin + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#pragma once + +#include "document_text.hh" +#include "layout.hh" + +#include + +namespace ricochet::tui::detail { + +enum class ViewMotion : std::uint8_t +{ + Left, + Right, + Up, + Down, + NextWord, + PreviousWord, + WordEnd, + LineStart, + LineEnd, + DocumentStart, + DocumentEnd, + PageUp, + PageDown, + HalfPageUp, + HalfPageDown, + PanLeft, + PanRight +}; + +// One tab's reading state. It owns the logical snapshot; screen rows are caches. +// Keyboard, mouse and host navigation all use the same layout/source mappings. +class DocumentView +{ +public: + DocumentView( Document document, ViewSnapshot snapshot, const TextService& text, ScreenSize viewport ); + + const Document& document() const; + const ViewSnapshot& snapshot() const; + void resize( ScreenSize viewport ); + void move( ViewMotion motion ); + void press( CellPoint point, std::chrono::steady_clock::time_point now ); + // The session routes these only while dragging() owns mouse capture. + void drag( CellPoint point ); + void release( CellPoint point ); + void stop_drag(); + bool dragging() const; + bool tick( std::chrono::steady_clock::time_point now ); + void begin_selection(); + void cancel_selection(); + std::optional selected_text() const; + void wheel( int steps ); + bool locate( const DocumentPoint& point ); + std::optional focused_target() const; + void draw( Frame& frame, CellPoint origin ) const; + +private: + std::size_t last_top_row() const; + void set_top_row( std::size_t row ); + void restore_viewport(); + void apply_scrolls( std::span changes ); + void reveal_cursor(); + void finish_move( bool preserve_column ); + void move_rows( std::int64_t distance, bool page ); + void extend_selection(); + void drag_to_pointer(); + + struct Drag + { + CellPoint press {}; + CellPoint pointer {}; + DocumentRange anchor {}; + bool selecting { false }; + std::chrono::steady_clock::time_point next_scroll {}; + }; + + Document document_; + ViewSnapshot snapshot_; + const TextService& text_; + DocumentText content_; + ScreenSize viewport_; + DocumentLayout layout_; + std::size_t top_row_ { 0 }; + std::int64_t desired_column_ { 0 }; + bool follow_cursor_ { false }; + std::optional drag_ {}; +}; + +} // namespace ricochet::tui::detail -- cgit v1.2.3 From 032b82c13e157a048ac13a540dfd18be9667fe49 Mon Sep 17 00:00:00 2001 From: Richard Qin Date: Mon, 26 Oct 2026 20:38:32 +0800 Subject: feat(tui): add object focus traversal and link activation --- ricochet/src/tui/document_view.cc | 22 ++++++++++++++ ricochet/src/tui/document_view.hh | 10 ++++++ ricochet/src/tui/layout.cc | 43 ++++++++++++++++++++++++++ ricochet/src/tui/layout.hh | 15 +++++++++ ricochet/src/tui/session.cc | 64 +++++++++++++++++++++++++++++++++++++-- 5 files changed, 151 insertions(+), 3 deletions(-) (limited to 'ricochet/src/tui/document_view.hh') diff --git a/ricochet/src/tui/document_view.cc b/ricochet/src/tui/document_view.cc index ee74e53..13a5d5f 100644 --- a/ricochet/src/tui/document_view.cc +++ b/ricochet/src/tui/document_view.cc @@ -361,6 +361,28 @@ bool DocumentView::locate( const DocumentPoint& point ) std::optional DocumentView::focused_target() const { return layout_.target( snapshot_.cursor ); } +FocusResult DocumentView::focus( bool backward ) +{ + const auto next = layout_.focus( snapshot_.cursor, backward ); + if ( !next ) { + return FocusResult::Empty; + } + stop_drag(); + snapshot_.cursor = next->position; + finish_move( false ); + return next->wrapped ? FocusResult::Wrapped : FocusResult::Moved; +} + +const Link* DocumentView::focused_link() const +{ + const auto target = focused_target(); + if ( !target || !std::holds_alternative( *target ) ) { + return nullptr; + } + // Layout link targets originate from this same immutable document. + return &*std::ranges::find( document_.data().links, std::get( *target ), &Link::id ); +} + void DocumentView::draw( Frame& frame, CellPoint origin ) const { const auto selection = snapshot_.selection ? std::optional( snapshot_.selection->range ) : std::nullopt; diff --git a/ricochet/src/tui/document_view.hh b/ricochet/src/tui/document_view.hh index 587f419..5f5e331 100644 --- a/ricochet/src/tui/document_view.hh +++ b/ricochet/src/tui/document_view.hh @@ -46,6 +46,13 @@ enum class ViewMotion : std::uint8_t PanRight }; +enum class FocusResult : std::uint8_t +{ + Empty, + Moved, + Wrapped +}; + // One tab's reading state. It owns the logical snapshot; screen rows are caches. // Keyboard, mouse and host navigation all use the same layout/source mappings. class DocumentView @@ -70,6 +77,9 @@ public: void wheel( int steps ); bool locate( const DocumentPoint& point ); std::optional focused_target() const; + // Browse/field-editor routing owns mode eligibility; this follows the shared order. + FocusResult focus( bool backward ); + const Link* focused_link() const; void draw( Frame& frame, CellPoint origin ) const; private: diff --git a/ricochet/src/tui/layout.cc b/ricochet/src/tui/layout.cc index e12c8d0..46bd626 100644 --- a/ricochet/src/tui/layout.cc +++ b/ricochet/src/tui/layout.cc @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -565,6 +566,20 @@ DocumentLayout::DocumentLayout( const Document& document, stops_.push_back( index ); } } + std::set omitted; + for ( const auto& control : document.data().controls ) { + if ( control.disabled ) { + omitted.insert( control.id ); + } + } + for ( std::size_t index = 0; index < stops_.size(); ++index ) { + const auto& target = data_.glyphs[stops_[index]].target; + // Skip ordinary text and disabled/previously encountered objects. A link's + // later fragments never create extra Tab stops, including across blocks. + if ( target && omitted.insert( *target ).second ) { + focus_.push_back( { *target, index } ); + } + } } int DocumentLayout::columns() const @@ -750,6 +765,34 @@ const LayoutGlyph& DocumentLayout::cursor_glyph( const DisplayPosition& position std::optional DocumentLayout::target( const DisplayPosition& position ) const { return cursor_glyph( position ).target; } +std::optional DocumentLayout::focus( const DisplayPosition& position, bool backward ) const +{ + if ( focus_.empty() ) { + return std::nullopt; + } + const auto object = target( position ); + const auto current + = std::ranges::find_if( focus_, [&object]( const auto& entry ) { return object == entry.target; } ); + auto origin = reading_position( position ); + // Any fragment of an object uses that object's single place in the focus order. + // Plain text and disabled controls instead start from the current reading stop. + if ( current != focus_.end() ) { + origin = { current->stop, true }; + } + if ( backward ) { + const auto previous = std::find_if( + focus_.rbegin(), focus_.rend(), [&origin]( const auto& entry ) { return entry.stop < origin.index; } ); + const bool wrapped = previous == focus_.rend(); + return FocusStep { stop( wrapped ? focus_.back().stop : previous->stop ), wrapped }; + } + const auto next = std::ranges::find_if( focus_, [&origin]( const auto& entry ) { + // A line-end insertion boundary is before the next stop, not on its glyph. + return entry.stop > origin.index || ( !origin.at_start && entry.stop == origin.index ); + } ); + const bool wrapped = next == focus_.end(); + return FocusStep { stop( wrapped ? focus_.front().stop : next->stop ), wrapped }; +} + std::optional DocumentLayout::cursor_cell( const DisplayPosition& position ) const { const auto& glyph = cursor_glyph( position ); diff --git a/ricochet/src/tui/layout.hh b/ricochet/src/tui/layout.hh index 7e02e76..f5db28c 100644 --- a/ricochet/src/tui/layout.hh +++ b/ricochet/src/tui/layout.hh @@ -48,6 +48,12 @@ struct LayoutHit std::optional target {}; }; +struct FocusStep +{ + DisplayPosition position {}; + bool wrapped { false }; +}; + struct ScrollWindow { BlockId block {}; @@ -118,6 +124,7 @@ public: DisplayPosition line_edge( const DisplayPosition& position, bool end ) const; DocumentRange unit( const DisplayPosition& position ) const; std::optional target( const DisplayPosition& position ) const; + std::optional focus( const DisplayPosition& position, bool backward ) const; std::optional cursor_cell( const DisplayPosition& position ) const; std::vector reveal( const DisplayPosition& position ) const; std::vector pan( const DisplayPosition& position, int direction ) const; @@ -141,9 +148,17 @@ private: const LayoutGlyph& cursor_glyph( const DisplayPosition& position ) const; DisplayPosition stop( std::size_t index ) const; + struct FocusEntry + { + HitTarget target {}; + std::size_t stop { 0 }; + }; + int columns_; LayoutData data_; std::vector stops_ {}; + // First reading stop per enabled object, independent of viewport clipping. + std::vector focus_ {}; }; } // namespace ricochet::tui::detail diff --git a/ricochet/src/tui/session.cc b/ricochet/src/tui/session.cc index 069c938..f54d382 100644 --- a/ricochet/src/tui/session.cc +++ b/ricochet/src/tui/session.cc @@ -334,6 +334,54 @@ public: } } + void focus( bool backward ) + { + const auto dimensions = screen_->size(); + if ( dimensions.rows < 3 || dimensions.columns < 1 ) { + return; // Object positioning requires a visible document region. + } + auto* view = active_view(); + if ( !view || view->snapshot().selection ) { + return; // Tab must not move the cursor or extend/cancel an active selection. + } + const auto result = view->focus( backward ); + switch ( result ) { + case detail::FocusResult::Empty: + notice_ = L"No focusable links or controls"; + break; + case detail::FocusResult::Moved: + notice_.clear(); + break; + case detail::FocusResult::Wrapped: + notice_ = backward ? L"Focus wrapped to last object" : L"Focus wrapped to first object"; + break; + } + tabs_.at( view->snapshot().scope.tab ).copy_feedback.clear(); + dirty_ = true; + } + + void activate_link() + { + auto* view = active_view(); + if ( !view || view->snapshot().selection ) { + return; // Selection mode consumes activation without navigating. + } + const auto* link = view->focused_link(); + if ( !link ) { + return; // Plain text and controls do not produce link navigation requests. + } + const RequestId request { next_request_++ }; + const auto source = view->snapshot().scope; + actions_.emplace_back( OpenLink { request, source, link->id, link->target, OpenTarget::CurrentTab } ); + auto& tab = tabs_.at( source.tab ); + // Correlate rejection even when the host fails before NavigationStarted. + tab.navigation = request; + tab.failure.reset(); + tab.copy_feedback.clear(); + notice_.clear(); + dirty_ = true; + } + void copy_selection() { auto* view = active_view(); @@ -516,10 +564,18 @@ public: } return; } + if ( key.code == KeyCode::Tab + && ( key.modifiers == Modifiers {} || key.modifiers == Modifiers { .shift = true } ) ) { + focus( key.modifiers.shift ); + return; + } if ( key.modifiers != Modifiers {} ) { return; // Modified keys have distinct bindings; do not alias them to arrows. } switch ( key.code ) { + case KeyCode::Enter: + activate_link(); + break; case KeyCode::Left: move( Motion::Left ); break; @@ -646,9 +702,6 @@ public: if ( !capabilities_.bracketed_paste ) { status = L"Paste boundaries unavailable; multiline paste may confirm input | q quit"; } - if ( !notice_.empty() ) { - status = notice_; - } if ( active_ ) { const auto found = tabs_.find( *active_ ); if ( found != tabs_.end() ) { @@ -668,6 +721,11 @@ public: } } } + // Immediate input feedback (including focus wrap) must remain visible while + // the page has a background navigation status. + if ( !notice_.empty() ) { + status = notice_; + } if ( prefix_ ) { status = prefix_->character == U'g' ? L"g ... | Esc cancel" : L"z ... | Esc cancel"; } -- cgit v1.2.3