Reset master to testing content
This commit is contained in:
Storm Dragon committed
1 parent
0f2587b719
commit
42afa2a56c
1483 files changed
+145308
-938069
No files matched your search
@@ -0,0 +1,243 @@
|
||||
// Copyright (c) 2026 Storm Dragon
|
||||
// Authors: Storm Dragon, Angus Kola
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
package review
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"git.stormux.org/storm/cthulhu/internal/atspi"
|
||||
)
|
||||
|
||||
// moveTable uses provider coordinates, never child order as a rectangular grid.
|
||||
// The virtual coordinate survives a spanning cell so reversing direction keeps
|
||||
// the user's column/row. Nested tables have independent coordinate spaces.
|
||||
func (cursor *DocumentCursor) moveTable(ctx context.Context, doc atspi.DocumentSnapshot, place *documentPlace, command DocumentCaretCommand) (DocumentCaretMove, error) {
|
||||
tableIndex, found := document_table_index(doc, place.object.ID())
|
||||
message := func(text string) (DocumentCaretMove, error) {
|
||||
return DocumentCaretMove{Position: documentPosition(doc, *place), Text: text}, nil
|
||||
}
|
||||
if !found {
|
||||
return message("Not in a table.")
|
||||
}
|
||||
table := doc.Nodes[tableIndex]
|
||||
tableEnd := doc.SubtreeEnd(tableIndex)
|
||||
if err := cursor.tree.ValidateDocumentRange(ctx, doc, tableIndex, tableEnd); err != nil {
|
||||
return DocumentCaretMove{}, err
|
||||
}
|
||||
var current atspi.DocumentNode
|
||||
for id, depth := place.object.ID(), 0; id.Valid() && id != table.Reference.ID() && depth < 128; depth++ {
|
||||
node, ok := doc.Node(id)
|
||||
if !ok {
|
||||
break
|
||||
}
|
||||
role := node.Snapshot.Role
|
||||
if (role == "table cell" || role == "row header" || role == "column header") && !node.Snapshot.TablePositionKnown {
|
||||
return message("Table coordinates unavailable.")
|
||||
}
|
||||
if node.Snapshot.TablePositionKnown {
|
||||
current = node
|
||||
break
|
||||
}
|
||||
id = node.Parent
|
||||
}
|
||||
rows, columns := table.Snapshot.TableRowCount, table.Snapshot.TableColumnCount
|
||||
if rows <= 0 || columns <= 0 {
|
||||
return message("Table coordinates unavailable.")
|
||||
}
|
||||
row, col := current.Snapshot.TableRowIndex, current.Snapshot.TableColumnIndex
|
||||
if current.Reference.Valid() && place.tableCell == current.Reference.ID() {
|
||||
row, col = place.tableRow, place.tableColumn
|
||||
}
|
||||
dr, dc := 0, 0
|
||||
switch command {
|
||||
case TableLeft:
|
||||
dc = -1
|
||||
case TableRight:
|
||||
dc = 1
|
||||
case TableUp:
|
||||
dr = -1
|
||||
case TableDown:
|
||||
dr = 1
|
||||
case TableFirst:
|
||||
row, col = 0, 0
|
||||
case TableLast:
|
||||
row, col = rows-1, columns-1
|
||||
}
|
||||
// A table structural stop starts at its first cell on directional movement.
|
||||
if current.Reference.Valid() {
|
||||
row += dr
|
||||
col += dc
|
||||
} else if command != TableLast {
|
||||
row, col = 0, 0
|
||||
}
|
||||
cells := make([]atspi.DocumentNode, 0)
|
||||
for index := tableIndex + 1; index <= tableEnd; index++ {
|
||||
node := doc.Nodes[index]
|
||||
if node.Snapshot.Role == "table" || node.Snapshot.Role == "tree table" {
|
||||
index = doc.SubtreeEnd(index)
|
||||
continue
|
||||
}
|
||||
if node.Snapshot.TablePositionKnown && !node.Hidden {
|
||||
cells = append(cells, node)
|
||||
}
|
||||
}
|
||||
for attempts := 0; attempts <= len(cells)+1; attempts++ {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return DocumentCaretMove{}, err
|
||||
}
|
||||
if col < 0 {
|
||||
return message("Beginning of row.")
|
||||
}
|
||||
if col >= columns {
|
||||
return message("End of row.")
|
||||
}
|
||||
if row < 0 {
|
||||
return message("Top of column.")
|
||||
}
|
||||
if row >= rows {
|
||||
return message("Bottom of column.")
|
||||
}
|
||||
var target atspi.DocumentNode
|
||||
for _, node := range cells {
|
||||
s := node.Snapshot
|
||||
if row >= s.TableRowIndex && row < s.TableRowIndex+max(1, s.TableRowSpan) && col >= s.TableColumnIndex && col < s.TableColumnIndex+max(1, s.TableColumnSpan) {
|
||||
target = node
|
||||
break
|
||||
}
|
||||
}
|
||||
if !target.Reference.Valid() && (dr != 0 || dc != 0) {
|
||||
target, row, col = next_available_table_cell(cells, current, row, col, dr, dc)
|
||||
}
|
||||
if !target.Reference.Valid() {
|
||||
return message("Table cell unavailable.")
|
||||
}
|
||||
s := target.Snapshot
|
||||
if target.Reference == current.Reference && (dr != 0 || dc != 0) {
|
||||
// Jump over the span rather than iterating potentially huge dimensions.
|
||||
if dr > 0 {
|
||||
row = s.TableRowIndex + max(1, s.TableRowSpan)
|
||||
}
|
||||
if dr < 0 {
|
||||
row = s.TableRowIndex - 1
|
||||
}
|
||||
if dc > 0 {
|
||||
col = s.TableColumnIndex + max(1, s.TableColumnSpan)
|
||||
}
|
||||
if dc < 0 {
|
||||
col = s.TableColumnIndex - 1
|
||||
}
|
||||
continue
|
||||
}
|
||||
parts := []string{}
|
||||
rowHeader, columnHeader := "", ""
|
||||
if s.TableRowHeaders != "" && s.TableRowHeaders != current.Snapshot.TableRowHeaders {
|
||||
rowHeader = s.TableRowHeaders
|
||||
parts = append(parts, rowHeader)
|
||||
}
|
||||
if s.TableColumnHeaders != "" && s.TableColumnHeaders != current.Snapshot.TableColumnHeaders {
|
||||
columnHeader = s.TableColumnHeaders
|
||||
parts = append(parts, columnHeader)
|
||||
}
|
||||
label := strings.TrimSpace(s.Name)
|
||||
prefix := strings.Join(parts, " ")
|
||||
prefixCount := len(parts)
|
||||
if label == "" {
|
||||
label = strings.TrimSpace(strings.ReplaceAll(s.Text, "\ufffc", ""))
|
||||
}
|
||||
if label == "" {
|
||||
label = "blank"
|
||||
}
|
||||
parts = append(parts, label, fmt.Sprintf("Row %d, column %d.", s.TableRowIndex+1, s.TableColumnIndex+1))
|
||||
if s.TableRowSpan > 1 {
|
||||
parts = append(parts, fmt.Sprintf("Spans %d rows.", s.TableRowSpan))
|
||||
}
|
||||
if s.TableColumnSpan > 1 {
|
||||
parts = append(parts, fmt.Sprintf("Spans %d columns.", s.TableColumnSpan))
|
||||
}
|
||||
suffix := strings.Join(parts[prefixCount+1:], " ")
|
||||
place.object, place.offset, place.origin = target.Reference, 0, StructuralNavigation
|
||||
place.tableCell, place.tableRow, place.tableColumn = target.Reference.ID(), row, col
|
||||
return DocumentCaretMove{Position: documentPosition(doc, *place), Text: strings.Join(parts, " "), TablePrefix: prefix, TableSuffix: suffix,
|
||||
TableRowHeader: rowHeader, TableColumnHeader: columnHeader, Moved: true}, nil
|
||||
}
|
||||
return message("Table cell unavailable.")
|
||||
}
|
||||
|
||||
// Use the immutable document index and avoid rebuilding whole-page parent maps.
|
||||
func document_table_index(doc atspi.DocumentSnapshot, id atspi.ObjectID) (int, bool) {
|
||||
for depth := 0; id.Valid() && depth < 128; depth++ {
|
||||
index, ok := doc.Index(id)
|
||||
if !ok {
|
||||
break
|
||||
}
|
||||
node := doc.Nodes[index]
|
||||
if node.Snapshot.Role == "table" || node.Snapshot.Role == "tree table" {
|
||||
return index, true
|
||||
}
|
||||
id = node.Parent
|
||||
}
|
||||
return 0, false
|
||||
}
|
||||
|
||||
// Search captured cells rather than iterating potentially enormous sparse
|
||||
// dimensions. Horizontal neighbors can occupy a lower row of a spanning cell.
|
||||
func next_available_table_cell(cells []atspi.DocumentNode, current atspi.DocumentNode, row, col, dr, dc int) (atspi.DocumentNode, int, int) {
|
||||
var target atspi.DocumentNode
|
||||
bestRow, bestCol := row, col
|
||||
for _, node := range cells {
|
||||
if node.Reference == current.Reference {
|
||||
continue
|
||||
}
|
||||
s := node.Snapshot
|
||||
rowEnd, colEnd := s.TableRowIndex+max(1, s.TableRowSpan)-1, s.TableColumnIndex+max(1, s.TableColumnSpan)-1
|
||||
candidateRow, candidateCol := row, col
|
||||
if dr != 0 {
|
||||
if col < s.TableColumnIndex || col > colEnd {
|
||||
continue
|
||||
}
|
||||
if dr > 0 {
|
||||
candidateRow = max(row, s.TableRowIndex)
|
||||
if candidateRow > rowEnd {
|
||||
continue
|
||||
}
|
||||
} else {
|
||||
candidateRow = min(row, rowEnd)
|
||||
if candidateRow < s.TableRowIndex {
|
||||
continue
|
||||
}
|
||||
}
|
||||
if target.Reference.Valid() && (dr > 0 && candidateRow >= bestRow || dr < 0 && candidateRow <= bestRow) {
|
||||
continue
|
||||
}
|
||||
} else {
|
||||
lastRow := row
|
||||
if current.Reference.Valid() {
|
||||
lastRow = max(row, current.Snapshot.TableRowIndex+max(1, current.Snapshot.TableRowSpan)-1)
|
||||
}
|
||||
candidateRow = max(row, s.TableRowIndex)
|
||||
if candidateRow > rowEnd || candidateRow > lastRow {
|
||||
continue
|
||||
}
|
||||
if dc > 0 {
|
||||
candidateCol = max(col, s.TableColumnIndex)
|
||||
if candidateCol > colEnd {
|
||||
continue
|
||||
}
|
||||
} else {
|
||||
candidateCol = min(col, colEnd)
|
||||
if candidateCol < s.TableColumnIndex {
|
||||
continue
|
||||
}
|
||||
}
|
||||
if target.Reference.Valid() && (candidateRow > bestRow || candidateRow == bestRow && (dc > 0 && candidateCol >= bestCol || dc < 0 && candidateCol <= bestCol)) {
|
||||
continue
|
||||
}
|
||||
}
|
||||
target, bestRow, bestCol = node, candidateRow, candidateCol
|
||||
}
|
||||
return target, bestRow, bestCol
|
||||
}
|
||||
Reference in new issue
Block a user