lib.rs

#![allow(clippy::type_complexity)]

use std::{collections::VecDeque, path::PathBuf, time::Duration};

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

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

impl Default for CosmicText {
    fn default() -> Self {
        Self::OneStyle(String::new())
    }
}

/// Enum representing the position of the cosmic text.
#[derive(Clone, Component, Default)]
pub enum CosmicTextPosition {
    #[default]
    Center,
    TopLeft,
}

#[derive(Event, Debug)]
pub struct CosmicTextChanged(pub (Entity, String));

// TODO docs
#[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 CosmicEditor {
    fn set_text(
        &mut self,
        text: CosmicText,
        attrs: AttrsOwned,
        font_system: &mut FontSystem,
    ) -> &mut Self {
        // TODO invoke trim_text here
        let editor = &mut self.0;
        editor.buffer_mut().lines.clear();
        match text {
            CosmicText::OneStyle(text) => {
                // TODO: this is a workaround
                // if `set_text` called with text length smaller than the current buffer cosmic-text panics
                // due to cursor being out of bounds.
                // Should be removed once https://github.com/StaffEngineer/bevy_cosmic_edit/issues/52 fixed.
                if text == *"" {
                    let mut current_cursor = editor.cursor();
                    current_cursor.line = 0;
                    current_cursor.index = 0;
                    editor.set_cursor(current_cursor);
                }
                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<
        (
            Entity,
            &mut CosmicText,
            &CosmicAttrs,
            &CosmicMetrics,
            &CosmicMaxChars,
            &CosmicMaxLines,
            Option<&ReadOnly>,
            Option<&Node>,
            Option<&Sprite>,
        ),
        Added<CosmicText>,
    >,
    mut font_system: ResMut<CosmicFontSystem>,
    mut commands: Commands,
) {
    for (entity, text, attrs, metrics, max_chars, max_lines, readonly, node, sprite) in
        added_editors.iter_mut()
    {
        let mut editor = Editor::new(Buffer::new(
            &mut font_system.0,
            Metrics::new(metrics.font_size, metrics.line_height).scale(metrics.scale_factor),
        ));

        if let Some(node) = node {
            editor
                .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
                    .buffer_mut()
                    .set_size(&mut font_system.0, size.x, size.y)
            }
        }

        // hide cursor on readonly buffers
        // TODO do this seperately, allow for readonly to be toggled
        let mut cursor = editor.cursor();
        if readonly.is_some() {
            cursor.color = Some(cosmic_text::Color::rgba(0, 0, 0, 0));
        }
        editor.set_cursor(cursor);

        let mut editor_component = CosmicEditor(editor);

        let text = trim_text(text.to_owned(), max_chars.0, max_lines.0);
        editor_component.set_text(text, attrs.0.clone(), &mut font_system.0);