449 lines
12 KiB
Rust
449 lines
12 KiB
Rust
use crate::components::*;
|
|
use std::collections::{HashMap, HashSet};
|
|
|
|
use lan_party_core::event::{
|
|
free_for_all_game::{FreeForAllGame, FreeForAllGameRanking, FreeForAllGameSpec},
|
|
team_game::{TeamGame, TeamGameSpec},
|
|
test::{Test, TestSpec},
|
|
*,
|
|
};
|
|
use paste::paste;
|
|
use wasm_bindgen::JsValue;
|
|
use yew::prelude::*;
|
|
|
|
use crate::{bind, bind_change, bind_value, clone, clone_cb};
|
|
|
|
macro_rules! view_fields {
|
|
($(($name:expr, $prop:expr)),* $(,)?) => {
|
|
html! {
|
|
<>
|
|
$(
|
|
<p>
|
|
{ $name }
|
|
{ $prop.view() }
|
|
</p>
|
|
)*
|
|
</>
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! view_struct {
|
|
($struct:path: $title:expr => $(($name:expr, $prop:ident)),* $(,)?) => {
|
|
impl View for $struct {
|
|
fn view(&self) -> Html {
|
|
html! {
|
|
<Block title={$title}>
|
|
{ view_fields!(
|
|
$(($name, self.$prop),)*
|
|
)}
|
|
</Block>
|
|
}
|
|
}
|
|
}
|
|
};
|
|
($struct:path as $self:ident => $body:expr) => {
|
|
impl View for $struct {
|
|
fn view(&$self) -> Html {
|
|
$body
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! view_enum_simple {
|
|
($enum:path: $($variant:ident),* $(,)?) => {
|
|
impl View for $enum {
|
|
fn view(&self) -> Html {
|
|
html! {
|
|
{match self {
|
|
$(
|
|
Self::$variant(i) => html! {
|
|
<>
|
|
{ i.view() }
|
|
</>
|
|
},
|
|
)*
|
|
}}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
#[derive(Debug, Clone, Properties, PartialEq)]
|
|
pub struct BlockProps {
|
|
title: String,
|
|
children: Children,
|
|
}
|
|
|
|
#[function_component(Block)]
|
|
pub fn block(props: &BlockProps) -> Html {
|
|
let open = use_state(|| false);
|
|
let mut class = classes!("overflow-hidden");
|
|
|
|
if !*open {
|
|
class.push("max-h-1");
|
|
}
|
|
|
|
html! {
|
|
<>
|
|
<div class="px-3 py-3 rounded-lg border-solid border-gray-800 border-2 my-3">
|
|
<p class="cursor-pointer text-lg" onclick={clone_cb!(open => move |_| open.set(!*open))}>{ &props.title }</p>
|
|
<div {class}>
|
|
<br />
|
|
<div>
|
|
{for props.children.iter()}
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</>
|
|
}
|
|
}
|
|
|
|
pub trait View {
|
|
fn view(&self) -> Html;
|
|
}
|
|
|
|
impl View for bool {
|
|
fn view(&self) -> Html {
|
|
html! {
|
|
<input type="checkbox" value={self.to_string()} disabled={true} />
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait ViewPlain: Into<Html> + std::fmt::Display {}
|
|
|
|
impl<T> View for T
|
|
where
|
|
T: ViewPlain,
|
|
{
|
|
fn view(&self) -> Html {
|
|
self.into()
|
|
}
|
|
}
|
|
|
|
impl ViewPlain for i64 {}
|
|
impl ViewPlain for i32 {}
|
|
impl ViewPlain for isize {}
|
|
|
|
impl ViewPlain for u64 {}
|
|
impl ViewPlain for u32 {}
|
|
impl ViewPlain for usize {}
|
|
|
|
impl ViewPlain for f64 {}
|
|
impl ViewPlain for f32 {}
|
|
|
|
impl ViewPlain for String {}
|
|
impl<'a> ViewPlain for &'a str {}
|
|
|
|
macro_rules! view_iter {
|
|
($t:ident => $type:ty) => {
|
|
impl<$t: View> View for $type {
|
|
fn view(&self) -> Html {
|
|
html! {
|
|
<Block title="List">
|
|
<ul>
|
|
{ self.iter().map(|x| html! { <li>{ x.view() }</li> }).collect::<Html>() }
|
|
</ul>
|
|
</Block>
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
view_iter!(T => Vec<T>);
|
|
view_iter!(T => HashSet<T>);
|
|
view_iter!(T => &[T]);
|
|
|
|
impl<T: View> View for Option<T> {
|
|
fn view(&self) -> Html {
|
|
match self {
|
|
Some(content) => content.view(),
|
|
None => html! { "None" },
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<K: View, V: View> View for HashMap<K, V> {
|
|
fn view(&self) -> Html {
|
|
html! {
|
|
<Block title={"Map"}>
|
|
{self.iter().map(|(k, v)| {
|
|
html! { <p><span>{k.view()}</span>{ ": " }<span>{v.view()}</span></p> }
|
|
}).collect::<Html>()}
|
|
</Block>
|
|
}
|
|
}
|
|
}
|
|
|
|
view_struct!(
|
|
lan_party_core::event::Event: "Event" =>
|
|
("Name: ", name),
|
|
("Description: ", description),
|
|
("Concluded: ", concluded),
|
|
("Event type: ", event_type),
|
|
);
|
|
|
|
view_enum_simple!(
|
|
lan_party_core::event::EventType: Test,
|
|
TeamGame,
|
|
FreeForAllGame
|
|
);
|
|
|
|
view_struct!(
|
|
lan_party_core::event::test::Test: "Test" =>
|
|
("Number of players: ", num_players)
|
|
);
|
|
|
|
view_struct!(FreeForAllGame as self =>
|
|
html! {
|
|
<Block title={"FreeForAllGame"}>
|
|
{ view_fields!(("Ranking: ", self.ranking)) }
|
|
{ view_fields!(
|
|
("Participants: ", self.spec.participants),
|
|
("Win rewards: ", self.spec.win_rewards),
|
|
("Lose rewards: ", self.spec.lose_rewards),
|
|
) }
|
|
</Block>
|
|
}
|
|
);
|
|
|
|
view_enum_simple!(
|
|
lan_party_core::event::free_for_all_game::FreeForAllGameRanking: Ranking,
|
|
Scores
|
|
);
|
|
|
|
view_struct!(TeamGame as self =>
|
|
html! {
|
|
<Block title={"TeamGame"}>
|
|
{ view_fields!(("Teams: ", self.teams)) }
|
|
{ view_fields!(("Ranking: ", self.ffa_game.ranking)) }
|
|
{ view_fields!(
|
|
("Participants: ", self.ffa_game.spec.participants),
|
|
("Win rewards: ", self.ffa_game.spec.win_rewards),
|
|
("Lose rewards: ", self.ffa_game.spec.lose_rewards),
|
|
) }
|
|
</Block>
|
|
}
|
|
);
|
|
|
|
macro_rules! edit_fields {
|
|
($(($name:expr, $prop:expr)),* $(,)?) => {
|
|
html! {
|
|
<>
|
|
$(
|
|
<p>
|
|
{ $name }
|
|
{ $prop.edit() }
|
|
</p>
|
|
)*
|
|
</>
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! link_fields {
|
|
($($field:ident),* $(,)? => $state:ident as $t:ident) => {
|
|
$(let $field = use_state(|| $state.$field.clone());)*
|
|
|
|
use_effect_with_deps(
|
|
clone!($($field,)* $state =>
|
|
move |_| {
|
|
$state.set($t {
|
|
$($field: (*$field).clone(),)*
|
|
..Default::default()
|
|
});
|
|
|| { $(drop($field);)* drop($state); }
|
|
}
|
|
),
|
|
($($field.clone(),)*),
|
|
);
|
|
};
|
|
}
|
|
|
|
macro_rules! link_variants {
|
|
($selected:ident => $($index:literal: $var_name:ident = $variant:ident: $var_type:ty),* $(,)? => $state:ident as $t:ident) => {
|
|
let $selected = use_state(|| 0 as usize);
|
|
$(let $var_name = if let $t::$variant(v) = &*$state {
|
|
use_state(|| v.clone())
|
|
} else {
|
|
use_state(|| <$var_type>::default())
|
|
};)*
|
|
|
|
use_effect_with_deps(
|
|
clone!($($var_name,)* $state, $selected =>
|
|
move |_| {
|
|
match *$selected {
|
|
$($index => $state.set($t::$variant((*$var_name).clone())),)*
|
|
_ => unreachable!()
|
|
}
|
|
|| { $(drop($var_name);)* drop($selected); drop($state); }
|
|
}
|
|
),
|
|
($($var_name.clone(),)* $selected.clone()),
|
|
);
|
|
};
|
|
}
|
|
|
|
macro_rules! edit_struct {
|
|
($struct:ident => $(($name:expr, $prop:ident)),* $(,)?) => {
|
|
paste! {
|
|
#[function_component([<$struct Edit>])]
|
|
pub fn [<$struct:lower _edit>](props: &EditProps<$struct>) -> Html {
|
|
let state = props.state.clone();
|
|
link_fields!($($prop,)* => state as $struct);
|
|
html! {
|
|
<Block title={stringify!($struct)}>
|
|
{ edit_fields!($(($name, $prop)),*) }
|
|
</Block>
|
|
}
|
|
}
|
|
|
|
impl Editable for $struct {
|
|
type Edit = [<$struct Edit>];
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! edit_enum {
|
|
($enum:ident => $selected:ident => $($index:literal: $var_name:ident = $variant:ident: $var_type:ty),* $(,)?) => {
|
|
paste! {
|
|
#[function_component([<$enum Edit>])]
|
|
pub fn [<$enum:lower _edit>](props: &EditProps<$enum>) -> Html {
|
|
let state = props.state.clone();
|
|
|
|
link_variants!($selected =>
|
|
$($index: $var_name = $variant: $var_type,)*
|
|
=> state as $enum
|
|
);
|
|
|
|
html! {
|
|
<Block title={stringify!($enum)}>
|
|
<Select class="" bind={bind!($selected)}>
|
|
$(<option value={stringify!($index)}>{ stringify!($variant) }</option>)*
|
|
</Select>
|
|
{ match &*state {
|
|
$($enum::$variant(_) => $var_name.edit(),)*
|
|
}}
|
|
</Block>
|
|
}
|
|
}
|
|
|
|
impl Editable for $enum {
|
|
type Edit = [<$enum Edit>];
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
#[derive(PartialEq, Properties)]
|
|
pub struct EditProps<T: PartialEq> {
|
|
pub state: UseStateHandle<T>,
|
|
}
|
|
|
|
pub trait Edit {
|
|
fn edit(&self) -> Html;
|
|
}
|
|
|
|
impl<Comp: Component<Properties = EditProps<Type>>, Type: Editable<Edit = Comp> + PartialEq> Edit
|
|
for UseStateHandle<Type>
|
|
{
|
|
fn edit(&self) -> Html {
|
|
html!(<Comp state={self.clone()} />)
|
|
}
|
|
}
|
|
|
|
pub trait Editable {
|
|
type Edit;
|
|
}
|
|
|
|
#[function_component(InputEdit)]
|
|
pub fn input_edit<T>(props: &EditProps<T>) -> Html
|
|
where
|
|
T: PartialEq + Clone + 'static,
|
|
Binding<String>: From<Binding<T>>,
|
|
{
|
|
let string = props.state.clone();
|
|
|
|
html! {
|
|
<TextInput
|
|
class={"mx-2 appearance-none block bg-gray-700 text-slate-400 border border-gray-600 rounded py-2 px-2 w-50 leading-tight focus:outline-none focus:ring-1 focus:ring-gray-500 focus:border-gray-500"}
|
|
bind={bind!(string)}
|
|
/>
|
|
}
|
|
}
|
|
|
|
impl<T> Editable for T
|
|
where
|
|
T: PartialEq + Clone + 'static,
|
|
Binding<String>: From<Binding<T>>,
|
|
{
|
|
type Edit = InputEdit<T>;
|
|
}
|
|
|
|
#[function_component(Stub)]
|
|
pub fn stub<T: PartialEq>(props: &EditProps<T>) -> Html {
|
|
html! { "stub" }
|
|
}
|
|
|
|
impl Editable for Vec<String> {
|
|
type Edit = Stub<Vec<String>>;
|
|
}
|
|
|
|
impl Editable for HashMap<String, i64> {
|
|
type Edit = Stub<HashMap<String, i64>>;
|
|
}
|
|
|
|
edit_struct!(EventSpec => ("Name: ", name), ("Description: ", description), ("Event type: ", event_type));
|
|
edit_struct!(TestSpec => ("Number of players: ", num_players));
|
|
edit_struct!(TeamGameSpec => );
|
|
edit_struct!(FreeForAllGameSpec => );
|
|
|
|
edit_enum!(EventTypeSpec => selected =>
|
|
0: test = Test: TestSpec,
|
|
1: team_game = TeamGame: TeamGameSpec,
|
|
2: free_for_all_game = FreeForAllGame: FreeForAllGameSpec
|
|
);
|
|
|
|
edit_enum!(FreeForAllGameRanking => selected =>
|
|
0: ranking = Ranking: Vec<String>,
|
|
1: scores = Scores: HashMap<String, i64>,
|
|
);
|
|
|
|
/*
|
|
#[function_component(EventTypeSpecEdit)]
|
|
pub fn event_type_spec_edit(props: &EditProps<EventTypeSpec>) -> Html {
|
|
let state = props.state.clone();
|
|
|
|
link_variants!(selected =>
|
|
0: test = Test: TestSpec,
|
|
1: team_game = TeamGame: TeamGameSpec,
|
|
2: free_for_all_game = FreeForAllGame: FreeForAllGameSpec
|
|
=> state as EventTypeSpec
|
|
);
|
|
|
|
html! {
|
|
<Block title={"EventTypeSpec"}>
|
|
<Select class="" bind={bind!(selected)}>
|
|
<option value="0">{ "Test" }</option>
|
|
<option value="1">{ "TeamGame" }</option>
|
|
<option value="2">{ "FreeForAllGame" }</option>
|
|
</Select>
|
|
{ match &*state {
|
|
EventTypeSpec::Test(_) => test.edit(),
|
|
EventTypeSpec::TeamGame(_) => team_game.edit(),
|
|
EventTypeSpec::FreeForAllGame(_) => free_for_all_game.edit(),
|
|
}}
|
|
</Block>
|
|
}
|
|
}
|
|
|
|
impl Editable for EventTypeSpec {
|
|
type Edit = EventTypeSpecEdit;
|
|
}
|
|
*/
|