feat: add display UI with splash screen, dashboard, and RSSI sparkline
Implement full SSD1306 OLED display support: - Splash screen on boot (1.5s) with project name, version, board - Dashboard showing radio state, config, counters, RSSI/SNR - RSSI history sparkline (64-sample ring buffer, 2px-wide bars) - DisplayOn/DisplayOff host commands routed via dedicated channel - Pure render functions against generic DrawTarget (no hardware coupling) - Display on/off control bypasses radio task entirely Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
17624 files changed
+4564928
-38
No files matched your search
+92
@@ -0,0 +1,92 @@
|
||||
//! # Documentation for Additional Attributes
|
||||
//!
|
||||
//! ## Attributes on Enums
|
||||
//!
|
||||
//! Strum supports several custom attributes to modify the generated code. At the enum level, the following attributes are supported:
|
||||
//!
|
||||
//! - `#[strum(serialize_all = "case_style")]` attribute can be used to change the case used when serializing to and deserializing
|
||||
//! from strings. This feature is enabled by [withoutboats/heck](https://github.com/withoutboats/heck) and supported case styles are:
|
||||
//!
|
||||
//! - `camelCase`
|
||||
//! - `PascalCase`
|
||||
//! - `kebab-case`
|
||||
//! - `snake_case`
|
||||
//! - `SCREAMING_SNAKE_CASE`
|
||||
//! - `SCREAMING-KEBAB-CASE`
|
||||
//! - `lowercase`
|
||||
//! - `UPPERCASE`
|
||||
//! - `title_case`
|
||||
//! - `mixed_case`
|
||||
//! - `Train-Case`
|
||||
//!
|
||||
//! ```rust
|
||||
//! use strum_macros;
|
||||
//!
|
||||
//! #[derive(Debug, Eq, PartialEq, strum_macros::Display)]
|
||||
//! #[strum(serialize_all = "snake_case")]
|
||||
//! enum Brightness {
|
||||
//! DarkBlack,
|
||||
//! Dim {
|
||||
//! glow: usize,
|
||||
//! },
|
||||
//! #[strum(serialize = "bright")]
|
||||
//! BrightWhite,
|
||||
//! }
|
||||
//!
|
||||
//! assert_eq!(
|
||||
//! String::from("dark_black"),
|
||||
//! Brightness::DarkBlack.to_string().as_ref()
|
||||
//! );
|
||||
//! assert_eq!(
|
||||
//! String::from("dim"),
|
||||
//! Brightness::Dim { glow: 0 }.to_string().as_ref()
|
||||
//! );
|
||||
//! assert_eq!(
|
||||
//! String::from("bright"),
|
||||
//! Brightness::BrightWhite.to_string().as_ref()
|
||||
//! );
|
||||
//! ```
|
||||
//!
|
||||
//! - You can also apply the `#[strum(ascii_case_insensitive)]` attribute to the enum,
|
||||
//! and this has the same effect of applying it to every variant.
|
||||
//!
|
||||
//! ## Attributes on Variants
|
||||
//!
|
||||
//! Custom attributes are applied to a variant by adding `#[strum(parameter="value")]` to the variant.
|
||||
//!
|
||||
//! - `serialize="..."`: Changes the text that `FromStr()` looks for when parsing a string. This attribute can
|
||||
//! be applied multiple times to an element and the enum variant will be parsed if any of them match.
|
||||
//!
|
||||
//! - `to_string="..."`: Similar to `serialize`. This value will be included when using `FromStr()`. More importantly,
|
||||
//! this specifies what text to use when calling `variant.to_string()` with the `Display` derivation, or when calling `variant.as_ref()` with `AsRefStr`.
|
||||
//!
|
||||
//! - `default`: Applied to a single variant of an enum. The variant must be a Tuple-like
|
||||
//! variant with a single piece of data that can be create from a `&str` i.e. `T: From<&str>`.
|
||||
//! The generated code will now return the variant with the input string captured as shown below
|
||||
//! instead of failing.
|
||||
//!
|
||||
//! ```text
|
||||
//! // Replaces this:
|
||||
//! _ => Err(strum::ParseError::VariantNotFound)
|
||||
//! // With this in generated code:
|
||||
//! default => Ok(Variant(default.into()))
|
||||
//! ```
|
||||
//! The plugin will fail if the data doesn't implement From<&str>. You can only have one `default`
|
||||
//! on your enum.
|
||||
//!
|
||||
//! - `disabled`: removes variant from generated code.
|
||||
//!
|
||||
//! - `ascii_case_insensitive`: makes the comparison to this variant case insensitive (ASCII only).
|
||||
//! If the whole enum is marked `ascii_case_insensitive`, you can specify `ascii_case_insensitive = false`
|
||||
//! to disable case insensitivity on this variant.
|
||||
//!
|
||||
//! - `message=".."`: Adds a message to enum variant. This is used in conjunction with the `EnumMessage`
|
||||
//! trait to associate a message with a variant. If `detailed_message` is not provided,
|
||||
//! then `message` will also be returned when `get_detailed_message` is called.
|
||||
//!
|
||||
//! - `detailed_message=".."`: Adds a more detailed message to a variant. If this value is omitted, then
|
||||
//! `message` will be used in it's place.
|
||||
//!
|
||||
//! - Structured documentation, as in `/// ...`: If using `EnumMessage`, is accessible via get_documentation().
|
||||
//!
|
||||
//! - `props(key="value")`: Enables associating additional information with a given variant.
|
||||
Vendored
+260
@@ -0,0 +1,260 @@
|
||||
//! # Strum
|
||||
//!
|
||||
//! [](https://travis-ci.org/Peternator7/strum)
|
||||
//! [](https://crates.io/crates/strum)
|
||||
//! [](https://docs.rs/strum)
|
||||
//!
|
||||
//! Strum is a set of macros and traits for working with
|
||||
//! enums and strings easier in Rust.
|
||||
//!
|
||||
//! The full version of the README can be found on [GitHub](https://github.com/Peternator7/strum).
|
||||
//!
|
||||
//! # Including Strum in Your Project
|
||||
//!
|
||||
//! Import strum and `strum_macros` into your project by adding the following lines to your
|
||||
//! Cargo.toml. `strum_macros` contains the macros needed to derive all the traits in Strum.
|
||||
//!
|
||||
//! ```toml
|
||||
//! [dependencies]
|
||||
//! strum = "0.26"
|
||||
//! strum_macros = "0.26"
|
||||
//!
|
||||
//! # You can also access strum_macros exports directly through strum using the "derive" feature
|
||||
//! strum = { version = "0.26", features = ["derive"] }
|
||||
//! ```
|
||||
//!
|
||||
|
||||
#![cfg_attr(not(feature = "std"), no_std)]
|
||||
#![cfg_attr(docsrs, feature(doc_cfg))]
|
||||
|
||||
// only for documentation purposes
|
||||
pub mod additional_attributes;
|
||||
|
||||
use core::iter::FusedIterator;
|
||||
|
||||
#[cfg(feature = "phf")]
|
||||
#[doc(hidden)]
|
||||
pub use phf as _private_phf_reexport_for_macro_if_phf_feature;
|
||||
|
||||
/// The `ParseError` enum is a collection of all the possible reasons
|
||||
/// an enum can fail to parse from a string.
|
||||
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
|
||||
pub enum ParseError {
|
||||
VariantNotFound,
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
impl std::fmt::Display for ParseError {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
|
||||
// We could use our macro here, but this way we don't take a dependency on the
|
||||
// macros crate.
|
||||
match self {
|
||||
ParseError::VariantNotFound => write!(f, "Matching variant not found"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
impl std::error::Error for ParseError {
|
||||
fn description(&self) -> &str {
|
||||
match self {
|
||||
ParseError::VariantNotFound => {
|
||||
"Unable to find a variant of the given enum matching the string given. Matching \
|
||||
can be extended with the Serialize attribute and is case sensitive."
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// This trait designates that an `Enum` can be iterated over. It can
|
||||
/// be auto generated using the [`EnumIter`](derive.EnumIter.html) derive macro.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// # use std::fmt::Debug;
|
||||
/// // You need to bring the type into scope to use it!!!
|
||||
/// use strum::{EnumIter, IntoEnumIterator};
|
||||
///
|
||||
/// #[derive(EnumIter, Debug)]
|
||||
/// enum Color {
|
||||
/// Red,
|
||||
/// Green { range: usize },
|
||||
/// Blue(usize),
|
||||
/// Yellow,
|
||||
/// }
|
||||
///
|
||||
/// // Iterate over the items in an enum and perform some function on them.
|
||||
/// fn generic_iterator<E, F>(pred: F)
|
||||
/// where
|
||||
/// E: IntoEnumIterator,
|
||||
/// F: Fn(E),
|
||||
/// {
|
||||
/// for e in E::iter() {
|
||||
/// pred(e)
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
/// generic_iterator::<Color, _>(|color| println!("{:?}", color));
|
||||
/// ```
|
||||
pub trait IntoEnumIterator: Sized {
|
||||
type Iterator: Iterator<Item = Self>
|
||||
+ Clone
|
||||
+ DoubleEndedIterator
|
||||
+ ExactSizeIterator
|
||||
+ FusedIterator;
|
||||
|
||||
fn iter() -> Self::Iterator;
|
||||
}
|
||||
|
||||
pub trait VariantIterator: Sized {
|
||||
type Iterator: Iterator<Item = Self>;
|
||||
|
||||
fn iter() -> Self::Iterator;
|
||||
}
|
||||
|
||||
pub trait VariantMetadata {
|
||||
const VARIANT_COUNT: usize;
|
||||
const VARIANT_NAMES: &'static [&'static str];
|
||||
|
||||
fn variant_name(&self) -> &'static str;
|
||||
}
|
||||
|
||||
/// Associates additional pieces of information with an Enum. This can be
|
||||
/// autoimplemented by deriving `EnumMessage` and annotating your variants with
|
||||
/// `#[strum(message="...")]`.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// # use std::fmt::Debug;
|
||||
/// // You need to bring the type into scope to use it!!!
|
||||
/// use strum::EnumMessage;
|
||||
///
|
||||
/// #[derive(PartialEq, Eq, Debug, EnumMessage)]
|
||||
/// enum Pet {
|
||||
/// #[strum(message="I have a dog")]
|
||||
/// #[strum(detailed_message="My dog's name is Spots")]
|
||||
/// Dog,
|
||||
/// /// I am documented.
|
||||
/// #[strum(message="I don't have a cat")]
|
||||
/// Cat,
|
||||
/// }
|
||||
///
|
||||
/// let my_pet = Pet::Dog;
|
||||
/// assert_eq!("I have a dog", my_pet.get_message().unwrap());
|
||||
/// ```
|
||||
pub trait EnumMessage {
|
||||
fn get_message(&self) -> Option<&'static str>;
|
||||
fn get_detailed_message(&self) -> Option<&'static str>;
|
||||
|
||||
/// Get the doc comment associated with a variant if it exists.
|
||||
fn get_documentation(&self) -> Option<&'static str>;
|
||||
fn get_serializations(&self) -> &'static [&'static str];
|
||||
}
|
||||
|
||||
/// `EnumProperty` is a trait that makes it possible to store additional information
|
||||
/// with enum variants. This trait is designed to be used with the macro of the same
|
||||
/// name in the `strum_macros` crate. Currently, the only string literals are supported
|
||||
/// in attributes, the other methods will be implemented as additional attribute types
|
||||
/// become stabilized.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// # use std::fmt::Debug;
|
||||
/// // You need to bring the type into scope to use it!!!
|
||||
/// use strum::EnumProperty;
|
||||
///
|
||||
/// #[derive(PartialEq, Eq, Debug, EnumProperty)]
|
||||
/// enum Class {
|
||||
/// #[strum(props(Teacher="Ms.Frizzle", Room="201"))]
|
||||
/// History,
|
||||
/// #[strum(props(Teacher="Mr.Smith"))]
|
||||
/// #[strum(props(Room="103"))]
|
||||
/// Mathematics,
|
||||
/// #[strum(props(Time="2:30"))]
|
||||
/// Science,
|
||||
/// }
|
||||
///
|
||||
/// let history = Class::History;
|
||||
/// assert_eq!("Ms.Frizzle", history.get_str("Teacher").unwrap());
|
||||
/// ```
|
||||
pub trait EnumProperty {
|
||||
fn get_str(&self, prop: &str) -> Option<&'static str>;
|
||||
fn get_int(&self, _prop: &str) -> Option<usize> {
|
||||
Option::None
|
||||
}
|
||||
|
||||
fn get_bool(&self, _prop: &str) -> Option<bool> {
|
||||
Option::None
|
||||
}
|
||||
}
|
||||
|
||||
/// A cheap reference-to-reference conversion. Used to convert a value to a
|
||||
/// reference value with `'static` lifetime within generic code.
|
||||
#[deprecated(
|
||||
since = "0.22.0",
|
||||
note = "please use `#[derive(IntoStaticStr)]` instead"
|
||||
)]
|
||||
pub trait AsStaticRef<T>
|
||||
where
|
||||
T: ?Sized,
|
||||
{
|
||||
fn as_static(&self) -> &'static T;
|
||||
}
|
||||
|
||||
/// A trait for capturing the number of variants in Enum. This trait can be autoderived by
|
||||
/// `strum_macros`.
|
||||
pub trait EnumCount {
|
||||
const COUNT: usize;
|
||||
}
|
||||
|
||||
/// A trait for retrieving the names of each variant in Enum. This trait can
|
||||
/// be autoderived by `strum_macros`.
|
||||
pub trait VariantNames {
|
||||
/// Names of the variants of this enum
|
||||
const VARIANTS: &'static [&'static str];
|
||||
}
|
||||
|
||||
/// A trait for retrieving a static array containing all the variants in an Enum.
|
||||
/// This trait can be autoderived by `strum_macros`. For derived usage, all the
|
||||
/// variants in the enumerator need to be unit-types, which means you can't autoderive
|
||||
/// enums with inner data in one or more variants. Consider using it alongside
|
||||
/// [`EnumDiscriminants`] if you require inner data but still want to have an
|
||||
/// static array of variants.
|
||||
pub trait VariantArray: ::core::marker::Sized + 'static {
|
||||
const VARIANTS: &'static [Self];
|
||||
}
|
||||
|
||||
#[cfg(feature = "derive")]
|
||||
pub use strum_macros::*;
|
||||
|
||||
macro_rules! DocumentMacroRexports {
|
||||
($($export:ident),+) => {
|
||||
$(
|
||||
#[cfg(all(docsrs, feature = "derive"))]
|
||||
#[cfg_attr(docsrs, doc(cfg(feature = "derive")))]
|
||||
pub use strum_macros::$export;
|
||||
)+
|
||||
};
|
||||
}
|
||||
|
||||
// We actually only re-export these items individually if we're building
|
||||
// for docsrs. You can do a weird thing where you rename the macro
|
||||
// and then reference it through strum. The renaming feature should be deprecated now that
|
||||
// 2018 edition is almost 2 years old, but we'll need to give people some time to do that.
|
||||
DocumentMacroRexports! {
|
||||
AsRefStr,
|
||||
Display,
|
||||
EnumCount,
|
||||
EnumDiscriminants,
|
||||
EnumIter,
|
||||
EnumMessage,
|
||||
EnumProperty,
|
||||
EnumString,
|
||||
VariantNames,
|
||||
FromRepr,
|
||||
IntoStaticStr,
|
||||
VariantArray
|
||||
}
|
||||
Reference in new issue
Block a user