URI: 
       Added color modes. - icy_draw - icy_draw is the successor to mystic draw. fork / mirror
  HTML git clone https://git.drkhsh.at/icy_draw.git
   DIR Log
   DIR Files
   DIR Refs
   DIR README
   DIR LICENSE
       ---
   DIR commit 6151b71c94e8774a254e123e39ab5f4ce2ee8eb5
   DIR parent ae6956921cdf72857ee55014830cf704a27234b1
  HTML Author: Mike Krüger <mkrueger@posteo.de>
       Date:   Fri, 15 Sep 2023 19:49:28 +0200
       
       Added color modes.
       
       Diffstat:
         M i18n/de/icy_draw.ftl                |       1 +
         M i18n/en/icy_draw.ftl                |       8 ++++++++
         M src/ui/dialogs/font_manager.rs      |       9 +++++++--
         M src/ui/main_window.rs               |      96 +++++++++++++++++++++----------
         M src/ui/palette_editor.rs            |      20 +++++++++++++++-----
         M src/ui/top_bar.rs                   |      82 ++++++++++++++++++++++++++++++-
       
       6 files changed, 177 insertions(+), 39 deletions(-)
       ---
   DIR diff --git a/i18n/de/icy_draw.ftl b/i18n/de/icy_draw.ftl
       @@ -163,6 +163,7 @@ glyph-font-label=Schriftart
        color-dos=DOS
        color-ext=ERW
        color-custom=USR
       +color-is_blinking=Blinken
        
        export-title=Export
        export-button-title=Export
   DIR diff --git a/i18n/en/icy_draw.ftl b/i18n/en/icy_draw.ftl
       @@ -62,6 +62,13 @@ menu-select_nothing=Deselect
        menu-inverse_selection=Inverse
        
        menu-colors=Colors
       +menu-color-mode=Color Mode
       +menu-color-mode-unrestricted=Unrestricted
       +menu-color-mode-dos=16 Colors, blink
       +menu-color-mode-ice=16 Colors, ice
       +menu-color-mode-ext-colors=256 Colors
       +menu-color-mode-ext-font=16 Colors, ext font, blink
       +menu-color-mode-ext-font-ice=16 Colors, ext font, ice
        
        menu-view=View
        menu-reference-image=Open Reference Image…
       @@ -162,6 +169,7 @@ glyph-font-label=Font
        color-dos=DOS
        color-ext=EXT
        color-custom=USR
       +color-is_blinking=Blink
        
        export-title=Export
        export-button-title=Export
   DIR diff --git a/src/ui/dialogs/font_manager.rs b/src/ui/dialogs/font_manager.rs
       @@ -82,6 +82,11 @@ impl crate::ModalDialog for FontManager {
                                            let mut title_rect = rect;
                                            title_rect.set_left(title_rect.left() + 4.0);
                                            title_rect.set_top(title_rect.bottom() - size.y - 8.0);
       +                                    let text_color = if is_selected {
       +                                        ui.style().visuals.strong_text_color()
       +                                    } else {
       +                                        ui.style().visuals.text_color()
       +                                    };
                                            ui.painter().galley_with_color(
                                                egui::Align2::LEFT_TOP
                                                    .align_size_within_rect(
       @@ -90,7 +95,7 @@ impl crate::ModalDialog for FontManager {
                                                    )
                                                    .min,
                                                galley.galley,
       -                                        ui.style().visuals.text_color(),
       +                                        text_color,
                                            );
        
                                            let font_id = TextStyle::Button.resolve(ui.style());
       @@ -107,7 +112,7 @@ impl crate::ModalDialog for FontManager {
                                                    )
                                                    .min,
                                                galley.galley,
       -                                        ui.style().visuals.strong_text_color(),
       +                                        text_color,
                                            );
        
                                            if response.clicked() {
   DIR diff --git a/src/ui/main_window.rs b/src/ui/main_window.rs
       @@ -573,11 +573,13 @@ impl eframe::App for MainWindow {
        
                        let mut caret_attr = TextAttribute::default();
                        let mut palette = Palette::default();
       +                let mut buffer_type = icy_engine::BufferType::NoLimits;
        
                        if let Some(doc) = self.get_active_document() {
                            if let Some(editor) = doc.lock().unwrap().get_ansi_editor() {
                                caret_attr = editor.buffer_view.lock().get_caret().get_attribute();
                                palette = editor.buffer_view.lock().get_buffer().palette.clone();
       +                        buffer_type = editor.buffer_view.lock().get_buffer().buffer_type;
                            }
                        }
        
       @@ -589,43 +591,75 @@ impl eframe::App for MainWindow {
                            msg = crate::palette_switcher(ctx, ui, &caret_attr, &palette);
                        });
                        ui.add_space(8.0);
       -                ui.horizontal(|ui| {
       -                    ui.add_space(8.0);
       -                    if ui
       -                        .selectable_label(
       -                            palette_mode == 0,
       -                            fl!(crate::LANGUAGE_LOADER, "color-dos"),
       -                        )
       -                        .clicked()
       -                    {
       -                        palette_mode = 0;
       -                    }
       -                    if ui
       -                        .selectable_label(
       -                            palette_mode == 1,
       -                            fl!(crate::LANGUAGE_LOADER, "color-ext"),
       -                        )
       -                        .clicked()
       -                    {
       -                        palette_mode = 1;
       -                    }
       -                    if ui
       -                        .selectable_label(
       -                            palette_mode == 2,
       -                            fl!(crate::LANGUAGE_LOADER, "color-custom"),
       -                        )
       -                        .clicked()
       -                    {
       -                        palette_mode = 2;
       -                    }
       -                });
       +                if buffer_type.has_extended_colors() || buffer_type.has_rgb_colors() {
       +                    ui.horizontal(|ui| {
       +                        ui.add_space(8.0);
       +                        if ui
       +                            .selectable_label(
       +                                palette_mode == 0,
       +                                fl!(crate::LANGUAGE_LOADER, "color-dos"),
       +                            )
       +                            .clicked()
       +                        {
       +                            palette_mode = 0;
       +                        }
       +                        if buffer_type.has_extended_colors() {
       +                            if ui
       +                                .selectable_label(
       +                                    palette_mode == 1,
       +                                    fl!(crate::LANGUAGE_LOADER, "color-ext"),
       +                                )
       +                                .clicked()
       +                            {
       +                                palette_mode = 1;
       +                            }
       +                        } else if palette_mode == 1 {
       +                            palette_mode = 0;
       +                        }
       +                        if buffer_type.has_rgb_colors() {
       +                            if ui
       +                                .selectable_label(
       +                                    palette_mode == 2,
       +                                    fl!(crate::LANGUAGE_LOADER, "color-custom"),
       +                                )
       +                                .clicked()
       +                            {
       +                                palette_mode = 2;
       +                            }
       +                        } else if palette_mode == 2 {
       +                            palette_mode = 0;
       +                        }
       +                    });
       +                } else {
       +                    palette_mode = 0;
       +                }
                        ui.separator();
                        let msg2 = match palette_mode {
       -                    0 => crate::palette_editor_16(ui, &caret_attr, &palette),
       +                    0 => crate::palette_editor_16(ui, &caret_attr, &palette, buffer_type),
                            1 => crate::show_extended_palette(ui),
                            _ => crate::show_custom_palette(ui),
                        };
        
       +                if buffer_type.has_blink()
       +                    && ui
       +                        .selectable_label(
       +                            caret_attr.is_blinking(),
       +                            fl!(crate::LANGUAGE_LOADER, "color-is_blinking"),
       +                        )
       +                        .clicked()
       +                {
       +                    if let Some(doc) = self.get_active_document() {
       +                        if let Some(editor) = doc.lock().unwrap().get_ansi_editor() {
       +                            caret_attr.set_is_blinking(!caret_attr.is_blinking());
       +                            editor
       +                                .buffer_view
       +                                .lock()
       +                                .get_caret_mut()
       +                                .set_attr(caret_attr);
       +                        }
       +                    }
       +                }
       +
                        if msg.is_none() {
                            msg = msg2;
                        }
   DIR diff --git a/src/ui/palette_editor.rs b/src/ui/palette_editor.rs
       @@ -2,8 +2,9 @@ use crate::{Message, Settings, SWAP_SVG};
        use eframe::egui::{self, color_picker, Sense, TextEdit, TextStyle, Ui};
        use eframe::emath::Align2;
        use eframe::epaint::{Color32, FontId, Pos2, Rect, Rounding, Stroke, Vec2};
       +use glow::Buffer;
        use i18n_embed_fl::fl;
       -use icy_engine::{Palette, TextAttribute, XTERM_256_PALETTE};
       +use icy_engine::{BufferType, Palette, TextAttribute, XTERM_256_PALETTE};
        use std::cmp::min;
        
        pub fn palette_switcher(
       @@ -154,6 +155,7 @@ pub fn palette_editor_16(
            ui: &mut egui::Ui,
            caret_attr: &TextAttribute,
            palette: &Palette,
       +    buffer_type: BufferType,
        ) -> Option<Message> {
            let mut result = None;
        
       @@ -166,8 +168,12 @@ pub fn palette_editor_16(
                let mut response = ui.interact(stroke_rect, id, Sense::click());
        
                let painter = ui.painter_at(stroke_rect);
       -
       -        for i in 0..16 {
       +        let upper_limit = if buffer_type == BufferType::ExtendedFont {
       +            8
       +        } else {
       +            16
       +        };
       +        for i in 0..upper_limit {
                    let (r, g, b) = palette.colors[i].get_rgb();
                    painter.rect_filled(
                        Rect::from_min_size(
       @@ -242,11 +248,15 @@ pub fn palette_editor_16(
                    let pos = (hp.to_vec2() - stroke_rect.left_top().to_vec2()) / Vec2::new(height, height);
                    let color = min(palette.len() - 1, pos.x as u32 + pos.y as u32 * 8);
                    if response.clicked() {
       -                result = Some(Message::SetForeground(color));
       +                if color < 8 || buffer_type.has_high_fg_colors() {
       +                    result = Some(Message::SetForeground(color));
       +                }
                        response.mark_changed();
                    }
                    if response.secondary_clicked() {
       -                result = Some(Message::SetBackground(color));
       +                if color < 8 || buffer_type.has_high_bg_colors() {
       +                    result = Some(Message::SetBackground(color));
       +                }
                        response.mark_changed();
                    }
                }
   DIR diff --git a/src/ui/top_bar.rs b/src/ui/top_bar.rs
       @@ -4,7 +4,10 @@ use eframe::{
        };
        use egui_extras::RetainedImage;
        use i18n_embed_fl::fl;
       -use icy_engine::util::{pop_data, BUFFER_DATA};
       +use icy_engine::{
       +    util::{pop_data, BUFFER_DATA},
       +    BufferType,
       +};
        
        use crate::{button_with_shortcut, MainWindow, Message, Settings, SETTINGS};
        
       @@ -289,6 +292,83 @@ impl MainWindow {
                        self.commands.crop.ui_enabled(ui, has_buffer, &mut result);
                    });
                    ui.menu_button(fl!(crate::LANGUAGE_LOADER, "menu-colors"), |ui| {
       +                if has_buffer {
       +                    if let Some(pane) = self.get_active_pane() {
       +                        if let Ok(doc) = &mut pane.doc.lock() {
       +                            let editor = doc.get_ansi_editor_mut().unwrap();
       +                            let lock = &mut editor.buffer_view.lock();
       +
       +                            ui.menu_button(fl!(crate::LANGUAGE_LOADER, "menu-color-mode"), |ui| {
       +                                if ui
       +                                    .selectable_label(
       +                                        lock.get_buffer().buffer_type == BufferType::NoLimits,
       +                                        fl!(crate::LANGUAGE_LOADER, "menu-color-mode-unrestricted"),
       +                                    )
       +                                    .clicked()
       +                                {
       +                                    lock.get_buffer_mut().buffer_type = BufferType::NoLimits;
       +                                    ui.close_menu();
       +                                }
       +
       +                                if ui
       +                                    .selectable_label(
       +                                        lock.get_buffer().buffer_type == BufferType::LegacyDos,
       +                                        fl!(crate::LANGUAGE_LOADER, "menu-color-mode-dos"),
       +                                    )
       +                                    .clicked()
       +                                {
       +                                    lock.get_buffer_mut().buffer_type = BufferType::LegacyDos;
       +                                    ui.close_menu();
       +                                }
       +
       +                                if ui
       +                                    .selectable_label(
       +                                        lock.get_buffer().buffer_type == BufferType::LegacyIce,
       +                                        fl!(crate::LANGUAGE_LOADER, "menu-color-mode-ice"),
       +                                    )
       +                                    .clicked()
       +                                {
       +                                    lock.get_buffer_mut().buffer_type = BufferType::LegacyIce;
       +                                    ui.close_menu();
       +                                }
       +
       +                                if ui
       +                                    .selectable_label(
       +                                        lock.get_buffer().buffer_type == BufferType::ExtendedColors,
       +                                        fl!(crate::LANGUAGE_LOADER, "menu-color-mode-ext-colors"),
       +                                    )
       +                                    .clicked()
       +                                {
       +                                    lock.get_buffer_mut().buffer_type = BufferType::ExtendedColors;
       +                                    ui.close_menu();
       +                                }
       +                                if ui
       +                                    .selectable_label(
       +                                        lock.get_buffer().buffer_type == BufferType::ExtendedFont,
       +                                        fl!(crate::LANGUAGE_LOADER, "menu-color-mode-ext-font"),
       +                                    )
       +                                    .clicked()
       +                                {
       +                                    lock.get_buffer_mut().buffer_type = BufferType::ExtendedFont;
       +                                    ui.close_menu();
       +                                }
       +                                if ui
       +                                    .selectable_label(
       +                                        lock.get_buffer().buffer_type
       +                                            == BufferType::ExtendedFontAndIce,
       +                                        fl!(crate::LANGUAGE_LOADER, "menu-color-mode-ext-font-ice"),
       +                                    )
       +                                    .clicked()
       +                                {
       +                                    lock.get_buffer_mut().buffer_type =
       +                                        BufferType::ExtendedFontAndIce;
       +                                    ui.close_menu();
       +                                }
       +                            });
       +                        }
       +                    }
       +                }
       +
                        self.commands
                            .pick_attribute_under_caret
                            .ui_enabled(ui, has_buffer, &mut result);