Struct Column 

pub struct Column<'a> {
    pub name: &'a str,
    pub width: Width,
    pub priority: Priority,
    pub sortable: bool,
    pub sorted: Option<Sort>,
}

One column of a table.

Described once. The grid track, the cell order and the drop behaviour are all derived from this, rather than being three hand-written encodings that must agree and are never checked against each other.

Fields

name: &'a str

The heading, and the name the cell is addressed by.

width: Width

How much room it asks for.

priority: Priority

What it is worth when room runs out.

sortable: bool

Whether the user can reorder the table by this column.

ce620871. What reordering calls is not here — that is an address, and this crate names none — so a host pairs this with the route the way it pairs a row’s parts with the row’s activation. This says the affordance exists, which is what a renderer needs to draw a header a user can press rather than a heading they cannot.

sorted: Option<Sort>

Which way the table is ordered by this column, if it is.

None on every column but the one in force. A renderer draws the caret from this and a webview sets aria-sort, which is why it is per column rather than a single fact on the table: the host idiom is a property of the header cell.

Independent of sortable rather than implied by it, because both combinations mean something. A column sorted and not sortable is a list ordered by a key the user cannot change, which is a real thing to describe and a caret worth drawing.

Implementations

impl<'a> Column<'a>

pub const fn new(name: &'a str) -> Self

A column that absorbs slack and drops after the optional ones.

pub const fn kept_at(&self, cutoff: Priority) -> bool

Whether this column survives at the given cutoff.

A renderer narrows by raising the cutoff, and never by counting positions.

Trait Implementations

impl<'a> Clone for Column<'a>

fn clone(&self) -> Column<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for Column<'a>

impl<'a> Debug for Column<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Eq for Column<'a>

impl<'a> Hash for Column<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for Column<'a>

fn eq(&self, other: &Column<'a>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a> StructuralPartialEq for Column<'a>