Select by character or color and fill with the brush on home computer screens

The ATASCII, VT52 and PETSCII editors show the select tool's modes and
actions like the ANSI editor. Filling a selection there paints the brush
into every selected character (its character and colors, only colors,
reverse or a shading step) instead of CP437's full block, so selecting
a character and filling replaces it.

Author: mkrueger

crates/icy_draw/src/bin/icy_draw_egui/app.rs

@@ -1222,6 +1222,118 @@ impl DrawApp {
         }
     }
 
+    /// The select tool's modes and what it does with the selection, in every editor's toolbar.
+    pub(super) fn selection_options(&mut self, ui: &mut egui::Ui, context: &egui::Context) {
+        use icy_draw::document::SelectionMode;
+        let mut mode = self.document.selection_mode;
+        if widgets::segmented(
+            ui,
+            &mut mode,
+            &[
+                (SelectionMode::Rectangle, fl!("tool-select-normal"), fl!("select-mode-normal-tooltip")),
+                (SelectionMode::Character, fl!("tool-select-character"), fl!("select-mode-character-tooltip")),
+                (SelectionMode::Attribute, fl!("tool-select-attribute"), fl!("select-mode-attribute-tooltip")),
+                (SelectionMode::Foreground, fl!("tool-select-foreground"), fl!("select-mode-foreground-tooltip")),
+                (SelectionMode::Background, fl!("tool-select-background"), fl!("select-mode-background-tooltip")),
+            ],
+        ) {
+            self.document.finish();
+            self.document.selection_mode = mode;
+        }
+        widgets::divider(ui);
+        let selected = self.document.with_state(|state| state.is_something_selected());
+        let paint = self.document.can_paint();
+        let shortcut = |label: String, shortcut: &egui::KeyboardShortcut| format!("{label} ({})", context.format_shortcut(shortcut));
+        let key = |label: String, key: &str| format!("{label} ({key})");
+        if self
+            .icons
+            .button(ui, "select", &shortcut(fl!("menu-select-all"), &menus::SELECT_ALL), false)
+            .clicked()
+        {
+            self.select_all();
+        }
+        ui.add_enabled_ui(selected, |ui| {
+            ui.spacing_mut().item_spacing.x = 4.0;
+            if self
+                .icons
+                .button(ui, "deselect", &shortcut(fl!("select-deselect"), &menus::DESELECT), false)
+                .clicked()
+            {
+                self.edit(|state| state.clear_selection());
+            }
+            widgets::divider(ui);
+            if self.icons.button(ui, "file_copy", &fl!("select-copy"), false).clicked() {
+                self.copy(context);
+            }
+            ui.add_enabled_ui(paint, |ui| {
+                ui.spacing_mut().item_spacing.x = 4.0;
+                if self.icons.button(ui, "library_add", &key(fl!("shortcut-block-copy"), "C"), false).clicked() {
+                    let result = self.document.float_selection(false);
+                    self.result(result);
+                }
+                if self.icons.button(ui, "move", &key(fl!("shortcut-block-move"), "M"), false).clicked() {
+                    let result = self.document.float_selection(true);
+                    self.result(result);
+                }
+                widgets::divider(ui);
+                if self.icons.button(ui, "fill", &key(fl!("shortcut-block-fill"), "F"), false).clicked() {
+                    let result = self.document.fill_selection();
+                    self.result(result);
+                }
+                let erase = egui::KeyboardShortcut::new(egui::Modifiers::NONE, egui::Key::Delete);
+                if self
+                    .icons
+                    .button(ui, "eraser", &shortcut(fl!("shortcut-erase-selection"), &erase), false)
+                    .clicked()
+                {
+                    self.document.finish();
+                    self.edit(|state| state.erase_selection());
+                }
+                if self.icons.button(ui, "crop", &shortcut(fl!("menu-crop"), &menus::CROP), false).clicked() {
+                    self.edit(|state| state.crop());
+                }
+                widgets::divider(ui);
+                if self.icons.button(ui, "flip_tool", &fl!("menu-flip-x"), false).clicked() {
+                    self.edit(|state| state.flip_x());
+                }
+                if self.icons.button(ui, "swap", &fl!("menu-flip-y"), false).clicked() {
+                    self.edit(|state| state.flip_y());
+                }
+                let justify = self.icons.button(ui, "format_align_center", &fl!("select-justify"), false);
+                egui::Popup::menu(&justify).id(egui::Id::new("select-justify")).show(|ui| {
+                    if ui.button(fl!("menu-justifyleft")).clicked() {
+                        self.edit(|state| state.justify_left());
+                        ui.close();
+                    }
+                    if ui.button(fl!("menu-justifycenter")).clicked() {
+                        self.edit(|state| state.center());
+                        ui.close();
+                    }
+                    if ui.button(fl!("menu-justifyright")).clicked() {
+                        self.edit(|state| state.justify_right());
+                        ui.close();
+                    }
+                });
+            });
+        });
+        widgets::divider(ui);
+        match selection_add_type(ui.input(|input| input.modifiers)) {
+            AddType::Add => {
+                ui.label(egui::RichText::new(fl!("select-mode-add")).color(appearance::PRIMARY).strong());
+            }
+            AddType::Subtract => {
+                ui.label(egui::RichText::new(fl!("select-mode-subtract")).color(appearance::PRIMARY).strong());
+            }
+            AddType::Default => {
+                if let Some(bounds) = self.document.with_state(|state| state.selection().map(|selection| selection.as_rectangle())) {
+                    ui.weak(format!("{}, {}  ·  {} × {}", bounds.left(), bounds.top(), bounds.width(), bounds.height()));
+                } else {
+                    ui.weak(fl!("tool-select-description"));
+                }
+            }
+        }
+    }
+
     /// Anchoring, a new layer, stamping, rotating, flipping and cancelling of a floating paste.
     pub(super) fn paste_options(&mut self, ui: &mut egui::Ui) {
         use icy_draw::document::PasteAction;
@@ -1484,116 +1596,7 @@ impl DrawApp {
             Tool::Pipette => {
                 self.pipette_options(ui);
             }
-            Tool::Select => {
-                use icy_draw::document::SelectionMode;
-                let mut mode = self.document.selection_mode;
-                if widgets::segmented(
-                    ui,
-                    &mut mode,
-                    &[
-                        (SelectionMode::Rectangle, fl!("tool-select-normal"), fl!("select-mode-normal-tooltip")),
-                        (SelectionMode::Character, fl!("tool-select-character"), fl!("select-mode-character-tooltip")),
-                        (SelectionMode::Attribute, fl!("tool-select-attribute"), fl!("select-mode-attribute-tooltip")),
-                        (SelectionMode::Foreground, fl!("tool-select-foreground"), fl!("select-mode-foreground-tooltip")),
-                        (SelectionMode::Background, fl!("tool-select-background"), fl!("select-mode-background-tooltip")),
-                    ],
-                ) {
-                    self.document.finish();
-                    self.document.selection_mode = mode;
-                }
-                widgets::divider(ui);
-                let selected = self.document.with_state(|state| state.is_something_selected());
-                let paint = self.document.can_paint();
-                let shortcut = |label: String, shortcut: &egui::KeyboardShortcut| format!("{label} ({})", context.format_shortcut(shortcut));
-                let key = |label: String, key: &str| format!("{label} ({key})");
-                if self
-                    .icons
-                    .button(ui, "select", &shortcut(fl!("menu-select-all"), &menus::SELECT_ALL), false)
-                    .clicked()
-                {
-                    self.select_all();
-                }
-                ui.add_enabled_ui(selected, |ui| {
-                    ui.spacing_mut().item_spacing.x = 4.0;
-                    if self
-                        .icons
-                        .button(ui, "deselect", &shortcut(fl!("select-deselect"), &menus::DESELECT), false)
-                        .clicked()
-                    {
-                        self.edit(|state| state.clear_selection());
-                    }
-                    widgets::divider(ui);
-                    if self.icons.button(ui, "file_copy", &fl!("select-copy"), false).clicked() {
-                        self.copy(context);
-                    }
-                    ui.add_enabled_ui(paint, |ui| {
-                        ui.spacing_mut().item_spacing.x = 4.0;
-                        if self.icons.button(ui, "library_add", &key(fl!("shortcut-block-copy"), "C"), false).clicked() {
-                            let result = self.document.float_selection(false);
-                            self.result(result);
-                        }
-                        if self.icons.button(ui, "move", &key(fl!("shortcut-block-move"), "M"), false).clicked() {
-                            let result = self.document.float_selection(true);
-                            self.result(result);
-                        }
-                        widgets::divider(ui);
-                        if self.icons.button(ui, "fill", &key(fl!("shortcut-block-fill"), "F"), false).clicked() {
-                            let result = self.document.fill_selection();
-                            self.result(result);
-                        }
-                        let erase = egui::KeyboardShortcut::new(egui::Modifiers::NONE, egui::Key::Delete);
-                        if self
-                            .icons
-                            .button(ui, "eraser", &shortcut(fl!("shortcut-erase-selection"), &erase), false)
-                            .clicked()
-                        {
-                            self.document.finish();
-                            self.edit(|state| state.erase_selection());
-                        }
-                        if self.icons.button(ui, "crop", &shortcut(fl!("menu-crop"), &menus::CROP), false).clicked() {
-                            self.edit(|state| state.crop());
-                        }
-                        widgets::divider(ui);
-                        if self.icons.button(ui, "flip_tool", &fl!("menu-flip-x"), false).clicked() {
-                            self.edit(|state| state.flip_x());
-                        }
-                        if self.icons.button(ui, "swap", &fl!("menu-flip-y"), false).clicked() {
-                            self.edit(|state| state.flip_y());
-                        }
-                        let justify = self.icons.button(ui, "format_align_center", &fl!("select-justify"), false);
-                        egui::Popup::menu(&justify).id(egui::Id::new("select-justify")).show(|ui| {
-                            if ui.button(fl!("menu-justifyleft")).clicked() {
-                                self.edit(|state| state.justify_left());
-                                ui.close();
-                            }
-                            if ui.button(fl!("menu-justifycenter")).clicked() {
-                                self.edit(|state| state.center());
-                                ui.close();
-                            }
-                            if ui.button(fl!("menu-justifyright")).clicked() {
-                                self.edit(|state| state.justify_right());
-                                ui.close();
-                            }
-                        });
-                    });
-                });
-                widgets::divider(ui);
-                match selection_add_type(ui.input(|input| input.modifiers)) {
-                    AddType::Add => {
-                        ui.label(egui::RichText::new(fl!("select-mode-add")).color(appearance::PRIMARY).strong());
-                    }
-                    AddType::Subtract => {
-                        ui.label(egui::RichText::new(fl!("select-mode-subtract")).color(appearance::PRIMARY).strong());
-                    }
-                    AddType::Default => {
-                        if let Some(bounds) = self.document.with_state(|state| state.selection().map(|selection| selection.as_rectangle())) {
-                            ui.weak(format!("{}, {}  ·  {} × {}", bounds.left(), bounds.top(), bounds.width(), bounds.height()));
-                        } else {
-                            ui.weak(fl!("tool-select-description"));
-                        }
-                    }
-                }
-            }
+            Tool::Select => self.selection_options(ui, context),
 
             Tool::Tag => {
                 if self.icons.button(ui, "tag", &fl!("tag-list-title"), false).clicked() {

crates/icy_draw/src/bin/icy_draw_egui/atascii.rs

@@ -457,7 +457,13 @@ impl DrawApp {
                 }
             }
             widgets::divider(ui);
-            (picked, step) = self.screen_fkey_bar(ui, &FKEY_SETS[set], (set, FKEY_SETS.len()), self.atascii_colors());
+            if self.document.tool == Tool::Select {
+                // Selecting by character or color and filling with the brush replaces characters.
+                let context = ui.ctx().clone();
+                self.selection_options(ui, &context);
+            } else {
+                (picked, step) = self.screen_fkey_bar(ui, &FKEY_SETS[set], (set, FKEY_SETS.len()), self.atascii_colors());
+            }
         });
         if step != 0 {
             if let Some(editor) = &mut self.atascii {

crates/icy_draw/src/bin/icy_draw_egui/petscii.rs

@@ -688,7 +688,13 @@ impl DrawApp {
                 self.petscii_outline_options(ui);
             }
             widgets::divider(ui);
-            (picked, step) = self.screen_fkey_bar(ui, &FKEY_SETS[set], (set, FKEY_SETS.len()), colors);
+            if self.document.tool == Tool::Select {
+                // Selecting by character or color and filling with the brush replaces characters.
+                let context = ui.ctx().clone();
+                self.selection_options(ui, &context);
+            } else {
+                (picked, step) = self.screen_fkey_bar(ui, &FKEY_SETS[set], (set, FKEY_SETS.len()), colors);
+            }
         });
         if step != 0 {
             if let Some(editor) = &mut self.petscii {
@@ -1048,6 +1054,31 @@ mod tests {
         assert_eq!(cell(&app, 2, 2).0, 0x5B);
     }
 
+    #[test]
+    fn selecting_a_character_and_filling_with_the_brush_replaces_it() {
+        let (_, mut app) = petscii_app(PetsciiMachine::C64, PetsciiCase::Upper);
+        app.document.type_text("ABAB").unwrap();
+        // Select every A: the select tool's character mode.
+        app.document.tool = Tool::Select;
+        app.document.selection_mode = icy_draw::document::SelectionMode::Character;
+        app.document.begin(Position::new(0, 0), icy_engine::MouseButton::Left);
+        app.document.finish();
+        // Replace them with the brush: a reverse space in red.
+        app.document.brush.paint_char = char::from(0xA0);
+        app.document.with_state(|state| state.set_caret_foreground(2));
+        app.document.fill_selection().unwrap();
+        assert_eq!(
+            (0..4).map(|x| cell(&app, x, 0)).collect::<Vec<_>>(),
+            [(0xA0, 2, 6), (2, 14, 6), (0xA0, 2, 6), (2, 14, 6)]
+        );
+        app.undo(false);
+        assert_eq!(cell(&app, 0, 0), (1, 14, 6), "one undo step");
+        // Only the color.
+        app.apply_petscii_paint_mode(PaintMode::Color);
+        app.document.fill_selection().unwrap();
+        assert_eq!([cell(&app, 0, 0), cell(&app, 1, 0)], [(1, 2, 6), (2, 14, 6)]);
+    }
+
     #[test]
     fn the_reverse_pen_turns_characters_reverse_and_back() {
         let (_, mut app) = petscii_app(PetsciiMachine::C64, PetsciiCase::Upper);

crates/icy_draw/src/bin/icy_draw_egui/vt52.rs

@@ -306,7 +306,13 @@ impl DrawApp {
                 }
             }
             widgets::divider(ui);
-            (picked, step) = self.screen_fkey_bar(ui, &fkey_codes(set), (set, FKEY_SETS.len()), colors);
+            if self.document.tool == Tool::Select {
+                // Selecting by character or color and filling with the brush replaces characters.
+                let context = ui.ctx().clone();
+                self.selection_options(ui, &context);
+            } else {
+                (picked, step) = self.screen_fkey_bar(ui, &fkey_codes(set), (set, FKEY_SETS.len()), colors);
+            }
         });
         if step != 0 {
             if let Some(editor) = &mut self.vt52 {

crates/icy_draw/src/document.rs

@@ -390,6 +390,12 @@ impl Document {
             return Ok(());
         }
         self.finish();
+        if !matches!(
+            self.profile(),
+            crate::screen_profile::ScreenProfile::Ansi | crate::screen_profile::ScreenProfile::Other(_)
+        ) {
+            return self.fill_selection_with_brush();
+        }
         self.with_state(|state| {
             let attribute = state.get_caret().attribute;
             if attribute.foreground() == 0 {
@@ -402,6 +408,29 @@ impl Document {
         .map_err(|error| error.to_string())
     }
 
+    /// Paints the brush once into every selected character of the current layer, in one undo
+    /// step: the character with its colors, only the colors, reverse, or a shading step. Home
+    /// computer screens fill this way, as CP437's full block is not theirs.
+    fn fill_selection_with_brush(&mut self) -> DrawResult<()> {
+        let mut brush = self.brush;
+        brush.brush_size = 1;
+        self.with_state(|state| {
+            let Some(layer) = state.get_cur_layer() else {
+                return;
+            };
+            let (offset, width, height) = (layer.offset(), layer.width(), layer.height());
+            let selected: Vec<Position> = (0..height)
+                .flat_map(|y| (0..width).map(move |x| Position::new(x, y) + offset))
+                .filter(|&position| state.is_selected(position))
+                .collect();
+            let _undo = state.begin_atomic_undo("Fill selection");
+            for position in selected {
+                self.stamp_into(state, position, brush, MouseButton::Left);
+            }
+        });
+        Ok(())
+    }
+
     fn start_floating_paste(&mut self, paste: impl FnOnce(&mut EditState) -> icy_engine::Result<()>) -> DrawResult<()> {
         self.start_floating(false, paste)
     }