hodasemi/ui
1
0
Fork 0
Code Issues 1 Pull requests 1 Projects Releases Wiki Activity Actions

Compare commits

base: hodasemi:b13253ecbced7915d940d16e64a7fed58f812bc4
Branches Tags
hodasemi:master
hodasemi:renovate/quick-xml-0.x
..
compare: hodasemi:070c475dae617862835d79350077ba4eaaf92f97
Branches Tags
hodasemi:renovate/quick-xml-0.x
hodasemi:master

1 commit
b13253ecbc ... 070c475dae

Author SHA1 Message Date
RenovateBot
070c475dae Update Rust crate quick-xml to 0.37.0
Some checks failed
Gavania Merge Build / build (pull_request) Has been cancelled
Details
2025-04-06 09:05:03 +00:00
14 changed files with 211 additions and 191 deletions
Show stats Expand all files Collapse all files

55
src/builder/builder.rs
View file

@ -23,31 +23,31 @@ pub struct GuiBuilder {
}
impl GuiBuilder {
pub fn new(gui_handler: &mut GuiHandler, path: &AssetPath) -> Result<Arc<Self>> {
pub fn new(world: &mut World, path: &AssetPath) -> Result<Arc<Self>> {
let validator = Validator::new(
#[cfg(feature = "audio")]
gui_handler,
world.resources.get::<GuiHandler>(),
path,
)
.with_context(|| format!("validator for {}", path.full_path()))?;
Ok(Arc::new(Self::_new(gui_handler, validator).with_context(
Ok(Arc::new(Self::_new(world, validator).with_context(
|| format!("for file {}", path.full_path()),
)?))
}
pub fn from_str(gui_handler: &mut GuiHandler, s: &str) -> Result<Arc<Self>> {
pub fn from_str(world: &mut World, s: &str) -> Result<Arc<Self>> {
let validator = Validator::from_str(
#[cfg(feature = "audio")]
gui_handler,
world.resources.get::<GuiHandler>(),
s,
)?;
Ok(Arc::new(Self::_new(gui_handler, validator)?))
Ok(Arc::new(Self::_new(world, validator)?))
}
pub fn merge<'a>(
gui_handler: &mut GuiHandler,
world: &mut World,
pathes: impl IntoIterator<Item = &'a AssetPath>,
) -> Result<Arc<Self>> {
let mut me = Self {
@ -62,11 +62,11 @@ impl GuiBuilder {
for path in pathes.into_iter() {
let validator = Validator::new(
#[cfg(feature = "audio")]
gui_handler,
world.resources.get::<GuiHandler>(),
path,
)?;
let builder = Self::_new(gui_handler, validator)
let builder = Self::_new(world, validator)
.with_context(|| format!("for file {}", path.full_path()))?;
me.grids.extend(builder.grids);
@ -86,7 +86,7 @@ impl GuiBuilder {
}
#[inline]
fn _new(gui_handler: &mut GuiHandler, validator: Validator) -> Result<Self> {
fn _new(world: &mut World, validator: Validator) -> Result<Self> {
let root = validator.root();
let mut ids = HashMap::new();
@ -95,8 +95,11 @@ impl GuiBuilder {
let mut grids = Vec::new();
let gui_handler = world.resources.get_mut_unchecked::<GuiHandler>();
for child in &root.children {
let tree = Self::create_tree(
world,
gui_handler,
&mut ids,
child,
@ -179,7 +182,7 @@ impl GuiBuilder {
impl Functionality for GuiBuilder {
fn set_click_callbacks(
&self,
functions: Vec<(&str, Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>)>,
functions: Vec<(&str, Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>)>,
) -> Result<()> {
for (function_name, callback) in functions {
let suffix_less_function_name = handle_function_suffix(function_name);
@ -195,7 +198,7 @@ impl Functionality for GuiBuilder {
&self,
_functions: Vec<(
&str,
Box<dyn Fn(&mut Commands, &dyn Any) -> Result<()> + Send + Sync>,
Box<dyn Fn(&mut World, &dyn Any) -> Result<()> + Send + Sync>,
)>,
) -> Result<()> {
Ok(())
@ -205,7 +208,7 @@ impl Functionality for GuiBuilder {
&self,
callbacks: Vec<(
&str,
Box<dyn Fn(&mut Commands, bool) -> Result<()> + Send + Sync>,
Box<dyn Fn(&mut World, bool) -> Result<()> + Send + Sync>,
)>,
) -> Result<()> {
for (function_name, callback) in callbacks {
@ -222,7 +225,7 @@ impl Functionality for GuiBuilder {
&self,
callbacks: Vec<(
&str,
Box<dyn Fn(&mut Commands, ControllerButton) -> Result<bool> + Send + Sync>,
Box<dyn Fn(&mut World, ControllerButton) -> Result<bool> + Send + Sync>,
)>,
) -> Result<()> {
for (function_name, callback) in callbacks {
@ -342,6 +345,7 @@ impl_element!(MultiLineTextField);
// private
impl GuiBuilder {
fn create_tree(
world: &mut World,
gui_handler: &mut GuiHandler,
ids: &mut HashMap<String, UiElement>,
root_grid_info: &Arc<GridInfo>,
@ -394,6 +398,7 @@ impl GuiBuilder {
for child in root_grid_info.children.read().unwrap().iter() {
Self::create_child(
world,
gui_handler,
child,
&root_grid,
@ -408,6 +413,7 @@ impl GuiBuilder {
}
fn create_child(
world: &mut World,
gui_handler: &mut GuiHandler,
child: &UiInfoElement,
grid: &Grid,
@ -423,7 +429,7 @@ impl GuiBuilder {
Self::insert_id(ids, &button_info.id, &button)?;
grid.attach(
gui_handler,
world,
button.clone(),
button_info
.x_slot
@ -458,7 +464,7 @@ impl GuiBuilder {
Self::insert_id(ids, &label_info.id, &label)?;
grid.attach(
gui_handler,
world,
label.clone(),
label_info.x_slot.get().with_context(|| "x_slot of label")?,
label_info.y_slot.get().with_context(|| "y_slot of label")?,
@ -470,12 +476,12 @@ impl GuiBuilder {
}
UiInfoElement::MultiLineLabel(multi_line_label_info) => {
let multi_line_label =
MultiLineLabel::try_from(multi_line_label_info, gui_handler)?;
MultiLineLabel::try_from(multi_line_label_info, world, gui_handler)?;
GuiBuilder::insert_id(ids, &multi_line_label_info.id, &multi_line_label)?;
grid.attach(
gui_handler,
world,
multi_line_label.clone(),
multi_line_label_info
.x_slot
@ -493,12 +499,12 @@ impl GuiBuilder {
}
UiInfoElement::MultiLineTextField(multi_line_text_field_info) => {
let multi_line_text_field =
MultiLineTextField::try_from(multi_line_text_field_info, gui_handler)?;
MultiLineTextField::try_from(multi_line_text_field_info, world, gui_handler)?;
GuiBuilder::insert_id(ids, &multi_line_text_field_info.id, &multi_line_text_field)?;
grid.attach(
gui_handler,
world,
multi_line_text_field.clone(),
multi_line_text_field_info
.x_slot
@ -520,7 +526,7 @@ impl GuiBuilder {
Self::insert_id(ids, &text_field_info.id, &text_field)?;
grid.attach(
gui_handler,
world,
text_field.clone(),
text_field_info
.x_slot
@ -542,7 +548,7 @@ impl GuiBuilder {
Self::insert_id(ids, &icon_info.id, UiElement::Icon(Arc::downgrade(&icon)))?;
grid.attach(
gui_handler,
world,
icon.clone(),
icon_info.x_slot.get().with_context(|| "x_slot of icon")?,
icon_info.y_slot.get().with_context(|| "y_slot of icon")?,
@ -558,7 +564,7 @@ impl GuiBuilder {
Self::insert_id(ids, &progress_bar_info.id, &progress_bar)?;
grid.attach(
gui_handler,
world,
progress_bar.clone(),
progress_bar_info
.x_slot
@ -580,7 +586,7 @@ impl GuiBuilder {
Self::insert_id(ids, &grid_info.id, &sub_grid)?;
grid.attach(
gui_handler,
world,
sub_grid.clone(),
grid_info.x_slot.get().with_context(|| "x_slot of grid")?,
grid_info.y_slot.get().with_context(|| "y_slot of grid")?,
@ -593,6 +599,7 @@ impl GuiBuilder {
for child in grid_info.children.read().unwrap().iter() {
Self::create_child(
world,
gui_handler,
child,
&sub_grid,

48
src/builder/snippet.rs
View file

@ -18,27 +18,27 @@ pub struct GuiSnippet {
}
impl GuiSnippet {
pub fn new(gui_handler: &mut GuiHandler, path: &AssetPath) -> Result<Arc<Self>> {
pub fn new(world: &mut World, path: &AssetPath) -> Result<Arc<Self>> {
let validator = Validator::new(
#[cfg(feature = "audio")]
gui_handler,
world.resources.get::<GuiHandler>(),
path,
)?;
Self::_new(gui_handler, validator)
Self::_new(world, validator)
}
pub fn from_str(gui_handler: &mut GuiHandler, s: &str) -> Result<Arc<Self>> {
pub fn from_str(world: &mut World, s: &str) -> Result<Arc<Self>> {
let validator = Validator::from_str(
#[cfg(feature = "audio")]
gui_handler,
world.resources.get::<GuiHandler>(),
s,
)?;
Self::_new(gui_handler, validator)
Self::_new(world, validator)
}
fn _new(gui_handler: &mut GuiHandler, validator: Validator) -> Result<Arc<Self>> {
fn _new(world: &mut World, validator: Validator) -> Result<Arc<Self>> {
let root = validator.root();
let mut ids = HashMap::new();
@ -51,13 +51,22 @@ impl GuiSnippet {
)));
}
let gui_handler = world.resources.get_mut_unchecked::<GuiHandler>();
let grid_info = &root.children[0];
let grid = Grid::try_from(gui_handler, grid_info, false)?;
GuiBuilder::insert_id(&mut ids, &grid_info.id, &grid)?;
for child in grid_info.children.read().unwrap().iter() {
Self::create_child(gui_handler, child, &grid, &mut ids, &mut custom_neighbours)?;
Self::create_child(
world,
gui_handler,
child,
&grid,
&mut ids,
&mut custom_neighbours,
)?;
}
GuiBuilder::connect_custom_neighbours(&ids, custom_neighbours)?;
@ -207,6 +216,7 @@ impl Functionality for GuiSnippet {
impl GuiSnippet {
fn create_child(
world: &mut World,
gui_handler: &mut GuiHandler,
child: &UiInfoElement,
grid: &Grid,
@ -220,7 +230,7 @@ impl GuiSnippet {
GuiBuilder::insert_id(ids, &button_info.id, &button)?;
grid.attach(
gui_handler,
world,
button.clone(),
button_info.x_slot.get()?,
button_info.y_slot.get()?,
@ -236,7 +246,7 @@ impl GuiSnippet {
GuiBuilder::insert_id(ids, &label_info.id, &label)?;
grid.attach(
gui_handler,
world,
label,
label_info.x_slot.get()?,
label_info.y_slot.get()?,
@ -246,12 +256,12 @@ impl GuiSnippet {
}
UiInfoElement::MultiLineLabel(multi_line_label_info) => {
let multi_line_label =
MultiLineLabel::try_from(multi_line_label_info, gui_handler)?;
MultiLineLabel::try_from(multi_line_label_info, world, gui_handler)?;
GuiBuilder::insert_id(ids, &multi_line_label_info.id, &multi_line_label)?;
grid.attach(
gui_handler,
world,
multi_line_label,
multi_line_label_info.x_slot.get()?,
multi_line_label_info.y_slot.get()?,
@ -261,12 +271,12 @@ impl GuiSnippet {
}
UiInfoElement::MultiLineTextField(multi_line_text_field_info) => {
let multi_line_text_field =
MultiLineTextField::try_from(multi_line_text_field_info, gui_handler)?;
MultiLineTextField::try_from(multi_line_text_field_info, world, gui_handler)?;
GuiBuilder::insert_id(ids, &multi_line_text_field_info.id, &multi_line_text_field)?;
grid.attach(
gui_handler,
world,
multi_line_text_field,
multi_line_text_field_info.x_slot.get()?,
multi_line_text_field_info.y_slot.get()?,
@ -280,7 +290,7 @@ impl GuiSnippet {
GuiBuilder::insert_id(ids, &text_field_info.id, &text_field)?;
grid.attach(
gui_handler,
world,
text_field,
text_field_info.x_slot.get()?,
text_field_info.y_slot.get()?,
@ -294,7 +304,7 @@ impl GuiSnippet {
GuiBuilder::insert_id(ids, &icon_info.id, UiElement::Icon(Arc::downgrade(&icon)))?;
grid.attach(
gui_handler,
world,
icon,
icon_info.x_slot.get()?,
icon_info.y_slot.get()?,
@ -308,7 +318,7 @@ impl GuiSnippet {
GuiBuilder::insert_id(ids, &progress_bar_info.id, &progress_bar)?;
grid.attach(
gui_handler,
world,
progress_bar,
progress_bar_info.x_slot.get()?,
progress_bar_info.y_slot.get()?,
@ -322,7 +332,7 @@ impl GuiSnippet {
GuiBuilder::insert_id(ids, &grid_info.id, &sub_grid)?;
grid.attach(
gui_handler,
world,
sub_grid.clone(),
grid_info.x_slot.get()?,
grid_info.y_slot.get()?,
@ -331,7 +341,7 @@ impl GuiSnippet {
)?;
for child in grid_info.children.read().unwrap().iter() {
Self::create_child(gui_handler, child, &sub_grid, ids, neighbour_infos)?;
Self::create_child(world, gui_handler, child, &sub_grid, ids, neighbour_infos)?;
}
}
}

16
src/elements/button.rs
View file

@ -315,23 +315,23 @@ impl Button {
pub fn set_callback<F>(&self, callback: F)
where
F: Fn(&mut Commands) -> Result<()> + Send + Sync + 'static,
F: Fn(&mut World) -> Result<()> + Send + Sync + 'static,
{
self.click_executable
.set_callback(move |commands: &mut Commands, _: ()| callback(commands));
.set_callback(move |world: &mut World, _: ()| callback(world));
}
pub fn set_select_callback<F>(&self, callback: F)
where
F: Fn(&mut Commands, bool) -> Result<()> + Send + Sync + 'static,
F: Fn(&mut World, bool) -> Result<()> + Send + Sync + 'static,
{
self.on_select_executable
.set_callback(move |commands: &mut Commands, select: bool| callback(commands, select));
.set_callback(move |world: &mut World, select: bool| callback(world, select));
}
pub fn set_custom_callback<F>(&self, callback: F)
where
F: Fn(&mut Commands, ControllerButton) -> Result<bool> + Send + Sync + 'static,
F: Fn(&mut World, ControllerButton) -> Result<bool> + Send + Sync + 'static,
{
self.selectable.set_custom_callback(callback);
}
@ -448,8 +448,10 @@ impl Visibility for Button {
self.visible.load(SeqCst)
}
fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
if visibility != self.visible.load(SeqCst) {
let gui_handler: &mut GuiHandler = world.resources.get_mut()?;
self.visible.store(visibility, SeqCst);
if visibility {
@ -579,7 +581,7 @@ impl Button {
fn create_selected_changed_callback(button: Arc<Button>) {
let button_weak = Arc::downgrade(&button);
let selected_changed = move |commands: &mut Commands, selected: bool| {
let selected_changed = move |world: &mut World, selected: bool| {
if let Some(button) = button_weak.upgrade() {
let gui_handler = world.resources.get_mut()?;

44
src/elements/grid.rs
View file

@ -1,5 +1,6 @@
use crate::prelude::*;
use anyhow::Result;
use ecs::*;
use crate::builder::validator::gridinfo::GridInfo;
@ -199,7 +200,7 @@ impl Grid {
pub fn detach(
&self,
gui_handler: &mut GuiHandler,
world: &mut World,
pos_x: usize,
pos_y: usize,
) -> Result<Option<Arc<dyn GuiElementTraits>>> {
@ -231,7 +232,7 @@ impl Grid {
Some((child, _x, _y)) => {
if self.visible() {
if let Some(child_visibility) = child.visibility() {
child_visibility.set_visibility(gui_handler, false)?;
child_visibility.set_visibility(world, false)?;
}
}
@ -242,11 +243,7 @@ impl Grid {
}
/// Returns `true` if item got detached
pub fn detach_item(
&self,
gui_handler: &mut GuiHandler,
item: Arc<dyn GuiElementTraits>,
) -> Result<bool> {
pub fn detach_item(&self, world: &mut World, item: Arc<dyn GuiElementTraits>) -> Result<bool> {
let mut grid = self.children.write().unwrap();
let mut removed = false;
@ -265,7 +262,7 @@ impl Grid {
if self.visible() {
if let Some(child_visibility) = child.visibility() {
child_visibility.set_visibility(gui_handler, false)?;
child_visibility.set_visibility(world, false)?;
}
}
}
@ -408,7 +405,7 @@ impl Grid {
pub fn attach(
&self,
gui_handler: &mut GuiHandler,
world: &mut World,
child: Arc<dyn GuiElementTraits>,
pos_x: usize,
pos_y: usize,
@ -447,7 +444,14 @@ impl Grid {
}
if self.framable.is_framed() {
self.child_position(gui_handler, child_gridable, pos_x, pos_y, dim_x, dim_y)?;
self.child_position(
world.resources.get_mut()?,
child_gridable,
pos_x,
pos_y,
dim_x,
dim_y,
)?;
}
child_gridable.set_layer(self.framable.ui_layer())?;
@ -458,7 +462,7 @@ impl Grid {
ChildState::Some { child, .. } => {
if self.visible() {
if let Some(child_visibility) = child.visibility() {
child_visibility.set_visibility(gui_handler, false)?;
child_visibility.set_visibility(world, false)?;
}
}
}
@ -468,7 +472,7 @@ impl Grid {
if self.visible() {
if let Some(child_visibility) = child.visibility() {
child_visibility.set_visibility(gui_handler, true)?;
child_visibility.set_visibility(world, true)?;
}
}
@ -622,26 +626,26 @@ impl Grid {
}
}
fn disable_tree(&self, gui_handler: &mut GuiHandler) -> Result<()> {
fn disable_tree(&self, world: &mut World, gui_handler: &mut GuiHandler) -> Result<()> {
self.framable.delete(gui_handler)?;
if let Some(background) = self.background.read().unwrap().as_ref() {
background.disable(gui_handler)?;
}
self.set_tree_visibility(gui_handler, false)?;
self.set_tree_visibility(world, false)?;
Ok(())
}
fn set_tree_visibility(&self, gui_handler: &mut GuiHandler, visible: bool) -> Result<()> {
fn set_tree_visibility(&self, world: &mut World, visible: bool) -> Result<()> {
let tree = self.children.read().unwrap();
for row in tree.deref() {
for child_state in row {
if let Some((child, ..)) = child_state.get_some() {
if let Some(visibility) = child.visibility() {
visibility.set_visibility(gui_handler, visible)?;
visibility.set_visibility(world, visible)?;
}
}
}
@ -793,8 +797,10 @@ impl Visibility for Grid {
self.visible.load(SeqCst)
}
fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()> {
fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()> {
if visibility != self.visible.load(SeqCst) {
let gui_handler = world.resources.get_mut_unchecked::<GuiHandler>();
self.visible.store(visibility, SeqCst);
if visibility {
@ -804,9 +810,9 @@ impl Visibility for Grid {
background.enable(gui_handler)?;
}
self.set_tree_visibility(gui_handler, true)?;
self.set_tree_visibility(world, true)?;
} else {
self.disable_tree(gui_handler)?;
self.disable_tree(world, gui_handler)?;
}
}

11
src/elements/multi_line_label.rs
View file

@ -57,7 +57,11 @@ impl MultiLineLabelBuilder {
self
}
pub fn build(self, gui_handler: &mut GuiHandler) -> Result<Arc<MultiLineLabel>> {
pub fn build(
self,
world: &mut World,
gui_handler: &mut GuiHandler,
) -> Result<Arc<MultiLineLabel>> {
let base_grid = Grid::new(gui_handler, 1, self.line_count as usize, false)?;
base_grid.set_margin(0);
base_grid.set_padding(0);
@ -73,7 +77,7 @@ impl MultiLineLabelBuilder {
.set_text_alignment(self.text_alignment)
.build(gui_handler)?;
base_grid.attach(gui_handler, label, 0, i as usize, 1, 1)?;
base_grid.attach(world, label, 0, i as usize, 1, 1)?;
}
Ok(Arc::new(MultiLineLabel {
@ -185,6 +189,7 @@ impl MultiLineLabel {
pub fn try_from(
multi_line_label_info: &MultiLineLabelInfo,
world: &mut World,
gui_handler: &mut GuiHandler,
) -> Result<Arc<Self>> {
let text = multi_line_label_info.text.read().unwrap().clone();
@ -213,7 +218,7 @@ impl MultiLineLabel {
multi_line_label_builder = multi_line_label_builder.set_text(text);
}
multi_line_label_builder.build(gui_handler)
multi_line_label_builder.build(world, gui_handler)
}
fn iter_label<F>(&self, mut f: F) -> Result<()>

13
src/elements/multi_line_textfield.rs
View file

@ -63,7 +63,11 @@ impl MultiLineTextFieldBuilder {
self
}
pub fn build(self, gui_handler: &mut GuiHandler) -> Result<Arc<MultiLineTextField>> {
pub fn build(
self,
world: &mut World,
gui_handler: &mut GuiHandler,
) -> Result<Arc<MultiLineTextField>> {
let base_grid = Grid::new(gui_handler, 1, self.line_count as usize, false)?;
base_grid.set_margin(0);
base_grid.set_padding(0);
@ -79,7 +83,7 @@ impl MultiLineTextFieldBuilder {
.set_text_alignment(self.text_alignment)
.build(gui_handler)?;
base_grid.attach(gui_handler, label, 0, i as usize, 1, 1)?;
base_grid.attach(world, label, 0, i as usize, 1, 1)?;
}
let text = Arc::new(SplittedText::new(self.text));
@ -97,7 +101,7 @@ impl MultiLineTextFieldBuilder {
multi_line_text_field.text_changed_exec.set_callback({
let weak_tf = Arc::downgrade(&multi_line_text_field);
move |commands: &mut Commands, _text| {
move |world: &mut World, _text| {
if let Some(tf) = weak_tf.upgrade() {
tf.update_text(world.resources.get_mut()?)?;
}
@ -305,6 +309,7 @@ impl MultiLineTextField {
pub fn try_from(
multi_line_text_field_info: &MultiLineTextFieldInfo,
world: &mut World,
gui_handler: &mut GuiHandler,
) -> Result<Arc<Self>> {
let text = multi_line_text_field_info.text.read().unwrap().clone();
@ -333,7 +338,7 @@ impl MultiLineTextField {
multi_line_text_field_builder = multi_line_text_field_builder.set_text(text);
}
multi_line_text_field_builder.build(gui_handler)
multi_line_text_field_builder.build(world, gui_handler)
}
fn iter_label<F>(&self, mut f: F) -> Result<()>

2
src/elements/textfield.rs
View file

@ -170,7 +170,7 @@ impl TextField {
pub fn set_text_changed_callback<F>(&self, f: F)
where
F: Fn(&mut Commands, Option<String>) -> Result<()> + Send + Sync + 'static,
F: Fn(&mut World, Option<String>) -> Result<()> + Send + Sync + 'static,
{
self.text_changed_executable.set_callback(f);
}

16
src/elements/traits.rs
View file

@ -1,6 +1,6 @@
use crate::prelude::*;
use anyhow::Result;
use ecs::*;
use ecs::World;
use std::{any::Any, collections::HashMap, sync::Arc};
@ -10,8 +10,8 @@ pub trait TopLevelGui: Send + Sync {
fn top_gui(&self) -> Option<&dyn TopGui>;
fn elements(&self) -> Option<&HashMap<String, UiElement>>;
fn functionality(&self) -> Option<&dyn Functionality>;
fn enable(&self, commands: &mut Commands) -> Result<()>;
fn disable(&self, commands: &mut Commands) -> Result<()>;
fn enable(&self, world: &mut World) -> Result<()>;
fn disable(&self, world: &mut World) -> Result<()>;
}
pub fn any_to<T>(any: &dyn Any) -> Result<&T>
@ -27,14 +27,14 @@ where
pub trait Functionality {
fn set_click_callbacks(
&self,
callbacks: Vec<(&str, Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>)>,
callbacks: Vec<(&str, Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>)>,
) -> Result<()>;
fn set_select_callbacks(
&self,
callbacks: Vec<(
&str,
Box<dyn Fn(&mut Commands, bool) -> Result<()> + Send + Sync>,
Box<dyn Fn(&mut World, bool) -> Result<()> + Send + Sync>,
)>,
) -> Result<()>;
@ -42,7 +42,7 @@ pub trait Functionality {
&self,
callbacks: Vec<(
&str,
Box<dyn Fn(&mut Commands, ControllerButton) -> Result<bool> + Send + Sync>,
Box<dyn Fn(&mut World, ControllerButton) -> Result<bool> + Send + Sync>,
)>,
) -> Result<()>;
@ -50,7 +50,7 @@ pub trait Functionality {
&self,
callbacks: Vec<(
&str,
Box<dyn Fn(&mut Commands, &dyn Any) -> Result<()> + Send + Sync>,
Box<dyn Fn(&mut World, &dyn Any) -> Result<()> + Send + Sync>,
)>,
) -> Result<()>;
}
@ -84,7 +84,7 @@ pub trait Gridable {
pub trait Visibility {
fn visible(&self) -> bool;
fn set_visibility(&self, gui_handler: &mut GuiHandler, visibility: bool) -> Result<()>;
fn set_visibility(&self, world: &mut World, visibility: bool) -> Result<()>;
}
pub enum GuiElement<'a> {

8
src/gui_handler/gui/executable.rs
View file

@ -1,7 +1,7 @@
//! `Executable` is a property to execute a closure
use anyhow::Result;
use ecs::*;
use ecs::World;
use std::sync::{Arc, RwLock};
@ -9,7 +9,7 @@ use crate::prelude::*;
/// `Executable` holds a closure which can be executed
pub struct Executable<I: Send + Sync> {
callback: RwLock<Option<Arc<dyn Fn(&mut Commands, I) -> Result<()> + Send + Sync>>>,
callback: RwLock<Option<Arc<dyn Fn(&mut World, I) -> Result<()> + Send + Sync>>>,
}
impl<I: Send + Sync + 'static> Executable<I> {
@ -27,7 +27,7 @@ impl<I: Send + Sync + 'static> Executable<I> {
/// * `callback` is a `Option<Callback>` closure
pub fn set_callback<F>(&self, callback: impl Into<Option<F>>)
where
F: Fn(&mut Commands, I) -> Result<()> + Send + Sync + 'static,
F: Fn(&mut World, I) -> Result<()> + Send + Sync + 'static,
{
let mut function = self.callback.write().unwrap();
@ -42,7 +42,7 @@ impl<I: Send + Sync + 'static> Executable<I> {
if let Some(callback) = self.callback.read().unwrap().as_ref() {
let callback = callback.clone();
gui_handler.add_callback(move |commands| (callback)(commands, input));
gui_handler.add_callback(move |gui_handler| (callback)(gui_handler, input));
}
Ok(())

10
src/gui_handler/gui/selectable.rs
View file

@ -3,7 +3,7 @@
use super::executable::Executable;
use crate::prelude::*;
use anyhow::Result;
use ecs::*;
use ecs::World;
use std::sync::{
Arc, RwLock, Weak,
@ -41,7 +41,7 @@ pub struct Selectable {
// used for custom buttons
custom_callback:
RwLock<Option<Box<dyn Fn(&mut Commands, ControllerButton) -> Result<bool> + Send + Sync>>>,
RwLock<Option<Box<dyn Fn(&mut World, ControllerButton) -> Result<bool> + Send + Sync>>>,
}
impl Selectable {
@ -117,7 +117,7 @@ impl Selectable {
pub fn set_custom_callback<F>(&self, custom_callback: F)
where
F: Fn(&mut Commands, ControllerButton) -> Result<bool> + Send + Sync + 'static,
F: Fn(&mut World, ControllerButton) -> Result<bool> + Send + Sync + 'static,
{
*self.custom_callback.write().unwrap() = Some(Box::new(custom_callback));
}
@ -180,11 +180,11 @@ impl Selectable {
pub(crate) fn custom_click_event(
&self,
commands: &mut Commands,
world: &mut World,
button: ControllerButton,
) -> Result<bool> {
if let Some(custom_callback) = self.custom_callback.read().unwrap().as_ref() {
if custom_callback(commands, button)? {
if custom_callback(world, button)? {
#[cfg(feature = "audio")]
{
if let Some(audible) = self.click_audible.read().unwrap().as_ref() {

8
src/gui_handler/gui/topgui.rs
View file

@ -1,20 +1,20 @@
/// A trait that is used by the gui handler as the target for input
use anyhow::Result;
use ecs::Commands;
use ecs::World;
pub trait TopGui: Send + Sync {
/// Decline method which is executed on `InputMap::B` press
fn decline(&self, commands: &mut Commands) -> Result<()>;
fn decline(&self, world: &mut World) -> Result<()>;
/// Method which is executed on `InputMap::RightButton` press
///
/// # Arguments
/// * `second_level` adds support for multiple tab layers, e.g. RB and RT press on controller
fn next_tab(&self, commands: &mut Commands, second_level: bool) -> Result<()>;
fn next_tab(&self, world: &mut World, second_level: bool) -> Result<()>;
/// Method which is executed on `InputMap::LeftButton` press
/// ///
/// # Arguments
/// * `second_level` adds support for multiple tab layers, e.g. RB and RT press on controller
fn previous_tab(&self, commands: &mut Commands, second_level: bool) -> Result<()>;
fn previous_tab(&self, world: &mut World, second_level: bool) -> Result<()>;
}

22
src/gui_handler/gui_handler.rs
View file

@ -2,7 +2,7 @@ use crate::prelude::*;
use anyhow::{Result, anyhow};
use assetpath::AssetPath;
use ecs::*;
use ecs::{Resource, World};
use serde::{Deserialize, Serialize};
use utilities::{impl_reprc, prelude::*};
use vulkan_rs::{prelude::*, render_target::sub_pass::InputAttachmentInfo};
@ -245,7 +245,7 @@ pub struct GuiHandler {
text_sample_count: VkSampleCountFlags,
callback_list: Vec<Box<dyn FnOnce(&mut Commands) -> Result<()> + Send + Sync>>,
callback_list: Vec<Box<dyn FnOnce(&mut World) -> Result<()> + Send + Sync>>,
}
impl GuiHandler {
@ -866,17 +866,17 @@ impl GuiHandler {
pub fn set_top_gui(
&mut self,
commands: &mut Commands,
world: &mut World,
top_gui: Option<Arc<dyn TopLevelGui>>,
) -> Result<()> {
match (&self.top_ui, &top_gui) {
(Some(current), Some(incoming)) => {
if !Arc::ptr_eq(current, incoming) {
current.disable(commands)?;
current.disable(world)?;
}
}
(Some(current), None) => {
current.disable(commands)?;
current.disable(world)?;
}
_ => (),
@ -889,17 +889,17 @@ impl GuiHandler {
pub fn set_tooltip(
&mut self,
commands: &mut Commands,
world: &mut World,
tooltip: Option<Arc<dyn TopLevelGui>>,
) -> Result<()> {
match (&self.tooltip_ui, &tooltip) {
(Some(current), Some(incoming)) => {
if !Arc::ptr_eq(current, incoming) {
current.disable(commands)?;
current.disable(world)?;
}
}
(Some(current), None) => {
current.disable(commands)?;
current.disable(world)?;
}
_ => (),
@ -910,19 +910,19 @@ impl GuiHandler {
Ok(())
}
pub(crate) fn add_callback<F: FnOnce(&mut Commands) -> Result<()> + Send + Sync + 'static>(
pub(crate) fn add_callback<F: FnOnce(&mut World) -> Result<()> + Send + Sync + 'static>(
&mut self,
f: F,
) {
self.callback_list.push(Box::new(f));
}
pub fn process_callbacks(&mut self, commands: &mut Commands) -> Result<()> {
pub fn process_callbacks(&mut self, world: &mut World) -> Result<()> {
let callbacks = mem::take(&mut self.callback_list);
callbacks
.into_iter()
.try_for_each(|callback| callback(commands))
.try_for_each(|callback| callback(world))
}
fn render(

57
src/state.rs
View file

@ -1,6 +1,6 @@
use crate::prelude::*;
use anyhow::{Result, anyhow};
use ecs::*;
use ecs::World;
use std::collections::HashMap;
use std::sync::{Arc, RwLock, Weak};
@ -100,23 +100,22 @@ pub(crate) struct State {
pub(crate) top_level_gui: Arc<dyn TopLevelGui>,
pub(crate) on_activate: RwLock<Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>>,
pub(crate) on_deactivate:
RwLock<Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>>,
pub(crate) on_activate: RwLock<Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>>,
pub(crate) on_deactivate: RwLock<Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>>,
pub(crate) next_tab: RwLock<Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>>,
pub(crate) previous_tab: RwLock<Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>>,
pub(crate) decline: RwLock<Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>>,
pub(crate) next_tab: RwLock<Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>>,
pub(crate) previous_tab: RwLock<Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>>,
pub(crate) decline: RwLock<Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>>,
}
impl State {
pub(crate) fn new<'a>(
gui_handler: &mut GuiHandler,
world: &mut World,
name: &str,
creation_type: CreationType<'a>,
) -> Result<Arc<Self>> {
let gui = match creation_type {
CreationType::File(path) => GuiBuilder::new(gui_handler, path)?,
CreationType::File(path) => GuiBuilder::new(world, path)?,
CreationType::TopGui(top_gui) => top_gui,
};
@ -180,49 +179,49 @@ impl State {
pub(crate) fn set_on_activate(
&self,
on_activate: Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>,
on_activate: Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>,
) {
*self.on_activate.write().unwrap() = on_activate;
}
pub(crate) fn set_on_deactivate(
&self,
on_deactivate: Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>,
on_deactivate: Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>,
) {
*self.on_deactivate.write().unwrap() = on_deactivate;
}
pub(crate) fn set_previous_tab(
&self,
previous_tab: Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>,
previous_tab: Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>,
) {
*self.previous_tab.write().unwrap() = previous_tab;
}
pub(crate) fn set_next_tab(
&self,
next_tab: Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>,
next_tab: Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>,
) {
*self.next_tab.write().unwrap() = next_tab;
}
pub(crate) fn set_decline(
&self,
decline: Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>,
decline: Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>,
) {
*self.decline.write().unwrap() = decline;
}
}
impl TopGui for State {
fn decline(&self, commands: &mut Commands) -> Result<()> {
fn decline(&self, world: &mut World) -> Result<()> {
match self.decline.read().unwrap().as_ref() {
Some(decline) => {
(decline)(commands)?;
(decline)(world)?;
}
None => {
if let Some(top_gui) = self.top_level_gui.top_gui() {
top_gui.decline(commands)?;
top_gui.decline(world)?;
}
}
}
@ -230,14 +229,14 @@ impl TopGui for State {
Ok(())
}
fn next_tab(&self, commands: &mut Commands, second_level: bool) -> Result<()> {
fn next_tab(&self, world: &mut World, second_level: bool) -> Result<()> {
match self.next_tab.read().unwrap().as_ref() {
Some(next_tab) => {
(next_tab)(commands)?;
(next_tab)(world)?;
}
None => {
if let Some(top_gui) = self.top_level_gui.top_gui() {
top_gui.next_tab(commands, second_level)?;
top_gui.next_tab(world, second_level)?;
}
}
}
@ -245,14 +244,14 @@ impl TopGui for State {
Ok(())
}
fn previous_tab(&self, commands: &mut Commands, second_level: bool) -> Result<()> {
fn previous_tab(&self, world: &mut World, second_level: bool) -> Result<()> {
match self.previous_tab.read().unwrap().as_ref() {
Some(previous_tab) => {
(previous_tab)(commands)?;
(previous_tab)(world)?;
}
None => {
if let Some(top_gui) = self.top_level_gui.top_gui() {
top_gui.previous_tab(commands, second_level)?;
top_gui.previous_tab(world, second_level)?;
}
}
}
@ -278,21 +277,21 @@ impl TopLevelGui for State {
self.top_level_gui.functionality()
}
fn enable(&self, commands: &mut Commands) -> Result<()> {
self.top_level_gui.enable(commands)?;
fn enable(&self, world: &mut World) -> Result<()> {
self.top_level_gui.enable(world)?;
if let Some(activate) = self.on_activate.read().unwrap().as_ref() {
(activate)(commands)?;
(activate)(world)?;
}
Ok(())
}
fn disable(&self, commands: &mut Commands) -> Result<()> {
self.top_level_gui.disable(commands)?;
fn disable(&self, world: &mut World) -> Result<()> {
self.top_level_gui.disable(world)?;
if let Some(deactivate) = self.on_deactivate.read().unwrap().as_ref() {
(deactivate)(commands)?;
(deactivate)(world)?;
}
Ok(())

74
src/states.rs
View file

@ -7,14 +7,12 @@ use std::collections::HashMap;
use std::sync::{Arc, Mutex};
pub trait FutureStateChange:
Fn(&mut Commands, &mut GuiHandler) -> Result<()> + Send + Sync
{
pub trait FutureStateChange: Fn(&mut World) -> Result<()> + Send + Sync {
fn clone_box<'a>(&self) -> Box<dyn 'a + FutureStateChange>
where
Self: 'a;
fn as_fn(&self) -> &(dyn Fn(&mut Commands, &mut GuiHandler) -> Result<()> + Send + Sync)
fn as_fn(&self) -> &(dyn Fn(&mut World) -> Result<()> + Send + Sync)
where
Self: Sized,
{
@ -23,7 +21,7 @@ pub trait FutureStateChange:
fn as_static(
&'static self,
) -> &'static (dyn Fn(&mut Commands, &mut GuiHandler) -> Result<()> + Send + Sync + 'static)
) -> &'static (dyn Fn(&mut World) -> Result<()> + Send + Sync + 'static)
where
Self: Sized,
{
@ -31,9 +29,7 @@ pub trait FutureStateChange:
}
}
impl<F: Fn(&mut Commands, &mut GuiHandler) -> Result<()> + Clone + Send + Sync> FutureStateChange
for F
{
impl<F: Fn(&mut World) -> Result<()> + Clone + Send + Sync> FutureStateChange for F {
fn clone_box<'a>(&self) -> Box<dyn 'a + FutureStateChange>
where
Self: 'a,
@ -51,27 +47,22 @@ impl<'a> Clone for Box<dyn 'a + FutureStateChange> {
/// Update type
pub enum StateUpdateType<'a> {
/// Updates the callback which is executed on next tab event
NextTab(Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>),
NextTab(Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>),
/// Updates the callback which is executed on previous tab event
PreviousTab(Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>),
PreviousTab(Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>),
/// Updates the callback which is executed on decline event
Decline(Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>),
Decline(Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>),
/// Updates callbacks by identifier
ClickCallbacks(
Vec<(
&'a str,
Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>,
)>,
),
ClickCallbacks(Vec<(&'a str, Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>)>),
/// Updates callbacks by identifier
SelectCallbacks(
Vec<(
&'a str,
Box<dyn Fn(&mut Commands, bool) -> Result<()> + Send + Sync>,
Box<dyn Fn(&mut World, bool) -> Result<()> + Send + Sync>,
)>,
),
@ -79,7 +70,7 @@ pub enum StateUpdateType<'a> {
CustomClickCallbacks(
Vec<(
&'a str,
Box<dyn Fn(&mut Commands, ControllerButton) -> Result<bool> + Send + Sync>,
Box<dyn Fn(&mut World, ControllerButton) -> Result<bool> + Send + Sync>,
)>,
),
@ -87,15 +78,15 @@ pub enum StateUpdateType<'a> {
VecCallbacks(
Vec<(
&'a str,
Box<dyn Fn(&mut Commands, &dyn Any) -> Result<()> + Send + Sync>,
Box<dyn Fn(&mut World, &dyn Any) -> Result<()> + Send + Sync>,
)>,
),
/// Updates the callback which is executed when this state gets activated on state change
OnActivate(Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>),
OnActivate(Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>),
/// Updates the callback which is executed when this state gets deactivated on state change
OnDeactivate(Option<Box<dyn Fn(&mut Commands) -> Result<()> + Send + Sync>>),
OnDeactivate(Option<Box<dyn Fn(&mut World) -> Result<()> + Send + Sync>>),
}
/// Type of the state to be created
@ -166,14 +157,12 @@ impl States {
/// Adds a single state
pub fn add_state<'a>(
&mut self,
gui_handler: &mut GuiHandler,
world: &mut World,
id: &str,
creation_type: impl Into<CreationType<'a>>,
) -> Result<()> {
self.states.insert(
id.to_string(),
State::new(gui_handler, id, creation_type.into())?,
);
self.states
.insert(id.to_string(), State::new(world, id, creation_type.into())?);
Ok(())
}
@ -191,16 +180,13 @@ impl States {
/// # Arguments
///
/// * `id` - Set state with the given identifier or None
pub fn set_state<'b>(
&self,
commands: &mut Commands,
gui_handler: &mut GuiHandler,
id: impl Into<Option<&'b str>>,
) -> Result<()> {
pub fn set_state<'b>(&self, world: &mut World, id: impl Into<Option<&'b str>>) -> Result<()> {
let gui_handler: &mut GuiHandler = world.resources.get_mut_unchecked();
Self::_set_state(
id.into().map(|id| self.get_state(id)).transpose()?,
&mut *self.current_state.lock().unwrap(),
commands,
world,
gui_handler,
self.log_state_change,
)
@ -209,7 +195,7 @@ impl States {
fn _set_state(
state: Option<Arc<State>>,
current: &mut Option<Arc<State>>,
commands: &mut Commands,
world: &mut World,
gui_handler: &mut GuiHandler,
logging: bool,
) -> Result<()> {
@ -222,14 +208,14 @@ impl States {
}
// execute deactivate on old state
old_state.disable(commands)?;
old_state.disable(world)?;
}
// set new state, either no state or requested state
match state {
Some(state) => {
state.enable(commands)?;
gui_handler.set_top_gui(commands, Some(state.clone()))?;
state.enable(world)?;
gui_handler.set_top_gui(world, Some(state.clone()))?;
if logging {
println!("Change UI State to {}", state.name);
@ -238,7 +224,7 @@ impl States {
*current = Some(state);
}
None => {
gui_handler.set_top_gui(commands, None)?;
gui_handler.set_top_gui(world, None)?;
if logging {
println!("Change UI State to None");
@ -272,20 +258,20 @@ impl States {
let weak_current_state = Arc::downgrade(&self.current_state);
let logging = self.log_state_change;
Ok(Box::new(
move |commands: &mut Commands, gui_handler: &mut GuiHandler| {
Ok(Box::new(move |world: &mut World| {
if let Some(current) = weak_current_state.upgrade() {
let gui_handler: &mut GuiHandler = world.resources.get_mut_unchecked();
Self::_set_state(
weak_state.as_ref().map(|w| w.upgrade()).flatten(),
&mut *current.lock().unwrap(),
commands,
world,
gui_handler,
logging,
)?;
}
Ok(())
},
))
}))
}
}