lib.rs

#![allow(clippy::type_complexity)]

use std::{collections::VecDeque, path::PathBuf, time::Duration};
#[path = "utils.rs"]
pub mod utils;
pub use utils::*;

use bevy::{
    asset::HandleId,
    input::mouse::{MouseScrollUnit, MouseWheel},
    prelude::*,
    render::{render_resource::Extent3d, texture::DEFAULT_IMAGE_HANDLE},
    ui::FocusPolicy,
    window::{PrimaryWindow, WindowScaleFactorChanged},
};
use cosmic_text::{
    Action, Attrs, AttrsList, AttrsOwned, Buffer, BufferLine, Cursor, Edit, Editor, FontSystem,
    Metrics, Shaping, SwashCache,
};
use image::{imageops::FilterType, GenericImageView};

#[derive(Clone)]
pub enum CosmicText {
    OneStyle(String),
    MultiStyle(Vec<Vec<(String, AttrsOwned)>>),
}

/// Enum representing the position of the cosmic text.
#[derive(Clone, Component, Default)]
pub enum CosmicTextPosition {
    // we have the space for full words :)
    #[default]
    Center,
    TopLeft,
}

#[derive(Clone, Component)]
pub struct CosmicMetrics {
    pub font_size: f32,
    pub line_height: f32,
    pub scale_factor: f32,
}

impl Default for CosmicMetrics {
    fn default() -> Self {
        Self {
            font_size: 12.,
            line_height: 12.,
            scale_factor: 1.,
        }
    }
}

#[derive(Resource)]
pub struct CosmicFontSystem(pub FontSystem);

#[derive(Component)]
pub struct ReadOnly; // tag component

#[derive(Component)]
pub struct CosmicEditor(pub Editor);

impl Default for CosmicEditor {
    fn default() -> Self {
        Self(Editor::new(Buffer::new_empty(Metrics::new(12., 14.))))
    }
}

impl CosmicEditor {
    pub fn set_text(
        &mut self,
        text: CosmicText,
        attrs: AttrsOwned,
        // i'd like to get the font system automagically but i'm too 3head -bytemunch
        font_system: &mut FontSystem,
    ) -> &mut Self {
        let editor = &mut self.0;
        editor.buffer_mut().lines.clear();
        match text {
            CosmicText::OneStyle(text) => {
                editor.buffer_mut().set_text(
                    font_system,
                    text.as_str(),
                    attrs.as_attrs(),
                    Shaping::Advanced,
                );
            }
            CosmicText::MultiStyle(lines) => {
                for line in lines {
                    let mut line_text = String::new();
                    let mut attrs_list = AttrsList::new(attrs.as_attrs());
                    for (text, attrs) in line.iter() {
                        let start = line_text.len();
                        line_text.push_str(text);
                        let end = line_text.len();
                        attrs_list.add_span(start..end, attrs.as_attrs());
                    }
                    editor.buffer_mut().lines.push(BufferLine::new(
                        line_text,
                        attrs_list,
                        Shaping::Advanced,
                    ));
                }
            }
        }
        self
    }

    /// Retrieves the cosmic text content from an editor.
    ///
    /// # Arguments
    ///
    /// * none, takes the rust magic ref to self
    ///
    /// # Returns
    ///
    /// A `String` containing the cosmic text content.
    pub fn get_text(&self) -> String {
        let buffer = self.0.buffer();
        let mut text = String::new();
        let line_count = buffer.lines.len();

        for (i, line) in buffer.lines.iter().enumerate() {
            text.push_str(line.text());

            if i < line_count - 1 {
                text.push('\n');
            }
        }

        text
    }
}

/// Adds the font system to each editor when added
fn cosmic_editor_builder(
    mut added_editors: Query<
        (
            &mut CosmicEditor,
            &CosmicAttrs,
            &CosmicMetrics,
            &BackgroundColor,
            Option<&ReadOnly>,
            Option<&Node>,
            Option<&Sprite>,
        ),
        Added<CosmicEditor>,
    >,
    mut font_system: ResMut<CosmicFontSystem>,
) {
    for (mut editor, attrs, metrics, background_color, readonly, node, sprite) in
        added_editors.iter_mut()
    {
        // keep old text if set
        let mut text = editor.get_text();

        if text.is_empty() {
            text = "".into();
            editor.0.buffer_mut().set_text(
                &mut font_system.0,
                text.as_str(),
                attrs.0.as_attrs(),
                Shaping::Advanced,
            );
        }

        editor.0.buffer_mut().set_metrics(
            &mut font_system.0,
            Metrics::new(metrics.font_size, metrics.line_height).scale(metrics.scale_factor),
        );

        if let Some(node) = node {
            editor
                .0
                .buffer_mut()
                .set_size(&mut font_system.0, node.size().x, node.size().y)
        }

        if let Some(sprite) = sprite {
            if let Some(size) = sprite.custom_size {
                editor
                    .0
                    .buffer_mut()
                    .set_size(&mut font_system.0, size.x, size.y)
            }
        }

        // hide cursor on readonly buffers
        let mut cursor = editor.0.cursor();
        if readonly.is_some() {
            cursor.color = Some(bevy_color_to_cosmic(background_color.0));
        }
        editor.0.set_cursor(cursor);
    }
}

#[derive(Component)]
pub struct CosmicAttrs(pub AttrsOwned);

impl Default for CosmicAttrs {