pine_interpreter/

output.rs

// Output-related types, traits, and implementations

use std::collections::HashMap;

/// Represents a color with RGBA components
#[derive(Clone, Debug, PartialEq)]
pub struct Color {
    pub r: u8, // Red component (0-255)
    pub g: u8, // Green component (0-255)
    pub b: u8, // Blue component (0-255)
    pub t: u8, // Transparency (0-100)
}

impl Color {
    pub fn new(r: u8, g: u8, b: u8, t: u8) -> Self {
        Color { r, g, b, t }
    }
}

/// Represents a label drawable object
#[derive(Clone, Debug)]
pub struct Label {
    pub x: f64,
    pub y: f64,
    pub text: String,
    pub xloc: String,
    pub yloc: String,
    pub color: Option<Color>,
    pub style: String,
    pub textcolor: Option<Color>,
    pub size: String,
    pub textalign: String,
    pub tooltip: Option<String>,
    pub text_font_family: String,
}

/// Represents a box drawable object
/// A `fill(...)` between two plots or hlines.
#[derive(Clone, Debug)]
pub struct FillObject {
    /// Id of the first plot/hline (`None` when it was `na`).
    pub id1: Option<usize>,
    /// Id of the second plot/hline.
    pub id2: Option<usize>,
    pub color: Option<Color>,
    pub title: String,
}

/// Chart-wide settings written by global functions like `bgcolor`/`barcolor`.
#[derive(Clone, Debug, Default)]
pub struct GlobalContext {
    /// Background color (`bgcolor`).
    pub bgcolor: Option<Color>,
    /// Price-bar color (`barcolor`).
    pub barcolor: Option<Color>,
}

/// An `alertcondition(...)` declaration — a named alert with a message.
#[derive(Clone, Debug, Default)]
pub struct AlertCondition {
    pub title: String,
    pub message: String,
}

/// The `indicator(...)` declaration — a script's identity and display settings.
#[derive(Clone, Debug, Default)]
pub struct Indicator {
    pub title: String,
    pub shorttitle: String,
    pub overlay: bool,
    pub format: String,
    pub precision: Option<i64>,
    pub timeframe: String,
}

/// A trend line drawn between two points, `(x1, y1)`–`(x2, y2)`.
#[derive(Clone, Debug)]
pub struct LineObject {
    pub x1: f64,
    pub y1: f64,
    pub x2: f64,
    pub y2: f64,
    pub xloc: String,
    pub extend: String,
    pub color: Option<Color>,
    pub style: String,
    pub width: f64,
}

/// One cell of a [`Table`].
#[derive(Clone, Debug, Default)]
pub struct TableCell {
    pub text: String,
    pub text_color: Option<Color>,
    pub bgcolor: Option<Color>,
    pub text_size: String,
    pub text_halign: String,
    pub text_valign: String,
}

/// A table overlay: a fixed grid of cells anchored to a chart position.
#[derive(Clone, Debug)]
pub struct Table {
    pub position: String,
    pub columns: usize,
    pub rows: usize,
    pub bgcolor: Option<Color>,
    pub cells: HashMap<(usize, usize), TableCell>,
}

#[derive(Clone, Debug)]
pub struct PineBox {
    pub left: f64,
    pub top: f64,
    pub right: f64,
    pub bottom: f64,
    pub border_color: Option<Color>,
    pub border_width: f64,
    pub border_style: String,
    pub extend: String,
    pub xloc: String,
    pub bgcolor: Option<Color>,
    pub text: String,
    pub text_size: f64,
    pub text_color: Option<Color>,
    pub text_halign: String,
    pub text_valign: String,
    pub text_wrap: String,
    pub text_font_family: String,
}

/// Represents a plot output
#[derive(Clone, Debug, Default)]
pub struct Plot {
    pub series: f64,
    pub title: String,
    pub color: Option<Color>,
    pub linewidth: f64,
    pub style: String,
    pub trackprice: bool,
    pub histbase: f64,
    pub offset: f64,
    pub join: bool,
    pub editable: bool,
    pub show_last: Option<f64>,
    pub display: String,
    pub format: Option<String>,
    pub precision: Option<f64>,
    pub force_overlay: bool,
    pub linestyle: String,
}

