fix bugs and docs

Author: optozorax

egui/src/any/any_map.rs

@@ -2,7 +2,7 @@ use crate::any::element::{AnyMapElement, AnyMapTrait};
 use std::any::TypeId;
 use std::collections::HashMap;
 
-/// Stores object with any type.
+/// Stores object of any type.
 #[derive(Clone, Debug, Default)]
 pub struct AnyMap(HashMap<TypeId, AnyMapElement>);
 

egui/src/any/id_map.rs

@@ -71,7 +71,7 @@ impl AnyMapId {
 
     pub fn reset<T: AnyMapTrait>(&mut self) {
         let id = TypeId::of::<T>();
-        self.0.retain(|_, v| v.type_id() == id);
+        self.0.retain(|_, v| v.type_id() != id);
     }
 
     pub fn reset_all(&mut self) {

egui/src/any/mod.rs

@@ -1,47 +1,51 @@
-//! Any type storages for [`crate::Memory`].
+//! Any-type storages for [`Memory`].
 //!
-//! This module contains structs to store arbitrary type using [`std::any::Any`] trait. Also, they can be cloned, and structs in [`serializable`] can be de/serialized.
+//! This module contains structs to store arbitrary types using [`Any`] trait. Also, they can be cloned, and structs in [`serializable`] can be de/serialized.
 //!
-//! Basically, all this is just `HashMap<TypeId, Box<dyn Any + static>>` and `HashMap<Id, Box<dyn Any + static>>`, but with helper functions and hacks for cloning and de/serialization.
+//! All this is just `HashMap<TypeId, Box<dyn Any + static>>` and `HashMap<Id, Box<dyn Any + static>>`, but with helper functions and hacks for cloning and de/serialization.
 //!
 //! # Trait requirements
 //!
-//! If you want to store your type here, it must implement `Clone` and `Any` and be `'static`, which means it must not contain references. If you want to store your data in serializable storage, it must implement `serde::Serialize` and `serde::Deserialize` under `persistent` feature.
+//! If you want to store your type here, it must implement `Clone` and `Any` and be `'static`, which means it must not contain references. If you want to store your data in serializable storage, it must implement `serde::Serialize` and `serde::Deserialize` under the `persistent` feature.
 //!
 //! # `AnyMap`
 //!
-//! It stores everything by just type. You should use this map for your widget, when all instances of your widgets can have only one state. E.g. for popup windows, for color picker.
+//! It stores everything by just type. You should use this map for your widget when all instances of your widgets can have only one state. E.g. for popup windows, for color picker.
 //!
-//! In order to not have intersections, you should create newtype for anything you try to store here, like:
+//! To not have intersections, you should create newtype for anything you try to store here, like:
 //! ```rust
 //! struct MyEditBool(pub bool);
 //! ```
 //!
 //! # `AnyMapId`
 //!
-//! [`AnyMap`] and [`AnyMapId`] has quite similar interface, except for [`AnyMapId`] you should pass [`crate::Id`] to get and insert things.
+//! [`AnyMap`] and [`AnyMapId`] has a quite similar interface, except for [`AnyMapId`] you should pass [`Id`] to get and insert things.
 //!
-//! It stores everything by [`crate::Id`], this should be used when your widget can have different data for different instances of the widget.
+//! It stores everything by [`Id`], this should be used when your widget can have different data for different instances of the widget.
 //!
 //! # `serializable`
 //!
 //! [`AnyMap`] and [`serializable::AnyMap`] has exactly the same interface, but [`serializable::AnyMap`] only requires serde traits for stored object under `persistent` feature. Same thing for [`AnyMapId`] and [`serializable::AnyMapId`].
 //!
-//! # What could broke
+//! # What could break
 //!
-//! Things here could broke only when you trying to load this from file.
+//! Things here could break only when you trying to load this from file.
 //!
-//! First, serialized `TypeId` in [`serializable::AnyMap`] could broke, if you updated version of Rust compiler between runs.
+//! First, serialized `TypeId` in [`serializable::AnyMap`] could broke if you updated the version of the Rust compiler between runs.
 //!
-//! Second, count and reset all instances of type in [`serializable::AnyMapId`] could return incorrect value for the same reason.
+//! Second, count and reset all instances of a type in [`serializable::AnyMapId`] could return an incorrect value for the same reason.
 //!
-//! Deserialization errors of loaded elements of these storages can be determined only when you call `get_...` functions, they not logged and not provided to user, on this errors value is just replaced with `or_insert()`/default value.
+//! Deserialization errors of loaded elements of these storages can be determined only when you call `get_...` functions, they not logged and not provided to a user, on this errors value is just replaced with `or_insert()`/default value.
 //!
 //! # When not to use this
 //!
-//! Basically, this is not for important widget data. Some errors just ignored and correct value of type is inserted when you call. This is done in order to simple interface.
+//! This is not for important widget data. Some errors are just ignored and the correct value of type is inserted when you call. This is done to more simple interface.
 //!
-//! You shouldn't use any map here when you need very reliable state storage with rich error-handling. For this purposes you should create your own `Memory` struct and pass it everywhere you need it. Then, you should de/serialize it by yourself, handling all serialization or other errors as you wish.
+//! You shouldn't use any map here when you need very reliable state storage with rich error-handling. For this purpose you should create your own `Memory` struct and pass it everywhere you need it. Then, you should de/serialize it by yourself, handling all serialization or other errors as you wish.
+//!
+//! [`Id`]: crate::Id
+//! [`Memory`]: crate::Memory
+//! [`Any`]: std::any::Any
 
 mod any_map;
 mod element;

egui/src/any/serializable/any_map.rs

@@ -12,7 +12,7 @@ use {
     std::any::TypeId,
 };
 
-/// Stores object with any type, and can be de/serialized.
+/// Stores object of any type and can be de/serialized.
 #[derive(Clone, Debug, Default)]
 #[cfg_attr(feature = "persistence", derive(serde::Deserialize, serde::Serialize))]
 pub struct AnyMap(HashMap<TypeId, AnyMapElement>);

egui/src/any/serializable/id_map.rs

@@ -72,7 +72,7 @@ impl AnyMapId {
 }
 
 impl AnyMapId {
-    /// You could use this function to find is there some leak or misusage. Note, that result of this function could broke between runs, if you upgraded Rust version or for other reasons.
+    /// You could use this function to find is there some leak or misusage. Note, that result of this function could break between runs, if you upgraded the Rust version or for other reasons.
     pub fn count<T: AnyMapTrait>(&mut self) -> usize {
         let id = TypeId::of::<T>();
         self.0.iter().filter(|(_, v)| v.1 == id).count()
@@ -82,10 +82,10 @@ impl AnyMapId {
         self.0.len()
     }
 
-    /// Note that this function could not reset all needed types between runs because, if you upgraded Rust version or for other reasons.
+    /// Note that this function could not reset all needed types between runs because if you upgraded the Rust version or for other reasons.
     pub fn reset<T: AnyMapTrait>(&mut self) {
         let id = TypeId::of::<T>();
-        self.0.retain(|_, v| v.1 == id);
+        self.0.retain(|_, v| v.1 != id);
     }
 
     pub fn reset_all(&mut self) {

egui/src/any/serializable/type_id.rs

@@ -1,6 +1,6 @@
 use std::any::Any;
 
-/// We need this because `TypeId` can't be deserialized or serialized directly, but this can be done using hashing. However, there is small possibility that different types will have intersection by hashes of their type ids.
+/// We need this because `TypeId` can't be deserialized or serialized directly, but this can be done using hashing. However, there is a small possibility that different types will have intersection by hashes of their type ids.
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
 #[cfg_attr(feature = "persistence", derive(serde::Deserialize, serde::Serialize))]
 pub struct TypeId(u64);

egui/src/context.rs

@@ -830,7 +830,7 @@ impl Context {
             ));
             if ui.button("Reset").clicked() {
                 self.memory()
-                    .data
+                    .id_data
                     .reset::<containers::collapsing_header::State>();
             }
         });
@@ -841,7 +841,7 @@ impl Context {
                 self.memory().id_data_temp.count::<menu::BarState>()
             ));
             if ui.button("Reset").clicked() {
-                self.memory().data_temp.reset::<menu::BarState>();
+                self.memory().id_data_temp.reset::<menu::BarState>();
             }
         });
 
