guise-ui 1.5.2

//! `ColorInput` — a color picker field (gpui entity).
//!
//! A swatch plus an editable hex/CSS text field; clicking the swatch opens a
//! deferred dropdown with the full theme palette (14 colors x 10 shades).
//! Typing any [`css`](crate::theme::css)-parsable color — `#40c057`,
//! `rgb(64, 192, 87)`, `teal` — updates the swatch live. Emits
//! [`ColorInputEvent`] whenever the value changes.
//!
//! ```ignore
//! let brand = cx.new(|cx| ColorInput::new(cx).label("Brand color").value(rgb(34, 139, 230)));
//! cx.subscribe(&brand, |_this, _input, event: &ColorInputEvent, _cx| {
//!     let color: Hsla = event.0;
//! })
//! .detach();
//! ```

use gpui::prelude::*;
use gpui::{
  deferred, div, px, App, Context, Entity, EventEmitter, FocusHandle, Hsla, IntoElement,
  KeyDownEvent, SharedString, Window,
};

use super::line::{self, Line, LineEditor, LineState};
use super::{control_metrics, edit::TextEdit, Field, KeyOutcome};
use crate::devtools::ProbedAny;
use crate::reactive::Signal;
use crate::theme::{css, theme, Color, ColorName, Size};

/// Emitted when the color changes (typed, picked, or bound). Carries the color.
#[derive(Debug, Clone, Copy)]
pub struct ColorInputEvent(pub Hsla);

/// A color field with a palette dropdown. Create with
/// `cx.new(|cx| ColorInput::new(cx))`.
pub struct ColorInput {
  edit: TextEdit,
  state: LineState,
  value: Hsla,
  open: bool,
  focus: FocusHandle,
  label: Option<SharedString>,
  description: Option<SharedString>,
  error: Option<SharedString>,
  size: Size,
  disabled: bool,
}

impl EventEmitter<ColorInputEvent> for ColorInput {}

/// `#rrggbb` for a color, dropping alpha (the buffer holds opaque hex).
fn to_hex(color: Hsla) -> String {
  let c = Color::from_hsla(color);
  format!("#{:02x}{:02x}{:02x}", c.r, c.g, c.b)
}

/// This input's value is always opaque: the buffer renders `#rrggbb`, so a
/// value carrying alpha would desync the text from the swatch and the emitted
/// color. Every value entering the field passes through here.
fn opaque(color: Hsla) -> Hsla {
  Hsla { a: 1.0, ..color }
}

impl ColorInput {
  pub fn new(cx: &mut Context<Self>) -> Self {
    let value = gpui::black();
    ColorInput {
      edit: TextEdit::new(&to_hex(value)),
      state: LineState::new(),
      value,
      open: false,
      focus: cx.focus_handle().tab_stop(true),
      label: None,
      description: None,
      error: None,
      size: Size::Sm,
      disabled: false,
    }
  }

  /// The initial color (alpha is dropped). Also rewrites the text buffer
  /// as hex.
  pub fn value(mut self, color: impl Into<Hsla>) -> Self {
    let color = opaque(color.into());
    self.value = color;
    self.edit.set_text(&to_hex(color));
    self
  }

  pub fn label(mut self, label: impl Into<SharedString>) -> Self {
    self.label = Some(label.into());
    self
  }

  pub fn description(mut self, description: impl Into<SharedString>) -> Self {
    self.description = Some(description.into());
    self
  }

  pub fn error(mut self, error: impl Into<SharedString>) -> Self {
    self.error = Some(error.into());
    self
  }

  pub fn size(mut self, size: Size) -> Self {
    self.size = size;
    self
  }

  pub fn disabled(mut self, disabled: bool) -> Self {
    self.disabled = disabled;
    self
  }

  /// The current color.
  pub fn color_value(&self) -> Hsla {
    self.value
  }