/// Represents a plotarrow output
#[derive(Clone, Debug)]
pub struct Plotarrow {
    pub series: f64,
    pub title: String,
    pub colorup: Option<Color>,
    pub colordown: Option<Color>,
    pub offset: f64,
    pub minheight: f64,
    pub maxheight: f64,
    pub editable: bool,
    pub show_last: Option<f64>,
    pub display: String,
    pub format: Option<String>,
    pub precision: Option<f64>,
    pub force_overlay: bool,
}

/// Represents a plotbar output
#[derive(Clone, Debug)]
pub struct Plotbar {
    pub open: f64,
    pub high: f64,
    pub low: f64,
    pub close: f64,
    pub title: String,
    pub color: Option<Color>,
    pub editable: bool,
    pub show_last: Option<f64>,
    pub display: String,
    pub format: Option<String>,
    pub precision: Option<f64>,
    pub force_overlay: bool,
}

/// Represents a plotcandle output
#[derive(Clone, Debug)]
pub struct Plotcandle {
    pub open: f64,
    pub high: f64,
    pub low: f64,
    pub close: f64,
    pub title: String,
    pub color: Option<Color>,
    pub wickcolor: Option<Color>,
    pub editable: bool,
    pub show_last: Option<f64>,
    pub bordercolor: Option<Color>,
    pub display: String,
    pub format: Option<String>,
    pub precision: Option<f64>,
    pub force_overlay: bool,
}

/// Represents a plotchar output
#[derive(Clone, Debug)]
pub struct Plotchar {
    pub series: f64,
    pub title: String,
    pub char: String,
    pub location: String,
    pub color: Option<Color>,
    pub offset: f64,
    pub text: String,
    pub textcolor: Option<Color>,
    pub editable: bool,
    pub size: String,
    pub show_last: Option<f64>,
    pub display: String,
    pub format: Option<String>,
    pub precision: Option<f64>,
    pub force_overlay: bool,
}

/// Represents a plotshape output
#[derive(Clone, Debug)]
pub struct Plotshape {
    pub series: f64,
    pub title: String,
    pub style: String,
    pub location: String,
    pub color: Option<Color>,
    pub offset: f64,
    pub text: String,
    pub textcolor: Option<Color>,
    pub editable: bool,
    pub size: String,
    pub show_last: Option<f64>,
    pub display: String,
    pub format: Option<String>,
    pub precision: Option<f64>,
    pub force_overlay: bool,
}

/// Log level
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LogLevel {
    Info,
    Warning,
    Error,
}

/// A log entry with level and message
#[derive(Debug, Clone)]
pub struct LogEntry {
    pub level: LogLevel,
    pub message: String,
}

/// The default value of a declared input, preserved with its type so a host can
/// render the right settings widget.
#[derive(Debug, Clone, PartialEq)]
pub enum InputValue {
    Int(i64),
    Float(f64),
    Bool(bool),
    Str(String),
    Color(Color),
}

/// A declared script input (`input.int(...)`, `input.source(...)`, ...).
///
/// Recorded into the output so a host can enumerate a script's configurable
/// settings without executing anything itself. The script still receives the
/// default value at runtime.
#[derive(Debug, Clone)]
pub struct Input {
    /// Which `input.*` function declared it: `"int"`, `"float"`, `"bool"`,
    /// `"string"`, `"source"`, `"color"`, `"session"`, `"time"`.
    pub kind: String,
    /// Display title (`title` argument), empty when none was given.
    pub title: String,
    /// Group the input belongs to (`group` argument), empty when none.
    pub group: String,
    /// Default value returned to the script.
    pub default: InputValue,
}

/// Base trait for all output implementations
///
/// This trait defines the minimal contract that all output types must implement.
/// Extension traits (LogOutput, PlotOutput, etc.) add additional capabilities.
pub trait PineOutput: Default + Clone + std::fmt::Debug + 'static {
    /// Clear all output data for a new iteration
    fn clear(&mut self);
}

/// Extension trait for logging output
pub trait LogOutput: PineOutput {
    /// Add a log entry with the given level and message
    fn add_log(&mut self, level: LogLevel, message: String);
    /// Get all log entries
    fn get_logs(&self) -> &[LogEntry];
}