@@ -851,7 +851,7 @@ impl Context {
                 self.memory().id_data.count::<scroll_area::State>()
             ));
             if ui.button("Reset").clicked() {
-                self.memory().data_temp.reset::<scroll_area::State>();
+                self.memory().id_data.reset::<scroll_area::State>();
             }
         });
 
@@ -861,7 +861,7 @@ impl Context {
                 self.memory().id_data.count::<resize::State>()
             ));
             if ui.button("Reset").clicked() {
-                self.memory().data_temp.reset::<resize::State>();
+                self.memory().id_data.reset::<resize::State>();
             }
         });
 

egui/src/memory.rs

@@ -11,21 +11,21 @@ use crate::{any, area, window, Id, InputState, LayerId, Pos2, Rect, Style};
 ///
 /// If you want this to persist when closing your app you should serialize `Memory` and store it.
 ///
-/// If you want to store data for your widgets, you should look at `data`/`data_temp` and `id_data`/`id_data_temp` fields, and read documentation of [`any`] module.
+/// If you want to store data for your widgets, you should look at `data`/`data_temp` and `id_data`/`id_data_temp` fields, and read the documentation of [`any`] module.
 #[derive(Clone, Debug, Default)]
 #[cfg_attr(feature = "persistence", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "persistence", serde(default))]
 pub struct Memory {
     pub options: Options,
 
-    /// This map stores current states for widgets that does not require `Id`. This will be saved between different program runs if you use `persistence` feature.
+    /// This map stores current states for widgets that don't require `Id`. This will be saved between different program runs if you use the `persistence` feature.
     pub data: any::serializable::AnyMap,
 
     /// Same as `data`, but this data will not be saved between runs.
     #[cfg_attr(feature = "persistence", serde(skip))]
     pub data_temp: any::AnyMap,
 
-    /// This map stores current states for all widgets with custom `Id`s. This will be saved between different program runs if you use `persistence` feature.
+    /// This map stores current states for all widgets with custom `Id`s. This will be saved between different program runs if you use the `persistence` feature.
     pub id_data: any::serializable::AnyMapId,
 
     /// Same as `id_data`, but this data will not be saved between runs.