Aller au contenu

Construire un compteur (FR)

Tutoriel3 min de lecture
Modifier cette page

Vous construirez une application compteur dont la logique réactive vit dans une crate bibliothèque agnostique vis-à-vis du framework et dont la couche de vue tourne sur GPUI. À la fin, vous re-ciblez le même hook vers Leptos en changeant un seul drapeau de fonctionnalité. Le compteur est le plus petit programme qui exerce chaque couche de Quoin : un signal pour l’état, un hook portable écrit contre ReactiveContext, et une vue framework qui lit le signal.

Prérequis : Rust stable 1.88 ou plus récent (rustup update stable), et un terminal. Aucune bibliothèque système GPUI n’est nécessaire pour la crate de logique ; GPUI lui-même a besoin des en-têtes de fenêtrage Linux habituels listés dans le guide d’installation.

  1. Créez un espace de travail Cargo avec deux crates : une bibliothèque pour la logique portable et un binaire pour la vue GPUI.

    Terminal
    cargo new counter --lib
    cargo new counter-gpui --bin
  2. Ajoutez Quoin aux deux manifestes. La bibliothèque dépend de quoin-core (traits seuls, pas de framework). Le binaire dépend de quoin avec la fonctionnalité gpui.

    counter/Cargo.toml
    [dependencies]
    quoin-core = "0.1"
    counter-gpui/Cargo.toml
    [dependencies]
    counter = { path = "../counter" }
    quoin = { version = "0.1", features = ["gpui"] }

Le hook est une fonction Rust ordinaire générique sur ReactiveContext. Il ne connaît rien de GPUI, des fenêtres ou du rendu.

counter/src/lib.rs
use quoin_core::prelude::*;
use std::rc::Rc;
pub struct Counter<S: Signal<u32>> {
pub count: S,
pub increment: Rc<dyn Fn()>,
}
pub fn use_counter<C: ReactiveContext>(cx: &C) -> Counter<C::Signal<u32>> {
let count = cx.create_signal(0u32);
let increment = {
let count = count.clone();
Rc::new(move || count.update(|c| *c += 1))
};
Counter { count, increment }
}

Points clés :

  • cx.create_signal(0u32) alloue de l’état réactif via le contexte. Le type renvoyé est C::Signal<u32> — quel que soit le framework actif.
  • count.update(|c| *c += 1) mute en place et demande un re-rendu sur les adaptateurs à tirage.
  • La borne Signal<T> garde la struct utilisable avec le type de signal de n’importe quel adaptateur.

Câblez maintenant le hook dans un composant GPUI et amorcez l’application avec run_app!.

counter-gpui/src/main.rs
use counter::use_counter;
use quoin::prelude::*;
struct CounterView {
counter: counter::Counter<quoin::GpuiSignal<u32>>,
_ctx: GpuiContext,
}
impl Render for CounterView {
fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
let count = self.counter.count.get();
div()
.flex()
.child(format!("Count: {count}"))
.child(
div()
.child("Increment")
.on_mouse_down(MouseButton::Left, cx.listener(|this, _, _, _| {
(this.counter.increment)();
}))
)
}
}
fn main() {
let ctx = GpuiContext::new();
let counter = use_counter(&ctx);
run_app!(CounterView { counter, _ctx: ctx });
}

Exécutez :

Terminal
cargo run -p counter-gpui

Sortie attendue : une fenêtre native affichant Count: 0 avec un bouton Increment ; chaque clic met à jour le libellé.

Changez le drapeau de fonctionnalité et échangez la vue. La crate hook reste intacte.

counter-leptos/Cargo.toml
[dependencies]
counter = { path = "../counter" }
quoin = { version = "0.1", features = ["leptos"] }
counter-leptos/src/lib.rs
use counter::use_counter;
use quoin::prelude::*;
#[component]
pub fn App() -> impl IntoView {
let ctx = LeptosContext::new();
let counter = use_counter(&ctx);
view! {
<div>
<p>"Count: " {move || counter.count.get()}</p>
<button on:click=move |_| (counter.increment)()>"Increment"</button>
</div>
}
}

Vous pouvez aussi sauter entièrement la couche de vue : le guide de test exécute le même hook sans tête avec quoin-testkit, et le guide devtools trace chaque mutation de signal qu’il effectue.