View

View è il blocco fondamentale di ogni schermata: un contenitore nativo (una UIView su iOS e Mac Catalyst, un ViewGroup su Android) che dispone i propri figli con flexbox o grid, disegna sfondo, bordi, ombre e gradienti, e gestisce le pressioni. Pulsanti, card, righe e schermate sono tutti view. Rust ne crea una con view(), TSX con <View> da nsh.

import { mount, signal, Text, View } from "nsh";
import { button, buttonText, desktop, focusRing, Inspector, Panel, Stage, ui, wide } from "./palette";

function App() {
  const presses = signal(0);
  const size = signal("");
  const views = () => (
    <>
      <View
        onPress={() => presses.update((n) => n + 1)}
        {...button("accent", { align: "center" })}
      >
        <Text style={buttonText("accent")}>activeStyle opacity · pressed {presses()}×</Text>
      </View>

      <View
        onPress={() => presses.update((n) => n + 1)}
        activeStyle={{ backgroundColor: ui().border }}
        style={{ ...ui().card, backgroundImage: "none", borderRadius: 16, padding: 16 }}
        hoverStyle={{ opacity: 0.88 }}
        focusStyle={focusRing()}
      >
        <Text style={{ color: ui().text, fontSize: wide() ? 14 : 16 }}>activeStyle background ({desktop ? "click" : "tap"} and hold)</Text>
      </View>

      <View class="flex-row gap-3">
        <View class="flex-1 h-20 rounded-xl bg-[#ff6170] hover:bg-[#ff7d89] active:bg-[#d94d5b] items-center justify-center" focusStyle={focusRing()} onPress={() => {}}>
          <Text class="text-[#13160c] font-semibold">active:</Text>
        </View>
        <View class="flex-1 h-20 rounded-xl bg-[#45d49a] items-center justify-center shadow-lg">
          <Text class="text-[#0c0d0f] font-semibold">shadow-lg</Text>
        </View>
        <View
          class="flex-1 h-20 rounded-xl items-center justify-center"
          style={{ backgroundImage: `linear-gradient(135deg, ${ui().violet}, ${ui().info})` }}
        >
          <Text class="font-semibold" style={{ color: ui().page }}>gradient</Text>
        </View>
      </View>
    </>
  );
  const measured = (height?: number) => (
    <View
      onLayout={({ bounds }) => size.set(`${Math.round(bounds.size.width)} × ${Math.round(bounds.size.height)} pt`)}
      style={{
        flex: height === undefined ? 1 : undefined,
        height,
        borderRadius: 12,
        borderWidth: 2,
        borderStyle: "dashed",
        borderColor: ui().faint,
        alignItems: "center",
        justifyContent: "center",
      }}
    >
      <Text style={{ color: ui().muted }}>onLayout: {size()}</Text>
    </View>
  );

  return (
    <View style={{ flex: 1, backgroundColor: ui().page }}>
      {() =>
        wide() ? (
          <View style={{ flex: 1, padding: 20, paddingTop: 24, gap: 14 }}>
            <Text style={{ fontSize: 22, fontWeight: "700", color: ui().text }}>view</Text>
            <Text style={{ color: ui().muted }}>Click and hold the views; resize the window to see onLayout</Text>
            <View style={{ flex: 1, flexDirection: "row", gap: 16 }}>
              <Stage width={480} gap={16}>
                {views()}
                {measured(120)}
              </Stage>
              <Inspector>
                <Panel title="onPress">
                  <Text style={{ fontSize: 13, color: ui().text, fontVariant: ["tabular-nums"] }}>pressed {presses()}×</Text>
                </Panel>
                <Panel title="onLayout" grow>
                  <Text style={{ fontSize: 13, color: ui().text, fontVariant: ["tabular-nums"] }}>{size()}</Text>
                </Panel>
              </Inspector>
            </View>
          </View>
        ) : (
          <View style={{ flex: 1, width: "100%", maxWidth: 640, alignSelf: "center", padding: 20, paddingTop: 24, gap: 16 }}>
            <Text style={{ fontSize: 22, fontWeight: "700", color: ui().text }}>view</Text>
            {views()}
            {measured()}
          </View>
        )
      }
    </View>
  );
}

mount(App);

use nsh_core::prelude::*;

