```toml

Cargo.toml

[dependencies] dip = { version = "0.2", features = ["desktop"] } ```

```rust, no_run use dip::prelude::*;

fn main() { App::new() .insertresource(WindowDescriptor { title: "Desktop App".tostring(), ..Default::default() }) .add_plugin(DesktopPlugin::::new(Root)) .run(); }

fn Root(cx: Scope) -> Element { let name = usestate(&cx, || "world".tostring());

cx.render(rsx! {
    h1 { "Hello, {name} !" }

    input {
        value: "{name}",
        oninput: |e| {
            name.set(e.value.to_string());
        },
    }
})

} ```

```toml

Cargo.toml

[dependencies] dip = { version = "0.2", features = ["cli"] } clap = { version = "3.2", features = ["derive"] } ```

```rust, no_run use dip::{bevy::log::LogPlugin, prelude::*};

fn main() { App::new() .addplugin(CliPlugin::::oneshot()) .addplugin(ActionPlugin) .addplugin(LogPlugin) .addsystem(logrootarg) .addsystem(logpathflag) .addsystem(handlehello) .addsystem(handletask) .addsystem(handle_ping) .run(); }

[derive(CliPlugin, clap::Parser)]

[clap(author, version, about, long_about = None)]

struct Cli { root_arg: Option,

#[clap(short, long)]
path: Option<String>,

#[clap(subcommand)]
action: Action,

}

[derive(SubcommandPlugin, clap::Subcommand, Clone)]

pub enum Action { // Named variant Hello { name: Option }, // Unnamed Hello2(Hello2Args), // Unit Ping, }

[derive(clap::Args, Debug, Clone)]

pub struct Hello2Args { name: Option, }

fn logrootarg(cli: Res) { if let Some(arg) = &cli.root_arg { info!("root arg: {:?}", arg); } }

fn logpathflag(cli: Res) { if let Some(path) = &cli.path { info!("path flag: {:?}", path); } }

fn handlehello(mut events: EventReader) { for e in events.iter() { info!("Hello, {}!", e.name.clone().unwrapor("world".to_string())); } }

fn handletask(mut events: EventReader) { for e in events.iter() { info!("Hello, {}!", e.name.clone().unwrapor("world".to_string())); } }

fn handle_ping(mut events: EventReader) { for _ in events.iter() { info!("Pong !"); } } ```

```sh cargo run -- --help

dip-cli-example 0.1.0 Junichi Sugiura Example binary project to showcase CliPlugin usage.

USAGE: cli [OPTIONS] [ROOT_ARG]

ARGS:

OPTIONS: -h, --help Print help information -p, --path -V, --version Print version information

SUBCOMMANDS: hello hello2 help Print this message or the help of the given subcommand(s) ping

```

```toml

Cargo.toml

[dependencies] dip = { version = "0.2", features = ["desktop"] }

Removing this crate throws error.

This is because some derive macros generates code using sub crate name instead of root

(e.x. bevy_ecs::Component vs bevy::ecs::Compoent)

bevy_ecs = "0.8" ```

```rust, no_run use dip::prelude::*;

fn main() { App::new() // Step 7. Put it all together .addplugin(DesktopPlugin::::new(Root)) .addplugin(UiStatePlugin) // generated by #[uistate] .addplugin(UiActionPlugin) // generated by #[uiaction] .addsystem(update_name) .run(); }

// Step 1: Define UiState // Each field represents root state. You can create multiple of them. // This macro generates UiState enum and UiStatePlugin which will be used in step 7.

[ui_state]

struct UiState { name: Name, }

// Make sure to wrap primitive types or common type such as String with named struct or enum. // You need to distinguish types in order to query specific root state in step 4 (system).

[derive(Clone, Debug)]

pub struct Name { value: String, }

// This is how you define default value for Name root state. impl Default for Name { fn default() -> Self { Self { value: "world".to_string(), } } }

// Step 2. Define actions // Create as many as actions with struct or enum.

[derive(Clone, Debug)]

pub struct UpdateName { value: String, }

// Step 3. Implement action creators // Each method needs to return one of actions that you defined in step 2. // This macro derives UiActionPlugin and UiAction which will be used in step 7.

[ui_action]

impl ActionCreator { fn update_name(value: String) -> UpdateName { UpdateName { value } } }

// Step 4. Implement systems to handle each action defined in step 2. // System is like reducer in Redux but more flexible. fn update_name(mut events: EventReader, mut name: ResMut) { for action in events.iter() { name.value = action.value.clone(); } }

fn Root(cx: Scope) -> Element { // Step 5. Select state let name = use_read(&cx, NAME);

let window = use_window::<UiAction, NoAsyncAction>(&cx);

cx.render(rsx! {
    h1 { "Hello, {name.value} !" }

    input {
        value: "{name.value}",
        oninput: |e| {
            // Step 6. Dispatch the action !
            window.send(UiAction::update_name(e.value.to_string()));
        },
    }
})

} ```