  /// Two-way bind this input's color to a `Signal<Hsla>`. The signal is the
  /// source of truth: the input adopts its value now, picks and valid typed
  /// colors write back through [`Signal::set_if_changed`], and signal writes
  /// update the swatch and buffer without emitting [`ColorInputEvent`].
  /// Equality guards on both directions prevent update loops.
  pub fn bind(entity: &Entity<ColorInput>, signal: &Signal<Hsla>, cx: &mut App) {
    let initial = signal.get(cx);
    entity.update(cx, |this, cx| this.sync_value(initial, cx));
    let sink = signal.clone();
    cx.subscribe(entity, move |_input, event: &ColorInputEvent, cx| {
      sink.set_if_changed(cx, event.0);
    })
    .detach();
    let input = entity.downgrade();
    cx.observe(signal.entity(), move |observed, cx| {
      let value = *observed.read(cx);
      input.update(cx, |this, cx| this.sync_value(value, cx)).ok();
    })
    .detach();
  }

  /// Programmatic set: update swatch + buffer without emitting an event.
  fn sync_value(&mut self, color: Hsla, cx: &mut Context<Self>) {
    let color = opaque(color);
    if self.value != color {
      self.value = color;
      self.edit.set_text(&to_hex(color));
      cx.notify();
    }
  }

  /// A palette pick: set, normalize the buffer to hex, close, emit.
  fn choose(&mut self, color: Hsla, cx: &mut Context<Self>) {
    self.open = false;
    self.edit.set_text(&to_hex(color));
    if self.value != color {
      self.value = color;
      cx.emit(ColorInputEvent(color));
    }
    cx.notify();
  }

  /// Re-parse the buffer after an edit; a valid color updates the swatch.
  fn adopt_buffer(&mut self, cx: &mut Context<Self>) {
    if let Ok(color) = css(&self.edit.text()).map(opaque) {
      if self.value != color {
        self.value = color;
        cx.emit(ColorInputEvent(color));
      }
    }
  }

  fn on_key(&mut self, event: &KeyDownEvent, window: &mut Window, cx: &mut Context<Self>) {
    if self.disabled {
      return;
    }
    match line::keys(self, event, window, cx) {
      KeyOutcome::Submit => {
        self.adopt_buffer(cx);
        // Normalize whatever parsed (or the last valid color) to hex.
        self.edit.set_text(&to_hex(self.value));
        self.open = false;
        cx.notify();
        cx.stop_propagation();
      }
      KeyOutcome::Edited => {
        self.line_changed(cx);
        cx.stop_propagation();
      }
      KeyOutcome::Cancel => {
        // Escape closes the dropdown; bubbles when already closed.
        if self.open {
          self.open = false;
          cx.notify();
          cx.stop_propagation();
        }
      }
      KeyOutcome::Pass => {}
    }
  }
}

impl LineEditor for ColorInput {
  fn edit(&self) -> &TextEdit {
    &self.edit
  }

  fn edit_mut(&mut self) -> &mut TextEdit {
    &mut self.edit
  }

  fn line(&self) -> &LineState {
    &self.state
  }

  fn line_mut(&mut self) -> &mut LineState {
    &mut self.state
  }

  fn line_focus(&self) -> &FocusHandle {
    &self.focus
  }

  fn line_read_only(&self) -> bool {
    self.disabled
  }

  fn line_changed(&mut self, cx: &mut Context<Self>) {
    self.adopt_buffer(cx);
    cx.notify();
  }
}

line::line_input_handler!(ColorInput);
line::line_focus_builders!(ColorInput);

impl Render for ColorInput {
  fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
    // Wired before the theme is read: `theme(cx)` borrows `cx` immutably
    // and `wire` needs it mutably, and this render keeps `t` alive all the
    // way down into the palette grid.
    let wired = line::wire(div().id("guise-colorinput"), &self.focus, cx)
      .on_key_down(cx.listener(Self::on_key));
    let interior = Line::new(cx.entity());

    let t = theme(cx);
    let (height, pad_x, font) = control_metrics(self.size);
    let radius = t.radius(t.default_radius);
    let focused = self.focus.is_focused(window) && !self.disabled;