/// Macro to easily implement all output traits by delegating to a base field
///
/// # Example
/// ```ignore
/// impl_output_traits_delegate!(CustomOutput, base);
/// ```
#[macro_export]
macro_rules! impl_output_traits_delegate {
    ($type:ty, $field:ident) => {
        impl $crate::LogOutput for $type {
            fn add_log(&mut self, level: $crate::LogLevel, message: String) {
                self.$field.add_log(level, message)
            }
            fn get_logs(&self) -> &[$crate::LogEntry] {
                self.$field.get_logs()
            }
        }

        impl $crate::PlotOutput for $type {
            fn add_plot(&mut self, plot: $crate::Plot) {
                self.$field.add_plot(plot)
            }
            fn plots(&self) -> &[$crate::Plot] {
                self.$field.plots()
            }
            fn add_plotarrow(&mut self, arrow: $crate::Plotarrow) {
                self.$field.add_plotarrow(arrow)
            }
            fn plotarrows(&self) -> &[$crate::Plotarrow] {
                self.$field.plotarrows()
            }
            fn add_plotbar(&mut self, bar: $crate::Plotbar) {
                self.$field.add_plotbar(bar)
            }
            fn plotbars(&self) -> &[$crate::Plotbar] {
                self.$field.plotbars()
            }
            fn add_plotcandle(&mut self, candle: $crate::Plotcandle) {
                self.$field.add_plotcandle(candle)
            }
            fn plotcandles(&self) -> &[$crate::Plotcandle] {
                self.$field.plotcandles()
            }
            fn add_plotchar(&mut self, char: $crate::Plotchar) {
                self.$field.add_plotchar(char)
            }
            fn plotchars(&self) -> &[$crate::Plotchar] {
                self.$field.plotchars()
            }
            fn add_plotshape(&mut self, shape: $crate::Plotshape) {
                self.$field.add_plotshape(shape)
            }
            fn plotshapes(&self) -> &[$crate::Plotshape] {
                self.$field.plotshapes()
            }
        }

        impl $crate::LabelOutput for $type {
            fn add_label(&mut self, label: $crate::Label) -> usize {
                self.$field.add_label(label)
            }
            fn get_label(&self, id: usize) -> Option<&$crate::Label> {
                self.$field.get_label(id)
            }
            fn get_label_mut(&mut self, id: usize) -> Option<&mut $crate::Label> {
                self.$field.get_label_mut(id)
            }
            fn delete_label(&mut self, id: usize) -> bool {
                self.$field.delete_label(id)
            }
        }

        impl $crate::BoxOutput for $type {
            fn add_box(&mut self, box_obj: $crate::PineBox) -> usize {
                self.$field.add_box(box_obj)
            }
            fn get_box(&self, id: usize) -> Option<&$crate::PineBox> {
                self.$field.get_box(id)
            }
            fn get_box_mut(&mut self, id: usize) -> Option<&mut $crate::PineBox> {
                self.$field.get_box_mut(id)
            }
            fn delete_box(&mut self, id: usize) -> bool {
                self.$field.delete_box(id)
            }
        }

        impl $crate::InputOutput for $type {
            fn add_input(&mut self, input: $crate::Input) {
                self.$field.add_input(input)
            }
            fn inputs(&self) -> &[$crate::Input] {
                self.$field.inputs()
            }
        }

        impl $crate::IndicatorOutput for $type {
            fn set_indicator(&mut self, indicator: $crate::Indicator) {
                self.$field.set_indicator(indicator)
            }
            fn indicator(&self) -> Option<&$crate::Indicator> {
                self.$field.indicator()
            }
        }

        impl $crate::AlertConditionOutput for $type {
            fn add_alertcondition(&mut self, alert: $crate::AlertCondition) {
                self.$field.add_alertcondition(alert)
            }
            fn alertconditions(&self) -> &[$crate::AlertCondition] {
                self.$field.alertconditions()
            }
        }

        impl $crate::FillOutput for $type {
            fn add_fill(&mut self, fill: $crate::FillObject) {
                self.$field.add_fill(fill)
            }
            fn fills(&self) -> &[$crate::FillObject] {
                self.$field.fills()
            }
        }

        impl $crate::GlobalOutput for $type {
            fn set_bgcolor(&mut self, color: Option<$crate::Color>) {
                self.$field.set_bgcolor(color)
            }
            fn set_barcolor(&mut self, color: Option<$crate::Color>) {
                self.$field.set_barcolor(color)
            }
            fn global_context(&self) -> &$crate::GlobalContext {
                self.$field.global_context()
            }
        }

        impl $crate::LineOutput for $type {
            fn add_line(&mut self, line: $crate::LineObject) -> usize {
                self.$field.add_line(line)
            }
            fn get_line(&self, id: usize) -> Option<&$crate::LineObject> {
                self.$field.get_line(id)
            }
            fn get_line_mut(&mut self, id: usize) -> Option<&mut $crate::LineObject> {
                self.$field.get_line_mut(id)
            }
            fn delete_line(&mut self, id: usize) -> bool {
                self.$field.delete_line(id)
            }
        }

        impl $crate::TableOutput for $type {
            fn add_table(&mut self, table: $crate::Table) -> usize {
                self.$field.add_table(table)
            }
            fn get_table(&self, id: usize) -> Option<&$crate::Table> {
                self.$field.get_table(id)
            }
            fn get_table_mut(&mut self, id: usize) -> Option<&mut $crate::Table> {
                self.$field.get_table_mut(id)
            }
            fn delete_table(&mut self, id: usize) -> bool {
                self.$field.delete_table(id)
            }
        }
    };
}

