Struct Axis 

pub struct Axis<D, Theme = Theme> { /* private fields */ }

An axis that maps data values to screen coordinates.

The Axis struct is responsible for:

1. Defining the scale (linear, log, etc.) for mapping data to pixels.
2. Configuring visual elements like ticks, grid lines, and labels.
3. Handling layout and rendering of the axis and its interactive marker.

Example

use iced_aksel::{Axis, axis::{Position, TickResult, TickContext}, scale::Linear};

let axis = Axis::new(Linear::new(0.0, 100.0), Position::Bottom)
    .with_thickness(40.0)
    .with_tick_renderer(|ctx: TickContext<f64>| TickResult {
        tick_line: Some(ctx.tickline()),
        grid_line: Some(ctx.gridline()),
        label: Some(ctx.label(format!("{:.2}", ctx.tick.value))),
        ..Default::default()
    });

Implementations

impl<D: Float, Theme> Axis<D, Theme>

pub fn new( scale: impl Scale<Domain = D, Normalized = f32> + 'static, position: Position, ) -> Self

Creates a new Axis with the given scale and position.

By default, the axis will render:

• Major ticks with labels
• Minor ticks (smaller lines)
• Grid lines aligned with major ticks

pub fn with_thickness<P: Into<Pixels>>(self, thickness: P) -> Self

Sets the reserved thickness of the axis in pixels.

This determines the space reserved for the axis in the chart layout. Increase this if your labels are being clipped or overlapping with the chart area.

pub fn style<F>(self, style_fn: F) -> Self

where F: FnMut(&mut AxisStyle) + 'static,

Adds a function that overrides the default styling coming from chart.

If you just want to set a general style for the chart in general, see crate::Chart instead.

pub fn with_tick_renderer<F>(self, renderer: F) -> Self

where F: FnMut(TickContext<'_, D, Theme>) -> TickResult + 'static,

Sets a custom renderer for ticks.

This function gives you full control over which ticks render lines, grids, or labels.

Example

iced_aksel::axis::Position::Bottom);
axis.with_tick_renderer(|ctx: TickContext<f64>| {
    if ctx.tick.level == 0 {
        TickResult::with_label(ctx.label(format!("{:.1}", ctx.tick.value)))
    } else {
        TickResult::default() // Empty tick result
    }
});

pub const fn without_grid(self) -> Self

Disables grid line rendering for this axis.

pub fn skip_overlapping_labels(self, min_gap_px: f32) -> Self

Configures the axis to skip labels that would overlap.

min_gap_px specifies the minimum distance in pixels required between labels.

pub fn with_custom_label_policy<F>(self, policy: F) -> Self

where F: for<'a> Fn(LabelDecisionContext<'a, D>) -> LabelDecision + 'static,

Sets a custom policy for determining which labels to render.

Useful for advanced collision detection or custom filtering logic.

pub const fn invisible(self) -> Self

Makes the axis invisible.

It will still occupy layout space (defined by thickness) but will not render any ticks, lines, or labels. To remove it from layout entirely, set thickness to 0.

pub fn set_skip_overlapping_labels(&mut self, min_gap_px: f32)

Configures the axis to skip labels that would overlap.

min_gap_px specifies the minimum distance in pixels required between labels.

pub fn set_tick_renderer<F>(&mut self, renderer: F)

where F: Fn(TickContext<'_, D, Theme>) -> TickResult + 'static,

Updates the tick renderer in-place.

pub const fn set_visibility(&mut self, visible: bool)

Sets the visibility of the axis.

pub fn set_thickness<P: Into<Pixels>>(&mut self, thickness: P)

Updates the thickness of the axis in-place.

pub const fn is_visible(&self) -> bool

Returns true if the axis is currently visible.

pub fn domain(&self) -> (&D, &D)

Returns the data domain (min, max) of the axis.

pub const fn position(&self) -> &Position

Returns the layout position of the axis.

pub fn orientation(&self) -> Orientation

Returns the orientation (Horizontal/Vertical) based on the position.

pub const fn thickness(&self) -> Pixels

Returns the current thickness of the axis.

Trait Implementations

impl<D, Theme> Debug for Axis<D, Theme>

fn fmt(&self, __f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<D: Float, Theme> Deref for Axis<D, Theme>

type Target = dyn Scale<Normalized = f32, Domain = D>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<D: Float, Theme> DerefMut for Axis<D, Theme>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.