+Cargo.lock \ No newline at end of file

+name = "gracilaria"

+

+tree-sitter = "0.25.0"

+tree-sitter-rust = "0.24"

+tree-sitter-highlight = "0.25.0"

+car = "0.1.2"

+memchr = "2.7.5"

+

+[build-dependencies]

+cc = "*"

+#![feature(generic_const_exprs, const_trait_impl)]

+use std::sync::LazyLock;

+

+ let ppem = 15.0;

+ let ls = 20.0;

+ let mut text = TextArea::default();

+ std::env::args().nth(1).map(|x| {

+ text.insert(&std::fs::read_to_string(x).unwrap());

+ });

+

+ let context =

+ softbuffer::Context::new(window.clone()).unwrap();

+ |_elwt, (window, context)| {

+ softbuffer::Surface::new(context, window.clone()).unwrap()

+ },

+ .with_event_handler(

+ move |(window, _context), surface, event, elwt| {

+ elwt.set_control_flow(ControlFlow::Wait);

+ match event {

+ Event::WindowEvent {

+ window_id,

+ event: WindowEvent::Resized(size),

+ } if window_id == window.id() => {

+ let Some(surface) = surface else {

+ eprintln!("Resized fired before Resumed or after Suspended");

+ return;

+ };

+ if let (Some(width), Some(height)) =

+ (NonZeroU32::new(size.width), NonZeroU32::new(size.height))

+ {

+ surface.resize(width, height).unwrap();

+ }

+ }

+ Event::WindowEvent {

+ window_id,

+ event: WindowEvent::RedrawRequested,

+ } if window_id == window.id() => {

+ let Some(surface) = surface else {

+ eprintln!("RedrawRequested fired before Resumed or after Suspended");

+ return;

+ };

+ let size = window.inner_size();

+ if let (Some(width), Some(height)) =

+ {

+ let (c, r) = dsb::fit(&FONT,ppem,ls, (size.width as _,size.height as _));

+ let cells =text.cells((c, r),[204, 202, 194], [36, 41, 54],);

+ let r = unsafe {

+ dsb::render(&cells, (c, r), ppem, [36, 41, 54],dsb::Fonts::new(*FONT, *FONT, *FONT, *FONT),

+ ls, false)};

+ let mut buffer = surface.buffer_mut().unwrap();

+ for y in 0..height.get() {

+ for x in 0..width.get() {

+ let [red, green, blue] =r.get_pixel(x, y).unwrap_or_default().map(_ as u32);

+ let index = y as usize * width.get() as usize + x as usize;

+ buffer[index] = blue | (green << 8) | (red << 16);

+ }

+

+ buffer.present().unwrap();

+ }

+ Event::WindowEvent {

+ event:

+ WindowEvent::CloseRequested

+ ,

+ window_id,

+ } if window_id == window.id() => {

+ elwt.exit();

+ Event::WindowEvent{

+ event:WindowEvent::KeyboardInput { device_id, event, is_synthetic }, window_id

+ } if event.state == ElementState::Pressed => {

+

+ match dbg!(event.logical_key ){

+ Key::Named(NamedKey::Space)=>

+ text.insert(" "),

+ Key::Named(NamedKey::Backspace) => text.backspace(),

+ Key::Named(NamedKey::Enter)=>

+ text.insert("\n"),

+ Key::Character(x) => {

+ text.insert(&*x);

+ }

+ _ =>{}

+ }

+ }

+ _ => {}

+ },

+ );

+use std::os::fd::AsRawFd;

+use atools::Chunked;

+use tree_sitter::{InputEdit, Language, Parser, Point, Tree};

+use tree_sitter_highlight::{

+ HighlightConfiguration, HighlightEvent, Highlighter,

+};

+#[rustfmt::skip]

+const NAMES: [&str; 13] = ["attribute", "comment", "constant", "function", "keyword", "number", "operator", "punctuation",

+ "string", "tag", "type", "variable", "variable.parameter"];

+#[rustfmt::skip]

+const COLORS: [[u8; 3]; 13] = car::map!(

+ [

+ b"ffd173", b"5c6773", b"DFBFFF", b"FFD173", b"FFAD66", b"dfbfff", b"F29E74", b"cccac2",

+ b"D5FF80", b"DFBFFF", b"73D0FF", b"5ccfe6", b"5ccfe6"

+ ],

+ |x| color(x)

+);

+

+const fn color(x: &[u8; 6]) -> [u8; 3] {

+ car::map!(

+ car::map!(x, |b| (b & 0xF) + 9 * (b >> 6)).chunked::<2>(),

+ |[a, b]| a * 16 + b

+ )

+}

+#[test]

+fn x() {

+ dbg!(color(b"ffd173"));

+}

+

+ // parser: Parser,

+ highlighter: Highlighter,

+ tree: Option<Tree>,

+ dbg!(c);

+ pub fn backspace(&mut self) {

+ _ = self.rope.try_remove(self.cursor - 1..self.cursor);

+ self.cursor = self.cursor.saturating_sub(1);

+ }

+

+ &mut self,

+ let mut x = HighlightConfiguration::new(

+ tree_sitter_rust::LANGUAGE.into(),

+ "rust",

+ tree_sitter_rust::HIGHLIGHTS_QUERY,

+ tree_sitter_rust::INJECTIONS_QUERY,

+ "",

+ )

+ .unwrap();

+

+ x.configure(&NAMES);

+

+

+ // dbg!(unsafe {

+ // String::from_utf8_unchecked(

+ // self.rope.bytes().collect::<Vec<_>>(),

+ // )

+ // });

+ let mut s = 0;

+ for hl in self

+ .highlighter

+ .highlight(

+ &x,

+ &self.rope.bytes().collect::<Vec<_>>(),

+ None,

+ |_| None,

+ )

+ .unwrap()

+ .map(Result::unwrap)

+ {

+ match hl {

+ HighlightEvent::Source { start, end } => {

+ // for elem in start..end {

+ // styles[elem] = s;

+ // }

+ let y1 = self.rope.char_to_line(start);

+ let y2 = self.rope.char_to_line(start);

+ let x1 = start - self.rope.line_to_char(y1);

+ let x2 = end - self.rope.line_to_char(y2);

+ // dbg!((x1, y1), (x2, y2));

+ cells.get_mut(y1 * c + x1..y2 * c + x2).map(|x| {

+ x.iter_mut()

+ .for_each(|x| x.style.color = COLORS[s])

+ });

+ // println!(

+ // "highlight {} {s} {}: {:?}",

+ // self.rope.byte_slice(start..end),

+ // NAMES[s],

+ // COLORS[s],

+ // )

+ }

+ HighlightEvent::HighlightStart(s_) => s = s_.0,

+ HighlightEvent::HighlightEnd => s = 0,

+ }

+ }

+

+ // let (a, b) = code.into_iter().collect::<(Vec<_>, Vec<_>)>();

+

+ // let mut i = 0;

+ // let mut y = 0;

+ // let mut x = 0;

+ // while i < code.len() {

+ // if code[i] == b'\n' {

+ // x = 0;

+ // y += 1;

+ // if y == r {

+ // break;

+ // }

+ // } else {

+ // cells[y * c + x].letter = Some(code[i] as char);

+ // cells[y * c + x].style.color = COLORS[styles[i]];

+ // x += 1

+ // }

+ // i += 1;

+ // }

+

+ if e != '\n' {

+ cells[y * c + x].letter = Some(e);

+ }

+

+impl Default for TextArea {

+ fn default() -> Self {

+ // let mut parser = Highlighter::new();

+

+ let mut x = Self {

+ rope: Default::default(),

+ cursor: 0,

+ tree: None,

+ highlighter: Highlighter::new(),

+ };

+

+ x

+ }

+}

+

+pub trait TakeLine<'b> {

+ fn take_line<'a>(&'a mut self) -> Option<&'b [u8]>;

+ fn take_backline<'a>(&'a mut self) -> Option<&'b [u8]>;

+}

+

+impl<'b> TakeLine<'b> for &'b [u8] {

+ fn take_line<'a>(&'a mut self) -> Option<&'b [u8]> {

+ match memchr::memchr(b'\n', self) {

+ None if self.is_empty() => None,

+ None => Some(std::mem::replace(self, b"")),

+ Some(end) => {

+ let line = &self[..end];

+ *self = &self[end + 1..];

+ Some(line)

+ }

+ }

+ }

+

+ fn take_backline<'a>(&'a mut self) -> Option<&'b [u8]> {

+ let end = self.len().checked_sub(1)?;

+ match memchr::memrchr(b'\n', &self[..end]) {

+ None => Some(std::mem::replace(self, b"")),

+ Some(end) => {

+ let line = &self[end + 1..];

+ *self = &self[..end];

+ Some(line)

+ }

+ }

+ }

+}