/// Extension trait for plot-related output
pub trait PlotOutput: PineOutput {
    /// Add a plot output
    fn add_plot(&mut self, plot: Plot);
    /// Get all plot outputs
    fn plots(&self) -> &[Plot];

    /// Add a plotarrow output
    fn add_plotarrow(&mut self, arrow: Plotarrow);
    /// Get all plotarrow outputs
    fn plotarrows(&self) -> &[Plotarrow];

    /// Add a plotbar output
    fn add_plotbar(&mut self, bar: Plotbar);
    /// Get all plotbar outputs
    fn plotbars(&self) -> &[Plotbar];

    /// Add a plotcandle output
    fn add_plotcandle(&mut self, candle: Plotcandle);
    /// Get all plotcandle outputs
    fn plotcandles(&self) -> &[Plotcandle];

    /// Add a plotchar output
    fn add_plotchar(&mut self, char: Plotchar);
    /// Get all plotchar outputs
    fn plotchars(&self) -> &[Plotchar];

    /// Add a plotshape output
    fn add_plotshape(&mut self, shape: Plotshape);
    /// Get all plotshape outputs
    fn plotshapes(&self) -> &[Plotshape];
}

/// Extension trait for label output
pub trait LabelOutput: PineOutput {
    /// Add a label and return its ID
    fn add_label(&mut self, label: Label) -> usize;
    /// Get a reference to a label by ID
    fn get_label(&self, id: usize) -> Option<&Label>;
    /// Get a mutable reference to a label by ID
    fn get_label_mut(&mut self, id: usize) -> Option<&mut Label>;
    /// Delete a label by ID and return true if it existed
    fn delete_label(&mut self, id: usize) -> bool;
}

/// Extension trait for box output
pub trait BoxOutput: PineOutput {
    /// Add a box and return its ID
    fn add_box(&mut self, box_obj: PineBox) -> usize;
    /// Get a reference to a box by ID
    fn get_box(&self, id: usize) -> Option<&PineBox>;
    /// Get a mutable reference to a box by ID
    fn get_box_mut(&mut self, id: usize) -> Option<&mut PineBox>;
    /// Delete a box by ID and return true if it existed
    fn delete_box(&mut self, id: usize) -> bool;
}

/// Extension trait for table output
pub trait TableOutput: PineOutput {
    /// Add a table and return its ID
    fn add_table(&mut self, table: Table) -> usize;
    /// Get a reference to a table by ID
    fn get_table(&self, id: usize) -> Option<&Table>;
    /// Get a mutable reference to a table by ID
    fn get_table_mut(&mut self, id: usize) -> Option<&mut Table>;
    /// Delete a table by ID and return true if it existed
    fn delete_table(&mut self, id: usize) -> bool;
}

/// Extension trait for line output
pub trait LineOutput: PineOutput {
    /// Add a line and return its ID
    fn add_line(&mut self, line: LineObject) -> usize;
    /// Get a reference to a line by ID
    fn get_line(&self, id: usize) -> Option<&LineObject>;
    /// Get a mutable reference to a line by ID
    fn get_line_mut(&mut self, id: usize) -> Option<&mut LineObject>;
    /// Delete a line by ID and return true if it existed
    fn delete_line(&mut self, id: usize) -> bool;
}

/// Extension trait for recording `fill(...)` areas.
pub trait FillOutput: PineOutput {
    fn add_fill(&mut self, fill: FillObject);
    fn fills(&self) -> &[FillObject];
}

