Questa pagina è stata tradotta automaticamente e può contenere errori. Leggi l'originale in inglese

Elementi

Table

Un Table dispone alcune righe che l’app scrive come figli (fatture, un riepilogo, un confronto) e offre ai lettori di schermo una tabella: la tabella stessa, i gruppi di righe, le righe, le intestazioni di colonna e le celle, ciascuno con il proprio ruolo. Le sue parti sono TableHeader, TableBody e TableFooter (gruppi di righe), TableRow (le sue celle affiancate), TableHead (la cella di intestazione di una colonna), TableCell e TableCaption. L’aspetto è quello dell’app: nessuna parte ha colori, bordi, padding o larghezze propri, e ciascuna riceve i class e i style dell’app. Per molte righe, ordinamento, selezione e colonne ridimensionabili, la tabella da usare è DataTable.

el-table.tsx
el-table.tsxLive
import { mount, Text, View } from "nsh";
import { Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow } from "nsh/base";
import { size, Stage, ui } from "./palette";

// A few rows the app writes out: the parts give screen readers a table, the
// classes and the palette give it its look.
const invoices = [
  { id: "INV001", status: "Paid", method: "Card", amount: 250 },
  { id: "INV002", status: "Pending", method: "Transfer", amount: 150 },
  { id: "INV003", status: "Unpaid", method: "Card", amount: 350 },
  { id: "INV004", status: "Paid", method: "Cash", amount: 450 },
];
const widths = ["w-24", "flex-1", "w-24", "w-24"];

function Cell(props: { i: number; head?: boolean; end?: boolean; children: string }) {
  const style = { fontSize: size.label, color: props.head ? ui().muted : ui().text, fontWeight: props.head ? ("500" as const) : ("400" as const) };
  const Part = props.head ? TableHead : TableCell;
  return (
    <Part class={`${widths[props.i]} px-3 py-2.5`}>
      <Text style={{ ...style, textAlign: props.end ? "right" : "left" }}>{props.children}</Text>
    </Part>
  );
}

function App() {
  const line = { borderBottomWidth: 1, borderColor: ui().line };
  const total = invoices.reduce((sum, i) => sum + i.amount, 0);
  return (
    <Stage width={520}>
      <View style={{ ...ui().card, borderRadius: 12, overflow: "hidden" }}>
        <Table accessibilityLabel="Recent invoices">
          <TableHeader>
            <TableRow style={line}>
              {["Invoice", "Status", "Method", "Amount"].map((title, i) => (
                <Cell i={i} head end={i === 3}>
                  {title}
                </Cell>
              ))}
            </TableRow>
          </TableHeader>
          <TableBody>
            {invoices.map((inv) => (
              <TableRow style={line}>
                <Cell i={0}>{inv.id}</Cell>
                <Cell i={1}>{inv.status}</Cell>
                <Cell i={2}>{inv.method}</Cell>
                <Cell i={3} end>{`$${inv.amount.toFixed(2)}`}</Cell>
              </TableRow>
            ))}
          </TableBody>
          <TableFooter>
            <TableRow>
              <Cell i={0} head>Total</Cell>
              <Cell i={1}>{""}</Cell>
              <Cell i={2}>{""}</Cell>
              <Cell i={3} end>{`$${total.toFixed(2)}`}</Cell>
            </TableRow>
          </TableFooter>
          <TableCaption class="px-3 py-2">
            <Text style={{ fontSize: size.detail, color: ui().muted }}>A list of your recent invoices.</Text>
          </TableCaption>
        </Table>
      </View>
    </Stage>
  );
}

mount(App);
use nsh_base::{table, table_body, table_cell, table_head, table_header, table_row, theme};
use nsh_core::prelude::*;

fn invoices() -> impl IntoElement {
    let cell = |label: &'static str| table_cell().w(px(120.0)).px_3().py_2().child(text(label));
    table()
        .accessibility_label("Recent invoices")
        .child(
            table_header().child(
                table_row()
                    .border_b_1()
                    .border_color(move || theme().border)
                    .child(table_head().w(px(120.0)).px_3().py_2().child(text("Invoice")))
                    .child(table_head().w(px(120.0)).px_3().py_2().child(text("Amount"))),
            ),
        )
        .child(table_body().child(table_row().child(cell("INV001")).child(cell("$250.00"))))
}

Table e le sue parti provengono da nsh/base, il crate nsh-base in Rust, dove table(), table_header(), table_body(), table_footer(), table_row(), table_head(), table_cell() e table_caption() le creano, con i metodi di stile tipizzati e .child(..). Una riga dispone le sue celle affiancate; l’app assegna le larghezze alle celle, così le colonne risultano allineate.

#Props

PropRustTipoPredefinitoDescrizione
accessibilityLabel.accessibility_label(..)stringnessunoSolo Table: come i lettori di schermo chiamano la tabella.
children.child(..)JSX.ElementnessunoCiò che la parte contiene: gruppi e una didascalia in un Table, righe in un gruppo, celle in una riga, contenuto in una cella.
class, stylemetodi di stilestring, StyleProp<ViewStyle>nessunoL’aspetto e il layout della parte.

#Parti

ParteContenuta inRuolo per i lettori di schermo
Tabletabella
TableHeaderTablegruppo di righe: le righe delle intestazioni di colonna
TableBodyTablegruppo di righe: le righe dei dati
TableFooterTablegruppo di righe: totali, una riga di riepilogo
TableRowun gruppo, oppure Tableriga; le sue celle affiancate
TableHeadun TableRow dell’intestazioneintestazione di colonna
TableCellTableRowcella
TableCaptionTablecontenuto che l’app mostra a proposito della tabella

Ogni piattaforma assegna i ruoli al proprio lettore di schermo: ruoli di tabella, riga, cella e intestazione di colonna su Linux (AT-SPI), sul web (ARIA), su Android e nel backend GPUI; griglie e gruppi su macOS e Windows; intestazioni come intestazioni su iOS.

#Vedi anche

  • DataTable: una tabella con qualsiasi numero di righe e colonne, con selezione, ordinamento e colonne ridimensionabili e spostabili.
  • Accessibility: i valori di accessibilityRole, table, row, cell, columnheader e rowgroup tra gli altri.