fn app() -> impl IntoElement {
    let liked = signal(false);
    view()
        .flex_1()
        .p_6()
        .gap_4()
        .bg(rgb(0xf6f8fa))
        .child(
            view()
                .flex_row()
                .items_center()
                .gap_3()
                .p_4()
                .rounded(px(16.0))
                .bg(white())
                .shadow_md()
                .child(view().size(px(40.0)).rounded_full().bg(rgb(0x8250df)))
                .child(text("A card").flex_1().text_base())
                .child(
                    view()
                        .hit_slop(EdgeInsets::all(px(8.0)))
                        .active(|s| s.opacity(0.5))
                        .on_press(move || liked.update(|l| *l = !*l))
                        .child(text(move || if liked.get() { "♥" } else { "♡" }).text_size(px(22.0))),
                ),
        )
}

import { mount, signal, Text, View } from "nsh";

function App() {
  const liked = signal(false);
  return (
    <View style={{ flex: 1, padding: 24, gap: 16, backgroundColor: "#f6f8fa" }}>
      <View
        style={{
          backgroundColor: "#ffffff",
          borderRadius: 16,
          padding: 16,
          boxShadow: "0 4px 12px rgba(0, 0, 0, 0.08)",
          flexDirection: "row",
          alignItems: "center",
          gap: 12,
        }}
      >
        <View style={{ width: 40, height: 40, borderRadius: 20, backgroundColor: "#8250df" }} />
        <Text style={{ flex: 1, fontSize: 16 }}>A card</Text>
        <View onPress={() => liked.set(!liked())} activeStyle={{ opacity: 0.5 }} hitSlop={8}>
          <Text style={{ fontSize: 22 }}>{liked() ? "♥" : "♡"}</Text>
        </View>
      </View>
    </View>
  );
}

mount(App);

#Layout

Una view dispone i propri figli con flexbox, con questi valori predefiniti: flexDirection: "column", flexShrink: 0, alignContent: "flex-start", position: "relative". display: "grid" (.grid() in Rust) passa al CSS grid e display: "block" al layout a blocchi. Le dimensioni sono in punti. Vedi layout e il riferimento degli stili.

display: "flex" segue il CSS: in uno stile, come classe flex e come .flex() di Rust, è una riga a meno che non sia impostata una direzione (flexDirection: "column", flex-col, .flex_col()). Una view che non imposta alcun display dispone i propri figli in colonna.

#Props

View ha una prop propria, selectable (.selectable(true) in Rust): i testi all’interno della view si selezionano insieme, come un’unica selezione (Selezione del testo). Le altre sono le prop comuni: gli stili (style, class, classList; i metodi Styled in Rust), disabled, le prop di pressione (onPress, onLongPress, onPressDown, onPressUp, delayLongPress, hitSlop), gli stili di stato (activeStyle, hoverStyle, focusStyle, disabledStyle, checkedStyle), onMouseEnter / onMouseMove / onMouseLeave, onContextMenu, onFileDragEnter / onFileDragLeave / onFileDrop, focusable, onLayout, ref, nativeID, testID, le prop dei gesti (pan, pinch, rotation e i relativi eventi), le prop di touch e responder, le prop di accessibilità e ios / android / desktop.

#View selezionabili

Con selectable, una selezione attraversa gli elementi Text e i TextView all’interno della view, in ordine di lettura; i testi con selectable={false} restano esclusi, e una view selezionabile dentro un’altra fa parte di quella esterna. Vedi Selezione del testo per i gesti su ogni piattaforma.

<View selectable class="gap-3 p-4">
  <Text>One selection runs from here…</Text>
  <Text>…to here.</Text>
</View>

#Feedback alla pressione

Una view premibile è qualsiasi view con un gestore di pressione. Il suo feedback è definito dall’app: uno stile mentre è premuta, applicato in modo nativo finché il dito è appoggiato, senza passare dal codice dell’app. hoverStyle, focusStyle e disabledStyle fanno lo stesso per gli altri stati:

// Fade the whole view.
view().on_press(open).active(|s| s.opacity(0.6))

// Show a background; group_active styles the children.
view()
    .group()
    .on_press(open)
    .active(|s| s.bg(rgb(0xe5e7eb)))
    .child(text("Open").group_active(|s| s.opacity(0.7)))

// Change any style while pressed.
view().on_press(open).bg(rgb(0x2563eb)).active(|s| s.bg(rgb(0x1e40af)).scale(0.95))

// Fade the whole view.
<View onPress={open} activeStyle={{ opacity: 0.6 }}>…</View>