    let border = if self.error.is_some() {
      t.color(ColorName::Red, 6)
    } else if focused {
      t.primary()
    } else {
      t.border()
    }
    .hsla();
    let plain_border = t.border().hsla();
    let surface = t.surface().hsla();
    let swatch_px = height - 16.0;

    let swatch = div()
      .id("guise-colorinput-swatch")
      .flex_none()
      .w(px(swatch_px))
      .h(px(swatch_px))
      .rounded(px(4.0))
      .border_1()
      .border_color(plain_border)
      .bg(self.value)
      .cursor_pointer()
      .on_click(cx.listener(|this, _ev, window, cx| {
        if !this.disabled {
          this.open = !this.open;
          window.focus(&this.focus);
          cx.notify();
        }
      }));

    let field = wired
      .flex()
      .items_center()
      .gap(px(8.0))
      .h(px(height))
      .px(px(pad_x))
      .rounded(px(radius))
      .border_1()
      .border_color(border)
      .bg(surface)
      .text_size(px(font))
      .line_height(px(font * 1.3))
      .child(swatch)
      .child(div().flex_1().min_w(px(0.0)).child(interior));

    let mut wrap = div().relative().child(field);

    if self.open && !self.disabled {
      let current = Color::from_hsla(self.value);
      let mut grid = div()
        .occlude()
        .absolute()
        .top(px(height + 6.0))
        .left(px(0.0))
        .flex()
        .flex_col()
        .gap(px(2.0))
        .p(px(6.0))
        .rounded(px(radius))
        .border_1()
        .border_color(plain_border)
        .bg(surface)
        .shadow_md();

      for (row, name) in ColorName::ALL.into_iter().enumerate() {
        let mut cells = div().flex().flex_row().gap(px(2.0));
        for shade in 0..10 {
          let cell_color = t.color(name, shade);
          let cell_hsla = cell_color.hsla();
          let mut cell = div()
            .id(("guise-colorinput-cell", row * 10 + shade))
            .w(px(14.0))
            .h(px(14.0))
            .rounded(px(3.0))
            .bg(cell_hsla)
            .cursor_pointer()
            .on_click(cx.listener(move |this, _ev, _window, cx| {
              this.choose(cell_hsla, cx);
            }));
          if cell_color == current {
            cell = cell
              .border_2()
              .border_color(cell_color.contrasting().hsla());
          }
          cells = cells.child(cell);
        }
        grid = grid.child(cells);
      }

      wrap = wrap.child(deferred(grid));
    }

    let mut chrome = Field::new().child(if self.disabled {
      wrap.opacity(0.6)
    } else {
      wrap
    });
    if let Some(label) = self.label.clone() {
      chrome = chrome.label(label);
    }
    if let Some(error) = self.error.clone() {
      chrome = chrome.error(error);
    } else if let Some(description) = self.description.clone() {
      chrome = chrome.description(description);
    }
    chrome.probe_any("ColorInput")
  }
}

#[cfg(test)]
mod tests {
  use super::to_hex;
  use crate::theme::css;

  #[test]
  fn hex_round_trips_through_css_parsing() {
    for hex in [
      "#ff0000", "#00ff00", "#0000ff", "#ffffff", "#000000", "#808080",
    ] {
      assert_eq!(to_hex(css(hex).unwrap()), hex);
    }
  }

  #[test]
  fn alpha_is_dropped() {
    let translucent = css("rgba(255, 0, 0, 0.5)").unwrap();
    assert_eq!(to_hex(translucent), "#ff0000");
  }

  #[test]
  fn adopted_colors_are_opaque() {
    // The value the field adopts must match the hex it displays: an
    // rgba() input and its opaque rgb() twin resolve to the same color.
    let adopted = super::opaque(css("rgba(255, 0, 0, 0.5)").unwrap());
    assert_eq!(adopted, css("rgb(255, 0, 0)").unwrap());
    assert_eq!(adopted.a, 1.0);
  }
}