/// Extension trait for chart-wide globals (`bgcolor`, `barcolor`).
pub trait GlobalOutput: PineOutput {
    fn set_bgcolor(&mut self, color: Option<Color>);
    fn set_barcolor(&mut self, color: Option<Color>);
    /// The accumulated chart-wide settings.
    fn global_context(&self) -> &GlobalContext;
}

/// Extension trait for recording declared alert conditions.
pub trait AlertConditionOutput: PineOutput {
    /// Record a declared alert condition.
    fn add_alertcondition(&mut self, alert: AlertCondition);
    /// Every alert condition declared so far, in declaration order.
    fn alertconditions(&self) -> &[AlertCondition];
}

/// Extension trait for the script's `indicator(...)` declaration.
pub trait IndicatorOutput: PineOutput {
    /// Record the indicator declaration (a script has at most one).
    fn set_indicator(&mut self, indicator: Indicator);
    /// The declaration, if the script declared one.
    fn indicator(&self) -> Option<&Indicator>;
}

/// Extension trait for recording declared inputs
pub trait InputOutput: PineOutput {
    /// Record a declared input.
    fn add_input(&mut self, input: Input);
    /// Every input declared so far, in declaration order.
    fn inputs(&self) -> &[Input];
}

/// Default implementation of PineOutput that supports all features
#[derive(Default, Clone, Debug)]
pub struct DefaultPineOutput {
    /// Label storage for drawable objects
    labels: HashMap<usize, Label>,
    /// Next label ID
    next_label_id: usize,
    /// Box storage for drawable objects
    boxes: HashMap<usize, PineBox>,
    /// Next box ID
    next_box_id: usize,
    /// Line storage for drawable objects
    lines: HashMap<usize, LineObject>,
    /// Next line ID
    next_line_id: usize,
    /// Table storage for drawable objects
    tables: HashMap<usize, Table>,
    /// Next table ID
    next_table_id: usize,
    /// Plot outputs
    plots: Vec<Plot>,
    /// Plotarrow outputs
    plotarrows: Vec<Plotarrow>,
    /// Plotbar outputs
    plotbars: Vec<Plotbar>,
    /// Plotcandle outputs
    plotcandles: Vec<Plotcandle>,
    /// Plotchar outputs
    plotchars: Vec<Plotchar>,
    /// Plotshape outputs
    plotshapes: Vec<Plotshape>,
    /// Log entries
    logs: Vec<LogEntry>,
    /// Declared inputs
    inputs: Vec<Input>,
    /// The `indicator(...)` declaration, if any.
    indicator: Option<Indicator>,
    /// Chart-wide settings (`bgcolor`, `barcolor`).
    globals: GlobalContext,
    /// Declared alert conditions.
    alertconditions: Vec<AlertCondition>,
    /// `fill(...)` areas.
    fills: Vec<FillObject>,
}

impl PineOutput for DefaultPineOutput {
    fn clear(&mut self) {
        self.labels.clear();
        self.boxes.clear();
        self.plots.clear();
        self.plotarrows.clear();
        self.plotbars.clear();
        self.plotcandles.clear();
        self.plotchars.clear();
        self.plotshapes.clear();
        self.logs.clear();
        self.inputs.clear();
        self.indicator = None;
        self.globals = GlobalContext::default();
        self.alertconditions.clear();
        self.fills.clear();
        self.lines.clear();
        self.tables.clear();
        // Reset ID counters
        self.next_label_id = 0;
        self.next_box_id = 0;
        self.next_line_id = 0;
        self.next_table_id = 0;
    }
}

impl LogOutput for DefaultPineOutput {
    fn add_log(&mut self, level: LogLevel, message: String) {
        self.logs.push(LogEntry { level, message });
    }

    fn get_logs(&self) -> &[LogEntry] {
        &self.logs
    }
}

impl PlotOutput for DefaultPineOutput {
    fn add_plot(&mut self, plot: Plot) {
        self.plots.push(plot);
    }

    fn plots(&self) -> &[Plot] {
        &self.plots
    }

    fn add_plotarrow(&mut self, arrow: Plotarrow) {
        self.plotarrows.push(arrow);
    }

    fn plotarrows(&self) -> &[Plotarrow] {
        &self.plotarrows
    }

    fn add_plotbar(&mut self, bar: Plotbar) {
        self.plotbars.push(bar);
    }