// Show a background; group-active: styles the children.
<View onPress={open} class="group" activeStyle={{ backgroundColor: "#e5e7eb" }}>
  <Text class="group-active:opacity-70">Open</Text>
</View>

// Change any style while pressed with active: classes.
<View onPress={open} class="bg-blue-600 active:bg-blue-800 active:scale-95">…</View>

Su Android, android={{ ripple: { color: "#0000001f" } }} (.ripple(Ripple { .. }) in Rust) aggiunge l’effetto ripple di Material (borderless, radius e foreground lo regolano).

disabled rimuove i listener di pressione dalla view nativa (nessuna pressione, nessun feedback) e applica gli stili disabilitati:

view()
    .on_press(submit)
    .disabled(move || !valid.get())
    .bg(rgb(0x16a34a))
    .disabled_style(|s| s.opacity(0.4))

<View onPress={submit} disabled={!valid()} class="bg-green-600 disabled:opacity-40">…</View>

#Eventi

Per gli eventi di touch e responder, vedi le prop comuni.

#Rilascio di file su desktop

Su AppKit, GTK, Win32 e GPUI, una view con onFileDrop riceve file e directory locali trascinati da un’altra applicazione. onFileDragEnter e onFileDragLeave tengono traccia della destinazione attiva; onFileDrop riceve { uris: string[] } nell’ordine della lista di file nativa. Ogni voce è un URL file: assoluto con spazi e caratteri non ASCII con escape. Analizza l’URL per ottenere un percorso del filesystem, invece di rimuovere il prefisso a mano.

let hovering = signal(false);
let files = signal(Vec::<String>::new());

view()
    .min_h(px(160.0))
    .p_6()
    .on_file_drag_enter(move || hovering.set(true))
    .on_file_drag_leave(move || hovering.set(false))
    .on_file_drop(move |event: &FileDropEvent| {
        files.set(event.uris.clone());
        hovering.set(false);
    })
    .child(text(move || if hovering.get() { "Release files here" } else { "Drop files here" }))
    .child(text(move || files.get().join("\n")))

const hovering = signal(false);
const files = signal<string[]>([]);

<View
  onFileDragEnter={() => hovering.set(true)}
  onFileDragLeave={() => hovering.set(false)}
  onFileDrop={(event) => {
    files.set(event.uris);
    hovering.set(false);
  }}
  style={{ minHeight: 160, padding: 24 }}
>
  <Text>{hovering() ? "Release files here" : "Drop files here"}</Text>
  <Text>{files().join("\n")}</Text>
</View>

Il discendente abilitato più vicino in ascolto di onFileDrop riceve il rilascio. Una radice modale delimita questa ricerca. disabled rimuove i listener di trascinamento/rilascio dei file; l’uscita, l’annullamento, il completamento e la rimozione della destinazione azzerano lo stato attivo. L’accettazione usa l’operazione Copy e lo stato nativo montato. Spetta all’app decidere se leggere, aprire o trasferire i file ricevuti.

#Metodi del ref

Il ref di una view semplice è un ViewRef: focus(), blur() e measure(). ref (.element_ref(&handle) in Rust) restituisce il suo nodo, ad esempio da passare a setAccessibilityFocus (API di accessibilità di nsh), oppure per misurarla (handle.measure() in Rust).

#View dentro il testo

Una view posta dentro un testo è un allegato inline: si colloca sulla linea di base, va a capo insieme alle parole e riceve pressioni proprie. Vedi testo.

#Note sulle piattaforme

• boxShadow viene disegnata su ogni piattaforma; android={{ elevation }} fornisce invece l’ombra material di Android. Su Android un’ombra richiede un colore di sfondo (una view con sfondo trasparente nonproietta alcuna ombra).
• filter sulle view: iOS supporta opacity(), brightness() fino a 1 e drop-shadow() (le immagini accettano ogni filtro colore e blur()); Android li supporta tutti da API 31, e i filtri colore sotto tale livello.
• backdropFilter: "blur(…)" è un materiale di sistema su iOS (un’approssimazione) e richiede API 31 su Android.
• Android disegna le trasformazioni translate, scale e rotate; le inclinazioni (skew(), skewX(), skewY()) si applicano sulle altre piattaforme.
• borderCurve: "continuous" (.border_curve(BorderCurve::Continuous)) disegna angoli che si raccordano dolcemente ai bordi (come le icone delle app iOS), su entrambe le piattaforme.
• Lo stile cursor si applica dove è presente un puntatore (Mac Catalyst, iPad con puntatore, desktop).