Newer
Older
}
let (offset_x, offset_y) = match text_position {
CosmicTextPosition::Center => (
get_x_offset(editor.0.buffer()),
get_y_offset(editor.0.buffer()),
),
CosmicTextPosition::TopLeft => (0, 0),
};
let point = |node_cursor_pos: (f32, f32)| {
(
(node_cursor_pos.0 * scale_factor) as i32 - offset_x,
(node_cursor_pos.1 * scale_factor) as i32 - offset_y,
)
};
if buttons.just_pressed(MouseButton::Left) {
if let Some(node_cursor_pos) = get_node_cursor_pos(
primary_window,
node_transform,
is_ui_node,
camera,
camera_transform,
) {
let (x, y) = point(node_cursor_pos);
if shift {
editor.0.action(&mut font_system.0, Action::Drag { x, y });
editor.0.action(&mut font_system.0, Action::Click { x, y });
return;
}
if buttons.pressed(MouseButton::Left) {
if let Some(node_cursor_pos) = get_node_cursor_pos(
primary_window,
node_transform,
(width, height),
is_ui_node,
camera,
camera_transform,
) {
let (x, y) = point(node_cursor_pos);
if active_editor.is_changed() && !shift {
editor.0.action(&mut font_system.0, Action::Click { x, y });
editor.0.action(&mut font_system.0, Action::Drag { x, y });
return;
}
for ev in scroll_evr.iter() {
match ev.unit {
MouseScrollUnit::Line => {
&mut font_system.0,
Action::Scroll {
lines: -ev.y as i32,
},
);
}
MouseScrollUnit::Pixel => {
let line_height = editor.0.buffer().metrics().line_height;
editor.0.action(
&mut font_system.0,
Action::Scroll {
lines: -(ev.y / line_height) as i32,
},
);
if readonly {
return;
}
if let Some(select) = editor.0.select_opt() {
if editor.0.cursor().line == select.line && editor.0.cursor().index == select.index
{
editor.0.set_select_opt(None);
let mut is_edit = is_clipboard;
let mut is_return = false;
if keys.just_pressed(KeyCode::Return) {
is_return = true;
is_edit = true;
if (max_lines.0 == 0 || editor.0.buffer().lines.len() < max_lines.0)
&& (max_chars.0 == 0 || editor.get_text().len() < max_chars.0)
{
// to have new line on wasm rather than E
editor.0.action(&mut font_system.0, Action::Insert('\n'));
}
if !(is_clipboard || is_return) {
for char_ev in char_evr.iter() {
is_edit = true;
if *is_deleting {
editor.0.action(&mut font_system.0, Action::Backspace);
} else if max_chars.0 == 0 || editor.get_text().len() < max_chars.0 {
editor
.0
.action(&mut font_system.0, Action::Insert(char_ev.char));
if !is_edit {
return;
}
if let Some(last_edit_duration) = *edits_duration {
if Duration::from_millis(now_ms as u64) - last_edit_duration
> Duration::from_millis(150)
{
save_edit_history(&mut editor.0, attrs, &mut edit_history);
*edits_duration = Some(Duration::from_millis(now_ms as u64));
}
save_edit_history(&mut editor.0, attrs, &mut edit_history);
*edits_duration = Some(Duration::from_millis(now_ms as u64));
fn cosmic_edit_set_redraw(mut cosmic_edit_query: Query<&mut CosmicEditor, Added<CosmicEditor>>) {
for mut editor in cosmic_edit_query.iter_mut() {
editor.0.buffer_mut().set_redraw(true);
#[allow(clippy::too_many_arguments)]
fn redraw_buffer_common(
images: &mut ResMut<Assets<Image>>,
swash_cache_state: &mut ResMut<SwashCacheState>,
background_image: Option<Handle<Image>>,
background_color: Color,
cosmic_canvas_img_handle: &mut Handle<Image>,
text_position: &CosmicTextPosition,
font_system: &mut ResMut<CosmicFontSystem>,
scale_factor: f32,
original_width: f32,
original_height: f32,
) {
let width = original_width * scale_factor;
let height = original_height * scale_factor;
let swash_cache = &mut swash_cache_state.swash_cache;
editor.shape_as_needed(&mut font_system.0);
if editor.buffer().redraw() {
editor
.buffer_mut()
.set_size(&mut font_system.0, width, height);
let font_color = attrs
.0
.color_opt
.unwrap_or(cosmic_text::Color::rgb(0, 0, 0));
let mut pixels = vec![0; width as usize * height as usize * 4];
if let Some(bg_image) = background_image {
if let Some(image) = images.get(&bg_image) {
let mut dynamic_image = image.clone().try_into_dynamic().unwrap();
if image.size().x != width || image.size().y != height {
dynamic_image = dynamic_image.resize_to_fill(
width as u32,
height as u32,
FilterType::Triangle,
);
}
for (i, (_, _, rgba)) in dynamic_image.pixels().enumerate() {
if let Some(p) = pixels.get_mut(i * 4..(i + 1) * 4) {
p[0] = rgba[0];
p[1] = rgba[1];
p[2] = rgba[2];
p[3] = rgba[3];
}
} else {
let bg = background_color;
for pixel in pixels.chunks_exact_mut(4) {
pixel[0] = (bg.r() * 255.) as u8; // Red component
pixel[1] = (bg.g() * 255.) as u8; // Green component
pixel[2] = (bg.b() * 255.) as u8; // Blue component
pixel[3] = (bg.a() * 255.) as u8; // Alpha component
}
}
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
let (offset_y, offset_x) = match text_position {
CosmicTextPosition::Center => {
(get_y_offset(editor.buffer()), get_x_offset(editor.buffer()))
}
CosmicTextPosition::TopLeft => (0, 0),
};
editor.draw(
&mut font_system.0,
swash_cache,
font_color,
|x, y, w, h, color| {
for row in 0..h as i32 {
for col in 0..w as i32 {
draw_pixel(
&mut pixels,
width as i32,
height as i32,
x + col + offset_x,
y + row + offset_y,
color,
);
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
},
);
editor.buffer_mut().set_redraw(false);
if let Some(prev_image) = images.get_mut(cosmic_canvas_img_handle) {
if *cosmic_canvas_img_handle == bevy::render::texture::DEFAULT_IMAGE_HANDLE.typed() {
let mut prev_image = prev_image.clone();
prev_image.data.clear();
prev_image.data.extend_from_slice(pixels.as_slice());
prev_image.resize(Extent3d {
width: width as u32,
height: height as u32,
depth_or_array_layers: 1,
});
let handle_id: HandleId = HandleId::random::<Image>();
let new_handle: Handle<Image> = Handle::weak(handle_id);
let new_handle = images.set(new_handle, prev_image);
*cosmic_canvas_img_handle = new_handle;
} else {
prev_image.data.clear();
prev_image.data.extend_from_slice(pixels.as_slice());
prev_image.resize(Extent3d {
width: width as u32,
height: height as u32,
depth_or_array_layers: 1,
});
}
}
}
}
fn cosmic_edit_redraw_buffer_ui(
windows: Query<&Window, With<PrimaryWindow>>,
mut images: ResMut<Assets<Image>>,
mut swash_cache_state: ResMut<SwashCacheState>,
mut cosmic_edit_query: Query<(
&mut CosmicEditor,
&CosmicBackground,
&BackgroundColor,
&CosmicTextPosition,
&mut UiImage,
&Node,
&mut Visibility,
)>,
mut font_system: ResMut<CosmicFontSystem>,
background_image,
background_color,
text_position,
mut img,
node,
mut visibility,
) in &mut cosmic_edit_query.iter_mut()
{
// provide min sizes to prevent render panic
let width = node.size().x.max(1.);
let height = node.size().y.max(1.);
redraw_buffer_common(
&mut images,
&mut swash_cache_state,
background_image.0.clone(),
background_color.0,
text_position,
&mut font_system,
primary_window.scale_factor() as f32,
width,
height,
);
if *visibility == Visibility::Hidden
&& img.texture.clone() != bevy::render::texture::DEFAULT_IMAGE_HANDLE.typed()
{
*visibility = Visibility::Visible;
}
}
}
fn blink_cursor(
mut visible: Local<bool>,
mut timer: Local<Option<Timer>>,
time: Res<Time>,
mut cosmic_editor_q: Query<&mut CosmicEditor, Without<ReadOnly>>,
if let Some(e) = active_editor.entity {
if let Ok(mut editor) = cosmic_editor_q.get_mut(e) {
let timer =
timer.get_or_insert_with(|| Timer::from_seconds(0.53, TimerMode::Repeating));
timer.tick(time.delta());
if !timer.just_finished() && !active_editor.is_changed() {
return;
}
*visible = !*visible;
// always start cursor visible on focus
if active_editor.is_changed() {
*visible = true;
timer.set_elapsed(Duration::from_secs(0));
let mut cursor = editor.0.cursor();
let new_color = if *visible {
None
} else {
Some(cosmic_text::Color::rgba(0, 0, 0, 0))
};
cursor.color = new_color;
editor.0.set_cursor(cursor);
editor.0.buffer_mut().set_redraw(true);
}
}
}
fn hide_inactive_cursor(
mut cosmic_editor_q: Query<(Entity, &mut CosmicEditor)>,
active_editor: Res<ActiveEditor>,
) {
if !active_editor.is_changed() || active_editor.entity.is_none() {
for (e, mut editor) in &mut cosmic_editor_q.iter_mut() {
if e != active_editor.entity.unwrap() {
let mut cursor = editor.0.cursor();
cursor.color = Some(cosmic_text::Color::rgba(0, 0, 0, 0));
editor.0.set_cursor(cursor);
editor.0.buffer_mut().set_redraw(true);
}
fn clear_inactive_selection(
mut cosmic_editor_q: Query<(Entity, &mut CosmicEditor)>,
active_editor: Res<ActiveEditor>,
) {
if !active_editor.is_changed() || active_editor.entity.is_none() {
return;
}
for (e, mut editor) in &mut cosmic_editor_q.iter_mut() {
if e != active_editor.entity.unwrap() {
editor.0.set_select_opt(None);
}
}
}
fn cosmic_edit_redraw_buffer(
windows: Query<&Window, With<PrimaryWindow>>,
mut images: ResMut<Assets<Image>>,
mut swash_cache_state: ResMut<SwashCacheState>,
mut cosmic_edit_query: Query<(
&mut CosmicEditor,
&Sprite,
&CosmicBackground,
&BackgroundColor,
&CosmicTextPosition,
&mut Handle<Image>,
&mut Visibility,
)>,
mut font_system: ResMut<CosmicFontSystem>,
sprite,
background_image,
background_color,
text_position,
mut handle,
mut visibility,
) in &mut cosmic_edit_query.iter_mut()
{
// provide min sizes to prevent render panic
let width = sprite.custom_size.unwrap().x.max(1.);
let height = sprite.custom_size.unwrap().y.max(1.);
redraw_buffer_common(
&mut images,
&mut swash_cache_state,
background_image.0.clone(),
background_color.0,
text_position,
&mut font_system,
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
primary_window.scale_factor() as f32,
width,
height,
);
if *visibility == Visibility::Hidden
&& handle.clone() != bevy::render::texture::DEFAULT_IMAGE_HANDLE.typed()
{
*visibility = Visibility::Visible;
}
}
}
fn draw_pixel(
buffer: &mut [u8],
width: i32,
height: i32,
x: i32,
y: i32,
color: cosmic_text::Color,
) {
let alpha = (color.0 >> 24) & 0xFF;
if alpha == 0 {
// Do not draw if alpha is zero
return;
}
if y < 0 || y >= height {
// Skip if y out of bounds
return;
}
if x < 0 || x >= width {
// Skip if x out of bounds
return;
}
let offset = (y as usize * width as usize + x as usize) * 4;
let mut current = buffer[offset + 2] as u32
| (buffer[offset + 1] as u32) << 8
| (buffer[offset] as u32) << 16
| (buffer[offset + 3] as u32) << 24;
if alpha >= 255 || current == 0 {
// Alpha is 100% or current is null, replace with no blending
current = color.0;
} else {
// Alpha blend with current value
let n_alpha = 255 - alpha;
let rb = ((n_alpha * (current & 0x00FF00FF)) + (alpha * (color.0 & 0x00FF00FF))) >> 8;
let ag = (n_alpha * ((current & 0xFF00FF00) >> 8))
+ (alpha * (0x01000000 | ((color.0 & 0x0000FF00) >> 8)));
current = (rb & 0x00FF00FF) | (ag & 0xFF00FF00);
}
buffer[offset + 2] = current as u8;
buffer[offset + 1] = (current >> 8) as u8;
buffer[offset] = (current >> 16) as u8;
buffer[offset + 3] = (current >> 24) as u8;
}
#[cfg(test)]
mod tests {
use crate::*;
fn test_spawn_cosmic_edit_system(mut commands: Commands) {
commands.spawn(CosmicEditUiBundle {
set_text: CosmicText::OneStyle("Blah".into()),
..Default::default()
});
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
}
#[test]
fn test_spawn_cosmic_edit() {
let mut app = App::new();
app.add_plugins(TaskPoolPlugin::default());
app.add_plugins(AssetPlugin::default());
app.insert_resource(CosmicFontSystem(create_cosmic_font_system(
CosmicFontConfig::default(),
)));
app.add_systems(Update, test_spawn_cosmic_edit_system);
let input = Input::<KeyCode>::default();
app.insert_resource(input);
let mouse_input: Input<MouseButton> = Input::<MouseButton>::default();
app.insert_resource(mouse_input);
app.add_asset::<Image>();
app.add_event::<ReceivedCharacter>();
app.update();
let mut text_nodes_query = app.world.query::<&CosmicEditor>();
for cosmic_editor in text_nodes_query.iter(&app.world) {
insta::assert_debug_snapshot!(cosmic_editor
.0
.buffer()
.lines
.iter()
.map(|line| line.text())
.collect::<Vec<_>>());
}
}
}