    fn plotbars(&self) -> &[Plotbar] {
        &self.plotbars
    }

    fn add_plotcandle(&mut self, candle: Plotcandle) {
        self.plotcandles.push(candle);
    }

    fn plotcandles(&self) -> &[Plotcandle] {
        &self.plotcandles
    }

    fn add_plotchar(&mut self, char: Plotchar) {
        self.plotchars.push(char);
    }

    fn plotchars(&self) -> &[Plotchar] {
        &self.plotchars
    }

    fn add_plotshape(&mut self, shape: Plotshape) {
        self.plotshapes.push(shape);
    }

    fn plotshapes(&self) -> &[Plotshape] {
        &self.plotshapes
    }
}

impl LabelOutput for DefaultPineOutput {
    fn add_label(&mut self, label: Label) -> usize {
        let id = self.next_label_id;
        self.next_label_id += 1;
        self.labels.insert(id, label);
        id
    }

    fn get_label(&self, id: usize) -> Option<&Label> {
        self.labels.get(&id)
    }

    fn get_label_mut(&mut self, id: usize) -> Option<&mut Label> {
        self.labels.get_mut(&id)
    }

    fn delete_label(&mut self, id: usize) -> bool {
        self.labels.remove(&id).is_some()
    }
}

impl BoxOutput for DefaultPineOutput {
    fn add_box(&mut self, box_obj: PineBox) -> usize {
        let id = self.next_box_id;
        self.next_box_id += 1;
        self.boxes.insert(id, box_obj);
        id
    }

    fn get_box(&self, id: usize) -> Option<&PineBox> {
        self.boxes.get(&id)
    }

    fn get_box_mut(&mut self, id: usize) -> Option<&mut PineBox> {
        self.boxes.get_mut(&id)
    }

    fn delete_box(&mut self, id: usize) -> bool {
        self.boxes.remove(&id).is_some()
    }
}

impl LineOutput for DefaultPineOutput {
    fn add_line(&mut self, line: LineObject) -> usize {
        let id = self.next_line_id;
        self.next_line_id += 1;
        self.lines.insert(id, line);
        id
    }

    fn get_line(&self, id: usize) -> Option<&LineObject> {
        self.lines.get(&id)
    }

    fn get_line_mut(&mut self, id: usize) -> Option<&mut LineObject> {
        self.lines.get_mut(&id)
    }

    fn delete_line(&mut self, id: usize) -> bool {
        self.lines.remove(&id).is_some()
    }
}

impl TableOutput for DefaultPineOutput {
    fn add_table(&mut self, table: Table) -> usize {
        let id = self.next_table_id;
        self.next_table_id += 1;
        self.tables.insert(id, table);
        id
    }

    fn get_table(&self, id: usize) -> Option<&Table> {
        self.tables.get(&id)
    }

    fn get_table_mut(&mut self, id: usize) -> Option<&mut Table> {
        self.tables.get_mut(&id)
    }

    fn delete_table(&mut self, id: usize) -> bool {
        self.tables.remove(&id).is_some()
    }
}

impl InputOutput for DefaultPineOutput {
    fn add_input(&mut self, input: Input) {
        self.inputs.push(input);
    }

    fn inputs(&self) -> &[Input] {
        &self.inputs
    }
}

impl IndicatorOutput for DefaultPineOutput {
    fn set_indicator(&mut self, indicator: Indicator) {
        self.indicator = Some(indicator);
    }

    fn indicator(&self) -> Option<&Indicator> {
        self.indicator.as_ref()
    }
}

impl AlertConditionOutput for DefaultPineOutput {
    fn add_alertcondition(&mut self, alert: AlertCondition) {
        self.alertconditions.push(alert);
    }

    fn alertconditions(&self) -> &[AlertCondition] {
        &self.alertconditions
    }
}

impl FillOutput for DefaultPineOutput {
    fn add_fill(&mut self, fill: FillObject) {
        self.fills.push(fill);
    }

    fn fills(&self) -> &[FillObject] {
        &self.fills
    }
}

impl GlobalOutput for DefaultPineOutput {
    fn set_bgcolor(&mut self, color: Option<Color>) {
        self.globals.bgcolor = color;
    }

    fn set_barcolor(&mut self, color: Option<Color>) {
        self.globals.barcolor = color;
    }

    fn global_context(&self) -> &GlobalContext {
        &self.globals
    }
}