use std::{
cell::RefCell,
collections::{HashMap, hash_map::DefaultHasher},
hash::{Hash, Hasher},
panic::Location,
sync::{Arc, Mutex, Weak},
};
use super::{
color_swatch::{self, ColorSwatch, ColorSwatchPart, ColorSwatchShape, ColorSwatchSize},
icon::Icon,
icons, names,
number_input::{NumberInput, NumberInputLayout},
part_style::{FontFamily, Length, PartStyle},
recipe::{Case, Interaction, Name, Recipe, ResolvedPart, ResolvedRecipe},
shared::{fading, pressable},
text_box::{self, BoxStates},
theme::{Themed, current_theme},
};
use crate::{
app::{
events::{DragEvent, KeyboardEvent, MouseButton, MouseButtonMask, MouseEvent},
theme::{ControlSize, IconSize, OpacityLevel, PaletteColor, RadiusSize, ShadowStyle, Theme},
},
components::{self, Column, Row, Stack},
core::{ElementRef, Signal},
eyedropper::EyeDropper,
layout::{Alignment, StackAlignment, text_style::FontWeight},
node::{
BoxShadowValue, CursorIcon, Element, Gradient,
border::Border,
color::{Color, Hsl, Hsv},
dimension::Dimension,
},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ColorPickerPart {
Root,
Area,
AreaThumb,
Hue,
Alpha,
Thumb,
Checker,
CheckerCell,
Swatches,
Swatch,
Fields,
Input,
Format,
FieldLabel,
Eyedropper,
EyedropperIcon,
}
names!(ColorPickerPart {
Root => "root",
Area => "area",
AreaThumb => "area_thumb",
Hue => "hue",
Alpha => "alpha",
Thumb => "thumb",
Checker => "checker",
CheckerCell => "checker_cell",
Swatches => "swatches",
Swatch => "swatch",
Fields => "fields",
Input => "input",
Format => "format",
FieldLabel => "field_label",
Eyedropper => "eyedropper",
EyedropperIcon => "eyedropper_icon",
});
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ColorPickerState {
Alpha,
Bare,
Disabled,
}
names!(ColorPickerState {
Alpha => "alpha",
Bare => "bare",
Disabled => "disabled",
});
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum ColorFormat {
#[default]
Hex,
Rgb,
Hsl,
}
impl ColorFormat {
fn name(self) -> &'static str {
match self {
Self::Hex => "HEX",
Self::Rgb => "RGB",
Self::Hsl => "HSL",
}
}
}
pub type ColorPickerRenderer = Arc<dyn Fn(ColorPickerView) -> Element + Send + Sync>;
type Told = Arc<dyn Fn(Color) + Send + Sync>;
#[derive(Clone)]
struct Words {
saturation: Arc<str>,
brightness: Arc<str>,
hue: Arc<str>,
alpha: Arc<str>,
format: Arc<str>,
eyedropper: Arc<str>,
told_area: bool,
}
impl Default for Words {
fn default() -> Self {
let locale = super::current_locale();
let words = &locale.fields;
Self {
saturation: words.saturation.clone(),
brightness: words.brightness.clone(),
hue: words.hue.clone(),
alpha: words.alpha.clone(),
format: words.format.clone(),
eyedropper: words.pick_from_screen.clone(),
told_area: false,
}
}
}
#[derive(Clone)]
enum Bound {
Value(Signal<Color>),
Controlled(Color),
}
pub struct ColorPicker {
bound: Bound,
binding: usize,
at: Option<&'static Location<'static>>,
alpha: bool,
formats: Vec<ColorFormat>,
format: ColorFormat,
swatches: Vec<Color>,
label: Option<Arc<str>>,
disabled: bool,
bare: bool,
eyedropper: bool,
words: Words,
on_change: Vec<Told>,
on_change_end: Vec<Told>,
states: Vec<Name>,
rules: Recipe,
forced: Option<Interaction>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl ColorPicker {
pub fn new(value: Signal<Color>) -> Self {
let binding = value.id();
Self::of(Bound::Value(value), binding, None)
}
#[track_caller]
pub fn controlled(value: Color, on_change: impl Fn(Color) + Send + Sync + 'static) -> Self {
let at = Location::caller();
Self::of(Bound::Controlled(value), controlled_binding(at, None), Some(at)).on_change(on_change)
}
fn of(bound: Bound, binding: usize, at: Option<&'static Location<'static>>) -> Self {
Self {
bound,
binding,
at,
alpha: false,
formats: Vec::new(),
format: ColorFormat::Hex,
swatches: Vec::new(),
label: None,
disabled: false,
bare: false,
eyedropper: true,
words: Words::default(),
on_change: Vec::new(),
on_change_end: Vec::new(),
states: Vec::new(),
rules: Recipe::new(),
forced: None,
id: None,
key: None,
}
}
pub fn eyedropper(mut self, eyedropper: bool) -> Self {
self.eyedropper = eyedropper;
self
}
pub fn eyedropper_label(mut self, label: &str) -> Self {
self.words.eyedropper = Arc::from(label);
self
}
pub(crate) fn kept_by(mut self, binding: usize) -> Self {
self.binding = binding;
self.at = None;
self
}
pub fn alpha(mut self, alpha: bool) -> Self {
self.alpha = alpha;
self
}
pub fn format(mut self, format: ColorFormat) -> Self {
self.format = format;
self
}
pub fn formats(mut self, formats: impl IntoIterator<Item = ColorFormat>) -> Self {
self.formats = formats.into_iter().collect();
self
}
pub fn swatch(mut self, color: impl Into<Color>) -> Self {
self.swatches.push(color.into());
self
}
pub fn swatches(mut self, colors: impl IntoIterator<Item = impl Into<Color>>) -> Self {
self.swatches.extend(colors.into_iter().map(Into::into));
self
}
pub fn label(mut self, label: &str) -> Self {
self.label = Some(Arc::from(label));
self
}
pub fn disabled(mut self, disabled: bool) -> Self {
self.disabled = disabled;
self
}
pub fn bare(mut self, bare: bool) -> Self {
self.bare = bare;
self
}
pub fn saturation_label(mut self, label: &str) -> Self {
self.words.saturation = Arc::from(label);
self.words.told_area = true;
self
}
pub fn brightness_label(mut self, label: &str) -> Self {
self.words.brightness = Arc::from(label);
self.words.told_area = true;
self
}
pub fn hue_label(mut self, label: &str) -> Self {
self.words.hue = Arc::from(label);
self
}
pub fn alpha_label(mut self, label: &str) -> Self {
self.words.alpha = Arc::from(label);
self
}
pub fn format_label(mut self, label: &str) -> Self {
self.words.format = Arc::from(label);
self
}
pub fn on_change(mut self, handler: impl Fn(Color) + Send + Sync + 'static) -> Self {
self.on_change.push(Arc::new(handler));
self
}
pub fn on_change_end(mut self, handler: impl Fn(Color) + Send + Sync + 'static) -> Self {
self.on_change_end.push(Arc::new(handler));
self
}
pub fn state(mut self, state: impl Into<Name>, on: bool) -> Self {
let state = state.into();
self.states.retain(|held| *held != state);
if on {
self.states.push(state);
}
self
}
pub fn style(mut self, part: impl Into<Name>, style: impl FnOnce(PartStyle) -> PartStyle) -> Self {
self.rules = self.rules.base(part, style);
self
}
pub fn rules(mut self, rules: &Recipe) -> Self {
self.rules = self.rules.extend(rules);
self
}
pub fn force(mut self, interaction: Option<Interaction>) -> Self {
self.forced = interaction;
self
}
pub fn id(mut self, id: impl Into<Arc<str>>) -> Self {
self.id = Some(id.into());
self
}
pub fn key(mut self, key: impl Into<Arc<str>>) -> Self {
self.key = Some(key.into());
self
}
pub fn build(self, theme: &Theme) -> Element {
let binding = match self.at {
Some(at) => controlled_binding(at, self.id.as_deref().or(self.key.as_deref())),
None => self.binding,
};
let value = match &self.bound {
Bound::Value(signal) => signal.get(),
Bound::Controlled(value) => *value,
};
let kept = kept(binding, value, self.format);
let format = kept.format.get();
let case = Case {
variant: None,
size: None,
density: None,
breakpoint: super::current_breakpoint(),
states: self.states.clone(),
}
.state(ColorPickerState::Alpha, self.alpha)
.state(ColorPickerState::Bare, self.bare)
.state(ColorPickerState::Disabled, self.disabled);
let model = Model {
bound: self.bound,
kept: kept.clone(),
on_change: self.on_change,
on_change_end: self.on_change_end,
};
let value = match kept.picked.get() {
Some(color) => {
kept.picked.set(None);
if !self.disabled {
model.step(|model| model.set_color(color));
}
model.current()
}
None => value,
};
let hsv = kept.shown(value);
let view = ColorPickerView {
color: value,
hsv,
alpha: self.alpha,
format,
formats: self.formats,
swatches: self.swatches,
label: self.label,
disabled: self.disabled,
eyedropper: self.eyedropper && EyeDropper::is_supported(),
recipe: theme
.resolve::<ColorPicker>(&case, Some(&self.rules))
.owned_by(self.id.as_ref()),
words: self.words,
model,
forced: self.forced,
id: self.id,
key: self.key,
};
match theme.renderer::<ColorPicker>() {
Some(renderer) => renderer(view),
None => view.render(),
}
}
}
impl From<ColorPicker> for Element {
fn from(picker: ColorPicker) -> Self {
picker.build(¤t_theme())
}
}
fn controlled_binding(at: &'static Location<'static>, name: Option<&str>) -> usize {
let mut hasher = DefaultHasher::new();
(at.file(), at.line(), at.column(), name, "color_picker").hash(&mut hasher);
(hasher.finish() as usize) | (1 << (usize::BITS - 1))
}
struct Kept {
hsv: Mutex<Hsv>,
current: Mutex<Color>,
start: Mutex<Option<Color>>,
format: Signal<ColorFormat>,
given: Mutex<ColorFormat>,
area: ElementRef,
hue: ElementRef,
alpha: ElementRef,
picked: Signal<Option<Color>>,
}
impl Kept {
fn shown(&self, value: Color) -> Hsv {
let mut held = self.hsv.lock().unwrap();
*self.current.lock().unwrap() = value;
if Color::from(*held) == value {
return *held;
}
let mut hsv = value.to_hsv();
if hsv.s <= 0.0 || hsv.v <= 0.0 {
hsv.h = held.h;
}
if hsv.v <= 0.0 {
hsv.s = held.s;
}
*held = hsv;
hsv
}
}
thread_local! {
static KEPT: RefCell<HashMap<usize, Weak<Kept>>> = RefCell::new(HashMap::new());
}
fn kept(binding: usize, value: Color, format: ColorFormat) -> Arc<Kept> {
KEPT.with(|all| {
let mut all = all.borrow_mut();
if let Some(kept) = all.get(&binding).and_then(Weak::upgrade) {
let mut given = kept.given.lock().unwrap();
if *given != format {
*given = format;
kept.format.set(format);
}
drop(given);
return kept;
}
all.retain(|_, kept| kept.strong_count() > 0);
let kept = Arc::new(Kept {
hsv: Mutex::new(value.to_hsv()),
current: Mutex::new(value),
start: Mutex::new(None),
format: Signal::new(format),
given: Mutex::new(format),
area: ElementRef::new(),
hue: ElementRef::new(),
alpha: ElementRef::new(),
picked: Signal::new(None),
});
all.insert(binding, Arc::downgrade(&kept));
kept
})
}
#[derive(Clone)]
struct Model {
bound: Bound,
kept: Arc<Kept>,
on_change: Vec<Told>,
on_change_end: Vec<Told>,
}
impl Model {
fn current(&self) -> Color {
match &self.bound {
Bound::Value(signal) => signal.get_untracked(),
Bound::Controlled(_) => *self.kept.current.lock().unwrap(),
}
}
fn hsv(&self) -> Hsv {
*self.kept.hsv.lock().unwrap()
}
fn begin(&self) {
let current = self.current();
self.kept.start.lock().unwrap().get_or_insert(current);
}
fn set(&self, hsv: Hsv) {
*self.kept.hsv.lock().unwrap() = hsv;
let color = Color::from(hsv);
if color == self.current() {
return;
}
*self.kept.current.lock().unwrap() = color;
if let Bound::Value(signal) = &self.bound {
signal.set(color);
}
for handler in &self.on_change {
handler(color);
}
}
fn set_color(&self, color: Color) {
let mut hsv = color.to_hsv();
let held = self.hsv();
if hsv.s <= 0.0 || hsv.v <= 0.0 {
hsv.h = held.h;
}
self.set(hsv);
}
fn end(&self) {
let Some(start) = self.kept.start.lock().unwrap().take() else {
return;
};
let now = self.current();
if now != start {
for handler in &self.on_change_end {
handler(now);
}
}
}
fn step(&self, change: impl FnOnce(&Self)) {
self.begin();
change(self);
self.end();
}
}
fn place(area: &ElementRef, x: f32, y: f32) -> (f32, f32) {
let bounds = area.bounds();
let across = if bounds.width > 0.0 {
((x - bounds.x) / bounds.width).clamp(0.0, 1.0)
} else {
0.0
};
let up = if bounds.height > 0.0 {
(1.0 - (y - bounds.y) / bounds.height).clamp(0.0, 1.0)
} else {
0.0
};
(across, up)
}
fn percent(value: f32) -> u32 {
(value * 100.0).round() as u32
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Slider {
Area,
Hue,
Alpha,
}
impl Slider {
fn at(self, hsv: Hsv, across: f32, up: f32) -> Hsv {
match self {
Self::Area => Hsv {
s: across,
v: up,
..hsv
},
Self::Hue => Hsv {
h: across * 360.0,
..hsv
},
Self::Alpha => Hsv { a: across, ..hsv },
}
}
fn key(self, hsv: Hsv, key: &str, shift: bool) -> Option<Hsv> {
let step = if shift { 10.0 } else { 1.0 };
let clamp = |value: f32| value.clamp(0.0, 1.0);
match self {
Self::Area => {
let (s, v) = (hsv.s, hsv.v);
let (s, v) = match key {
"ArrowRight" => (clamp(s + step / 100.0), v),
"ArrowLeft" => (clamp(s - step / 100.0), v),
"ArrowUp" => (s, clamp(v + step / 100.0)),
"ArrowDown" => (s, clamp(v - step / 100.0)),
"PageUp" => (s, clamp(v + 0.1)),
"PageDown" => (s, clamp(v - 0.1)),
"Home" => (0.0, v),
"End" => (1.0, v),
_ => return None,
};
Some(Hsv { s, v, ..hsv })
}
Self::Hue => {
let h = hsv.h;
let h = match key {
"ArrowRight" | "ArrowUp" => h + step,
"ArrowLeft" | "ArrowDown" => h - step,
"PageUp" => h + 36.0,
"PageDown" => h - 36.0,
"Home" => 0.0,
"End" => 360.0,
_ => return None,
};
Some(Hsv {
h: h.clamp(0.0, 360.0),
..hsv
})
}
Self::Alpha => {
let a = hsv.a;
let a = match key {
"ArrowRight" | "ArrowUp" => a + step / 100.0,
"ArrowLeft" | "ArrowDown" => a - step / 100.0,
"PageUp" => a + 0.1,
"PageDown" => a - 0.1,
"Home" => 0.0,
"End" => 1.0,
_ => return None,
};
Some(Hsv { a: clamp(a), ..hsv })
}
}
}
}
pub struct ColorPickerView {
pub color: Color,
pub hsv: Hsv,
pub alpha: bool,
pub format: ColorFormat,
pub formats: Vec<ColorFormat>,
pub swatches: Vec<Color>,
pub label: Option<Arc<str>>,
pub disabled: bool,
pub eyedropper: bool,
pub recipe: ResolvedRecipe,
words: Words,
model: Model,
forced: Option<Interaction>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl ColorPickerView {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part).forced(self.forced)
}
pub fn theme(&self) -> &Theme {
self.recipe.theme()
}
fn px(&self, length: Option<Length>, or: f32) -> f32 {
match length.and_then(|length| length.resolve(self.theme())) {
Some(Dimension::Px(px)) => px,
_ => or,
}
}
fn sub_id(&self, suffix: &str) -> Option<String> {
self.id.as_ref().map(|id| format!("{id}-{suffix}"))
}
fn width(&self) -> f32 {
self.px(self.part(ColorPickerPart::Area).rest().width, 208.0)
}
fn slider(&self, inner: Stack, slider: Slider, bounds: ElementRef, name: Arc<str>, said: String) -> Stack {
let mut slider_node = inner
.ref_element(bounds.clone())
.describe("a11y_role", "slider")
.describe("a11y_name", name)
.describe("a11y_valuetext", said);
if self.disabled {
return slider_node.describe("a11y_disabled", "true");
}
slider_node = slider_node.tab_index(0).focuses(&bounds);
let (press, drag, ended, released, keys) = (
(self.model.clone(), bounds.clone()),
(self.model.clone(), bounds.clone()),
self.model.clone(),
self.model.clone(),
self.model.clone(),
);
slider_node
.start_drag_buttons(MouseButtonMask::LEFT)
.finger_drags(true)
.on_mouse_down(move |event: MouseEvent| {
if event.button != MouseButton::Left {
return;
}
let (model, bounds) = &press;
model.begin();
let (across, up) = place(bounds, event.x, event.y);
model.set(slider.at(model.hsv(), across, up));
})
.on_drag_move(move |event: DragEvent| {
let (model, bounds) = &drag;
let (across, up) = place(bounds, event.x, event.y);
model.set(slider.at(model.hsv(), across, up));
})
.on_drag_end(move |_: DragEvent| ended.end())
.on_mouse_up(move |_: MouseEvent| released.end())
.on_key_down(move |event: KeyboardEvent| {
if !event.focus_within || event.ctrl || event.alt || event.meta {
return;
}
if let Some(next) = slider.key(keys.hsv(), &event.key, event.shift) {
event.prevent_default();
keys.step(|model| model.set(next));
}
})
}
pub fn area(&self) -> Element {
let part = self.part(ColorPickerPart::Area);
let thumb = self.part(ColorPickerPart::AreaThumb);
let (width, height) = (self.width(), self.px(part.rest().height, 120.0));
let side = self.px(thumb.rest().width, 12.0);
let hue = Color::from(Hsv {
h: self.hsv.h,
s: 1.0,
v: 1.0,
a: 1.0,
});
let white = Color::new(255, 255, 255, 255);
let black = Color::new(0, 0, 0, 255);
let field = Row::new()
.part(&part.clone().unnamed())
.size(width, height)
.background_gradient(Gradient::corners(white, hue, black, black));
let circle = Row::new()
.part(&thumb)
.offset(
self.hsv.s * width - side / 2.0,
(1.0 - self.hsv.v) * height - side / 2.0,
)
.pointer_events_none();
let (said, name) = if self.words.told_area {
let (saturation, brightness) = (&self.words.saturation, &self.words.brightness);
(
format!(
"{saturation} {}%, {brightness} {}%",
percent(self.hsv.s),
percent(self.hsv.v)
),
Arc::from(format!("{saturation}, {brightness}")),
)
} else {
let locale = super::current_locale();
let said = crate::core::fill(
&locale.fields.saturation_brightness_value,
&[
("saturation", &percent(self.hsv.s).to_string()),
("brightness", &percent(self.hsv.v).to_string()),
],
);
(said, locale.fields.saturation_and_brightness.clone())
};
let mut area = Stack::new()
.stack_align(StackAlignment::TopStart)
.part(&part)
.overflow_visible()
.size(width, height)
.child(field)
.child(circle)
.describe("a11y_valuenow", percent(self.hsv.s).to_string());
area = self.slider(area, Slider::Area, self.model.kept.area.clone(), name, said);
if let Some(id) = self.sub_id("area") {
area = area.id(id);
}
area.into()
}
fn rail(&self, slider: Slider, part: ColorPickerPart, fill: Element, at: f32, name: Arc<str>, said: String) -> Stack {
let track = self.part(part);
let thumb = self.part(ColorPickerPart::Thumb).keyed(match slider {
Slider::Alpha => "alpha",
_ => "hue",
});
let width = self.width();
let height = self.px(track.rest().height, 10.0);
let side = self.px(thumb.rest().width, 14.0);
let bounds = match slider {
Slider::Alpha => self.model.kept.alpha.clone(),
_ => self.model.kept.hue.clone(),
};
let rail = Stack::new()
.stack_align(StackAlignment::TopStart)
.part(&track)
.overflow_visible()
.size(width, height)
.child(
Stack::new()
.stack_align(StackAlignment::TopStart)
.size(width, height)
.part(&track)
.child(fill),
)
.child(
Row::new()
.part(&thumb)
.offset(at * width - side / 2.0, (height - side) / 2.0)
.pointer_events_none(),
);
self.slider(rail, slider, bounds, name, said)
}
pub fn hue(&self) -> Element {
let width = self.width();
let height = self.px(self.part(ColorPickerPart::Hue).rest().height, 10.0);
let stops: Vec<Color> = (0..=6)
.map(|sixth| {
Color::from(Hsv {
h: sixth as f32 * 60.0,
s: 1.0,
v: 1.0,
a: 1.0,
})
})
.collect();
let fill = Row::new()
.size(width, height)
.background_gradient(Gradient::linear(90.0, stops))
.into();
let degrees = self.hsv.h.round() as u32;
let mut rail = self
.rail(
Slider::Hue,
ColorPickerPart::Hue,
fill,
self.hsv.h / 360.0,
self.words.hue.clone(),
format!("{} {degrees}°", self.words.hue),
)
.describe("a11y_valuenow", degrees.to_string())
.describe("a11y_valuemin", "0")
.describe("a11y_valuemax", "360");
if let Some(id) = self.sub_id("hue") {
rail = rail.id(id);
}
rail.into()
}
pub fn alpha_rail(&self) -> Option<Element> {
if !self.alpha {
return None;
}
let width = self.width();
let height = self.px(self.part(ColorPickerPart::Alpha).rest().height, 10.0);
let opaque = self.color.with_alpha(255);
let fill = Stack::new()
.stack_align(StackAlignment::TopStart)
.size(width, height)
.child(color_swatch::checkerboard(
width,
height,
&self.part(ColorPickerPart::Checker),
&self.part(ColorPickerPart::CheckerCell),
))
.child(
Row::new()
.size(width, height)
.background_gradient(Gradient::linear(90.0, [opaque.with_alpha(0), opaque])),
)
.into();
let alpha = percent(self.hsv.a);
let mut rail = self
.rail(
Slider::Alpha,
ColorPickerPart::Alpha,
fill,
self.hsv.a,
self.words.alpha.clone(),
format!("{} {alpha}%", self.words.alpha),
)
.describe("a11y_valuenow", alpha.to_string())
.describe("a11y_valuemin", "0")
.describe("a11y_valuemax", "100");
if let Some(id) = self.sub_id("alpha") {
rail = rail.id(id);
}
Some(rail.into())
}
pub fn swatches(&self) -> Option<Element> {
if self.swatches.is_empty() {
return None;
}
let rules = self.recipe.rules_for(ColorPickerPart::Swatch, ColorSwatchPart::Root);
let theme = self.theme().clone();
let mut row = Row::new()
.align_items(Alignment::Center)
.overflow_visible()
.part(&self.part(ColorPickerPart::Swatches));
for (index, color) in self.swatches.iter().copied().enumerate() {
let model = self.model.clone();
let mut swatch = ColorSwatch::new(color)
.size(ColorSwatchSize::Sm)
.shape(ColorSwatchShape::Round)
.selected(color == self.color)
.disabled(self.disabled)
.rules(&rules)
.on_click(move |_| model.step(|model| model.set_color(color)));
if let Some(id) = self.sub_id(&format!("swatch-{index}")) {
swatch = swatch.id(id);
}
row = row.child(swatch.build(&theme));
}
Some(row.into())
}
pub fn format_button(&self) -> Option<Element> {
if self.formats.len() < 2 {
return None;
}
let part = self.part(ColorPickerPart::Format);
let (formats, current, format) = (self.formats.clone(), self.format, self.model.kept.format.clone());
let mut button = pressable(&part, self.disabled)
.flex_shrink(0.0)
.describe("a11y_role", "button")
.describe("a11y_name", format!("{}: {}", self.words.format, self.format.name()))
.child(part.text(self.format.name()).nowrap().part(&part));
if !self.disabled {
button = button.on_click(move |_| {
let at = formats.iter().position(|held| *held == current).map_or(0, |at| at + 1);
format.set(formats[at % formats.len()]);
});
}
if let Some(id) = self.sub_id("format") {
button = button.id(id);
}
Some(button.into())
}
pub fn eyedropper(&self) -> Option<Element> {
if !self.eyedropper {
return None;
}
let part = self.part(ColorPickerPart::Eyedropper);
let icon = self.part(ColorPickerPart::EyedropperIcon);
let side = icon.rest().width.unwrap_or(Length::Icon(IconSize::Md));
let mut button = pressable(&part, self.disabled)
.flex_shrink(0.0)
.align_items(Alignment::Center)
.describe("a11y_role", "button")
.describe("a11y_name", self.words.eyedropper.clone())
.child(
Row::new()
.part(&icon)
.child(Icon::new(icons::EYEDROPPER).size(side).build(self.theme())),
);
if !self.disabled {
let (picked, theme) = (self.model.kept.picked.clone(), self.theme().clone());
button = button.on_click(move |_| {
let picked = picked.clone();
EyeDropper::new().theme(&theme).pick_then(move |answer| {
if let Ok(Some(color)) = answer {
picked.set(Some(color));
}
});
});
}
if let Some(id) = self.sub_id("eyedropper") {
button = button.id(id);
}
Some(button.into())
}
pub fn hex_field(&self) -> Element {
let part = self.part(ColorPickerPart::Input);
let text = Signal::new(self.color.to_hex_upper());
let control = components::TextInput::new(text.clone())
.single_line()
.text_style(text_box::ink(self.theme(), &part.rest()))
.part(&part)
.keep_text_while_focused(true);
let states = BoxStates {
disabled: self.disabled,
label: Some(Arc::from("Hex")),
..BoxStates::default()
};
let mut control = text_box::text_box(control, &states, Vec::new());
let commit = {
let (model, text) = (self.model.clone(), text.clone());
move || {
let typed = text.get_untracked();
match Color::parse(&typed) {
Some(color) => model.step(|model| model.set_color(color)),
None => {}
}
let shown = model.current().to_hex_upper();
if text.get_untracked() != shown {
text.set(shown);
}
}
};
let enter = commit.clone();
control = control
.on_key_down(move |event: KeyboardEvent| {
if event.focus_within && event.key == "Enter" {
enter();
}
})
.on_blur(commit);
if let Some(id) = self.sub_id("hex") {
control = control.id(id);
}
control.into()
}
fn channel(
&self,
letter: &str,
name: &str,
value: f32,
max: f32,
set: impl Fn(&Model, f32) + Send + Sync + 'static,
) -> Element {
let model = self.model.clone();
let label = self.part(ColorPickerPart::FieldLabel).keyed(letter.to_lowercase());
let field = NumberInput::controlled(value.round() as f64, move |typed| {
if let Some(typed) = typed {
model.step(|model| set(model, typed as f32));
}
})
.min(0.0)
.max(max as f64)
.layout(NumberInputLayout::Bare)
.label(name)
.disabled(self.disabled)
.full_width(true);
let mut field = field;
if let Some(id) = self.sub_id(&format!("{}", letter.to_lowercase())) {
field = field.id(id);
}
Column::new()
.align_items(Alignment::Stretch)
.flex(1.0)
.min_width(0.0)
.spacing(2.0)
.child(label.text(letter).nowrap().part(&label))
.child(field.build(self.theme()))
.into()
}
pub fn fields(&self) -> Element {
let mut row = Row::new()
.align_items(Alignment::End)
.width(Dimension::Pct(100.0))
.part(&self.part(ColorPickerPart::Fields));
if let Some(button) = self.format_button() {
row = row.child(button);
}
match self.format {
ColorFormat::Hex => row = row.child(Row::new().flex(1.0).min_width(0.0).child(self.hex_field())),
ColorFormat::Rgb => {
let locale = super::current_locale();
let [r, g, b] = [self.color.r(), self.color.g(), self.color.b()].map(f32::from);
row = row
.child(self.channel("R", &locale.fields.red, r, 255.0, |model, red| {
let c = model.current();
model.set_color(Color::new(red as u8, c.g(), c.b(), c.a()))
}))
.child(self.channel("G", &locale.fields.green, g, 255.0, |model, green| {
let c = model.current();
model.set_color(Color::new(c.r(), green as u8, c.b(), c.a()))
}))
.child(self.channel("B", &locale.fields.blue, b, 255.0, |model, blue| {
let c = model.current();
model.set_color(Color::new(c.r(), c.g(), blue as u8, c.a()))
}));
}
ColorFormat::Hsl => {
let hsl = self.color.to_hsl_values();
let hue = if hsl.s <= 0.0 { self.hsv.h } else { hsl.h };
row = row
.child(self.channel("H", &self.words.hue, hue, 360.0, |model, h| {
let hsl = model.current().to_hsl_values();
model.set(with_hue(Hsl { h, ..hsl }, h))
}))
.child(
self.channel("S", &self.words.saturation, hsl.s * 100.0, 100.0, |model, s| {
let hsl = model.current().to_hsl_values();
let h = model.hsv().h;
model.set(with_hue(Hsl { s: s / 100.0, ..hsl }, h))
}),
)
.child(self.channel(
"L",
&super::current_locale().fields.lightness,
hsl.l * 100.0,
100.0,
|model, l| {
let hsl = model.current().to_hsl_values();
let h = model.hsv().h;
model.set(with_hue(Hsl { l: l / 100.0, ..hsl }, h))
},
));
}
}
if self.alpha && self.format != ColorFormat::Hex {
row = row.child(
self.channel("A", &self.words.alpha, self.hsv.a * 100.0, 100.0, |model, a| {
let hsv = model.hsv();
model.set(Hsv { a: a / 100.0, ..hsv })
}),
);
}
if let Some(eyedropper) = self.eyedropper() {
row = row.child(eyedropper);
}
row.into()
}
pub fn render(self) -> Element {
let mut root = Column::new()
.align_items(Alignment::Start)
.part(&self.part(ColorPickerPart::Root))
.describe("a11y_role", "group")
.child(self.area())
.child(self.hue());
if let Some(label) = &self.label {
root = root.describe("a11y_name", label.clone());
}
if let Some(alpha) = self.alpha_rail() {
root = root.child(alpha);
}
if let Some(swatches) = self.swatches() {
root = root.child(swatches);
}
root = root.child(self.fields());
if let Some(id) = &self.id {
root = root.id(id.clone());
}
if let Some(key) = &self.key {
root = root.key(key.clone());
}
root.into()
}
}
fn with_hue(hsl: Hsl, h: f32) -> Hsv {
let mut hsv = Color::from(hsl).to_hsv();
if hsv.s <= 0.0 || hsv.v <= 0.0 {
hsv.h = h;
}
hsv
}
impl crate::ui::Styled for ColorPicker {
type Component = Self;
fn rules(self, rules: &crate::ui::Recipe) -> Self {
Self::rules(self, rules)
}
fn state(self, state: impl Into<crate::ui::Name>, on: bool) -> Self {
Self::state(self, state, on)
}
}
impl Themed for ColorPicker {
const NAME: &'static str = "color_picker";
type Renderer = ColorPickerRenderer;
fn parts() -> crate::ui::Declared {
ColorPickerPart::declared()
}
fn states() -> crate::ui::Declared {
ColorPickerState::declared()
}
fn recipe() -> Recipe {
use ColorPickerPart::*;
use PaletteColor::{
Border as Edge, Foreground, Highlight, Muted, MutedForeground, Popover as Fill, PopoverForeground,
};
let white = Color::new(255, 255, 255, 255);
let thumb = move |s: PartStyle, side: f32| {
s.square(side)
.radius(RadiusSize::Full)
.border(Border::inside(2.0, white))
.cursor(CursorIcon::Pointer)
};
let recipe = Recipe::new()
.base(Root, |s| {
s.width(232.0)
.padding_x(12.0)
.padding_y(12.0)
.gap(12.0)
.radius(RadiusSize::Lg)
.background(Fill)
.foreground(PopoverForeground)
.border(Border::inside(1.0, Edge))
.shadow(ShadowStyle::Md)
})
.base(Area, |s| {
s.width(208.0)
.height(120.0)
.radius(RadiusSize::Md)
.cursor(CursorIcon::Crosshair)
})
.base(AreaThumb, move |s| thumb(s, 12.0))
.base(Hue, |s| {
s.height(10.0).radius(RadiusSize::Full).cursor(CursorIcon::Pointer)
})
.base(Alpha, |s| {
s.height(10.0).radius(RadiusSize::Full).cursor(CursorIcon::Pointer)
})
.base(Thumb, move |s| thumb(s, 14.0).shadow(ShadowStyle::Sm))
.base(Checker, |s| s.background(PaletteColor::Background))
.base(CheckerCell, |s| s.square(5.0).background(Muted))
.base(Swatches, |s| s.gap(8.0))
.base(Fields, |s| s.gap(6.0))
.base(Input, |s| {
text_box::box_style(s)
.height(ControlSize::Md)
.foreground(Foreground)
.font_family(FontFamily::Mono)
.font_size(14.0)
.weight(FontWeight::Normal)
})
.base(Format, |s| {
fading(s)
.height(ControlSize::Md)
.padding_x(8.0)
.radius(RadiusSize::Md)
.foreground(MutedForeground)
.font_family(FontFamily::Mono)
.font_size(12.0)
.cursor(CursorIcon::Pointer)
})
.hovered(Format, |s| s.background(Highlight).foreground(Foreground))
.focus_visible(Format, |s| s.focus_ring())
.base(FieldLabel, |s| s.font_size(11.0).foreground(MutedForeground))
.base(Eyedropper, |s| {
fading(s)
.square(ControlSize::Md)
.radius(RadiusSize::Md)
.foreground(MutedForeground)
.cursor(CursorIcon::Pointer)
})
.base(EyedropperIcon, |s| s.square(Length::Icon(IconSize::Md)))
.hovered(Eyedropper, |s| s.background(Highlight).foreground(Foreground))
.focus_visible(Eyedropper, |s| s.focus_ring())
.state(ColorPickerState::Disabled, Eyedropper, |s| {
s.cursor(CursorIcon::Default)
})
.focus_visible(Area, |s| s.focus_ring())
.focus_visible(Hue, |s| s.focus_ring())
.focus_visible(Alpha, |s| s.focus_ring())
.state(ColorPickerState::Bare, Root, |s| {
s.background(Color::new(0, 0, 0, 0))
.border(Border::inside(0.0, Color::new(0, 0, 0, 0)))
.shadow(BoxShadowValue::none())
.radius(0.0)
})
.state(ColorPickerState::Disabled, Root, |s| s.opacity(OpacityLevel::Disabled))
.state(ColorPickerState::Disabled, Area, |s| s.cursor(CursorIcon::Default))
.state(ColorPickerState::Disabled, Hue, |s| s.cursor(CursorIcon::Default))
.state(ColorPickerState::Disabled, Alpha, |s| s.cursor(CursorIcon::Default))
.state(ColorPickerState::Disabled, Format, |s| s.cursor(CursorIcon::Default));
text_box::box_rules(recipe, Root, Input, FieldLabel)
}
}