Thinking about GUI

1 files changed, 34 insertions, 791 deletions

diff --git a/src/gui.rs b/src/gui.rs
index c633dac..32929ae 100644
--- a/src/gui.rs
+++ b/src/gui.rs
@@ -1,807 +1,50 @@
-/*
-    This file is part of Takwrap.
+use fltk::{app, button::*, enums::*, frame::*, text::*, window::*};
 
-    Takwrap is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    Foobar is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with Foobar.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-extern crate pancurses;
-
-pub use pancurses::Input::*;
-pub use pancurses::*;
-
-use std::fs::File;
-use std::io::Write;
-
-use crate::consulter::*;
-use crate::game::*;
-use crate::parser::*;
-
-#[derive(PartialEq)]
-pub enum GUIResult {
-    Undo,
-    Quit,
-    Save,
-    SwitchElement,
-    Raw(String),
-}
-
-pub struct GameLog {
-    action_window: Window,
-    pieces_window: Window,
-    has_colours: bool,
-    white_colour: u8,
-    black_colour: u8,
-    num_lines: usize,
-    offset: usize,
-    action_lines: Vec<String>,
-}
-
-impl GameLog {
-    pub fn new(
-        ypos: i32,
-        xpos: i32,
-        height: i32,
-        width: i32,
-        has_colours: bool,
-        white_colour: u8,
-        black_colour: u8,
-    ) -> GameLog {
-        let gl = GameLog {
-            pieces_window: newwin(4, width, ypos, xpos),
-            action_window: newwin(height - 5, width, ypos + 5, xpos),
-            has_colours,
-            white_colour,
-            black_colour,
-            num_lines: (height - 7) as usize,
-            offset: 0,
-            action_lines: Vec::new(),
-        };
-
-        gl.action_window.keypad(true);
-        gl.action_window.nodelay(false);
-        gl
-    }
-
-    pub fn update(&mut self, game: &Game) {
-        self.pieces_window.clear();
-
-        if self.has_colours {
-            self.pieces_window.attrset(ColorPair(self.white_colour));
-        }
-        self.pieces_window.addstr(format!(
-            "W: {:2}",
-            game.get_pieces(Player::White, Stone::Flat)
-        ));
-
-        self.pieces_window.attrset(Attribute::Normal);
-        self.pieces_window.addstr("  ");
-
-        if self.has_colours {
-            self.pieces_window.attrset(ColorPair(self.black_colour));
-        }
-        self.pieces_window.addstr(format!(
-            "B: {:2}",
-            game.get_pieces(Player::Black, Stone::Flat),
-        ));
-
-        self.pieces_window.attrset(Attribute::Normal);
-
-        self.pieces_window
-            .addstr(format!("  Variant: {}", game.get_start_type().to_string()));
-
-        self.pieces_window.mv(1, 0);
-
-        if self.has_colours {
-            self.pieces_window.attrset(ColorPair(self.white_colour));
-        }
-        self.pieces_window.addstr(format!(
-            "WC: {}",
-            game.get_pieces(Player::White, Stone::Capstone)
-        ));
-
-        self.pieces_window.attrset(Attribute::Normal);
-        self.pieces_window.addstr("  ");
-
-        if self.has_colours {
-            self.pieces_window.attrset(ColorPair(self.black_colour));
-        }
-        self.pieces_window.addstr(format!(
-            "BC: {}",
-            game.get_pieces(Player::Black, Stone::Capstone),
-        ));
-        self.pieces_window.attrset(Attribute::Normal);
-
-        self.pieces_window
-            .addstr(format!("  Ply: {}", game.get_ply() + 1));
-
-        self.pieces_window.mv(3, 0);
-        self.pieces_window.addstr("Active player: ");
-        match game.get_current_player() {
-            Player::Black => {
-                if self.has_colours {
-                    self.pieces_window.attrset(ColorPair(self.black_colour));
-                }
-            }
-            Player::White => {
-                if self.has_colours {
-                    self.pieces_window.attrset(ColorPair(self.white_colour));
-                }
-            }
-        }
-        self.pieces_window.addstr(game.get_current_player_name());
-
-        let new_lines = game.get_action_lines();
-        if new_lines.len() > self.num_lines {
-            self.offset = new_lines.len() - self.num_lines;
-        } else {
-            self.offset = 0;
-        }
-        self.action_lines = new_lines.clone();
-        self.list_actions();
-
-        self.pieces_window.refresh();
-    }
-
-    fn list_actions(&self) {
-        self.action_window.clear();
-        self.action_window.draw_box(0, 0);
-        let mut y = 1;
-        for i in 0..self.num_lines {
-            if let Some(line) = self.action_lines.get(i + self.offset) {
-                self.action_window.mv(y, 2);
-                self.action_window.addstr(line);
-                y += 1;
-            }
-        }
-        self.action_window.refresh();
-        self.action_window.mv(1, 2);
-    }
-
-    pub fn read_action(&mut self) -> GUIResult {
-        loop {
-            self.list_actions();
-            if let Some(inp) = self.action_window.getch() {
-                match inp {
-                    KeyUp => {
-                        if self.offset > 0 {
-                            self.offset -= 1;
-                        }
-                    }
-                    KeyDown => {
-                        if self.offset + self.num_lines < self.action_lines.len() {
-                            self.offset += 1;
-                        }
-                    }
-                    Character('\t') => return GUIResult::SwitchElement,
-                    Character('U') => return GUIResult::Undo,
-                    Character('Q') => return GUIResult::Quit,
-                    Character('S') => return GUIResult::Save,
-                    _ => (),
-                }
-            }
-        }
-    }
+#[derive(Debug, Clone, Copy)]
+enum Message {
+    Increment,
+    Decrement,
 }
 
-pub struct BoardGUI {
-    board_window: Window,
-    cell_windows: Vec<Window>,
-    size: u8,
-    cell_height: u8,
-    cell_width: u8,
-    hoff: i32,
-    cur_cell: Position,
-    has_colours: bool,
-    white_colour: u8,
-    black_colour: u8,
-}
+pub fn gui_test() -> Result<(), Box<dyn std::error::Error>> {
+    let app = app::App::default();
 
-impl BoardGUI {
-    fn draw_grid(&self) {
-        let s: i32 = self.size as i32;
-        let h: i32 = self.cell_height as i32;
-        let w: i32 = self.cell_width as i32;
-        for y in 0..h * s + 1 {
-            for x in 0..w * s + 1 {
-                if y % h == 0 {
-                    if x % w == 0 {
-                        self.board_window.mvaddch(y, x + self.hoff, '+');
-                    } else {
-                        self.board_window.mvaddch(y, x + self.hoff, '-');
-                    }
-                } else if x % w == 0 {
-                    self.board_window.mvaddch(y, x + self.hoff, '|');
-                }
-            }
-        }
-        for y in 0..s {
-            self.board_window
-                .mvaddstr(y * h + h / 2, 0, format!("{}.", s - y));
-        }
-        for x in 0..s {
-            self.board_window.mvaddstr(
-                s * h + 1,
-                w * x + w / 2 + self.hoff,
-                format!("{:x}.", x + 10),
-            );
-        }
-        self.board_window.refresh();
-    }
+    let mut wind = SingleWindow::default()
+        .with_size(800, 600)
+        .center_screen()
+        .with_label("Test");
+    wind.make_resizable(true);
 
-    fn pos_to_idx(&self, pos: &Position) -> usize {
-        let y = pos.y as usize;
-        let x = pos.x as usize;
-        x + y * (self.size as usize)
-    }
+    let mut ptn = TextDisplay::default()
+        .with_size(20 * 16, 30 * 16)
+        .with_pos(800 - 20 * 16 - 10, 0);
+    ptn.set_buffer(Some(TextBuffer::default()));
 
-    fn mv_to_cell(&self, pos: &Position, line: i32) {
-        if let Some(win) = self.cell_windows.get(self.pos_to_idx(pos)) {
-            win.mv(line, 0);
-            win.refresh();
-        }
-    }
+    let mut but_inc = Button::new(30, 40, 100, 40, "@+");
+    let mut but_dec = Button::new(30, 120, 100, 40, "@square");
+    wind.end();
+    wind.show();
 
-    fn draw_stone(&self, win: &Window, top: bool, buried: bool, player: &Player, stone: &Stone) {
-        if self.has_colours && (!buried) {
-            match player {
-                Player::Black => win.attron(ColorPair(self.black_colour)),
-                Player::White => win.attron(ColorPair(self.white_colour)),
-            };
-            if top {
-                win.addch(match stone {
-                    Stone::Flat => '#',
-                    Stone::Standing => '/',
-                    Stone::Capstone => '*',
-                });
-            } else {
-                win.addstr(format!("{}", player));
-            }
-            win.attrset(Attribute::Normal);
-        } else {
-            if buried {
-                win.attron(Attribute::Underline);
-            }
-            win.addstr(format!("{}", player));
-            if top {
-                win.addstr(format!("{}", stone));
-            }
-        }
-    }
+    let (s, r) = app::channel::<Message>();
 
-    fn draw_stack(&self, pos: &Position, stack: &Stack) {
-        if let Some(win) = self.cell_windows.get(self.pos_to_idx(pos)) {
-            win.clear();
-            let height = stack.len() as i32;
-            if height > 0 {
-                let carry_capacity = self.size;
+    but_inc.emit(s, Message::Increment);
+    but_dec.emit(s, Message::Decrement);
 
-                let my = win.get_max_y();
-                let mut cy = 0;
-                let mut cx = 0;
+    let mut state = 0;
 
-                for i in 0..height {
-                    let piece = &stack[(height - i - 1) as usize];
-                    self.draw_stone(
-                        win,
-                        i == 0,
-                        i >= carry_capacity as i32,
-                        &piece.player,
-                        &piece.stone,
-                    );
-                    cy += 1;
-                    if (cy >= my) && (i + 1 < height) {
-                        cx += 1;
-                        if i + my - 1 >= height {
-                            cy = i + my - height + 1;
-                        } else {
-                            cy = 1;
-                        }
-                        win.mv(0, cx);
-                        win.attrset(Attribute::Normal);
-                        win.addch('v');
-                    }
-                    win.mv(cy, cx);
-                }
+    while app.wait()? {
+        match r.recv() {
+            Some(Message::Increment) => {
+                state += 1;
+                ptn.insert(&format!("Increment {}\n", state));
             }
-            win.refresh();
-        }
-    }
 
-    pub fn update(&self, game: &Game, squares: Vec<Position>) {
-        // Is this really the `best' way?
-        assert!(game.get_size() == self.size);
-        for p in squares {
-            if let Some(stack) = game.query_square(&p) {
-                self.draw_stack(&p, stack);
+            Some(Message::Decrement) => {
+                state -= 1;
+                ptn.insert(&format!("Decrement {}\n", state));
             }
+            None => (),
         }
-        // Prevent redraw of the grid itself?
-        self.board_window.untouch();
-    }
-
-    pub fn new(
-        ypos: i32,
-        xpos: i32,
-        size: u8,
-        cell_height: u8,
-        cell_width: u8,
-        hoff: u8,
-        has_colours: bool,
-        white_colour: u8,
-        black_colour: u8,
-    ) -> BoardGUI {
-        let hoff = hoff as i32;
-        let s: i32 = size as i32;
-        let h: i32 = cell_height as i32;
-        let w: i32 = cell_width as i32;
-
-        let board_window = newwin(h * s + 3, w * s + 3 + hoff, ypos, xpos);
-
-        let mut cell_windows: Vec<Window> = Vec::new();
-        for i in 0..s * s {
-            let y: i32 = i / s;
-            let x: i32 = i % s;
-            cell_windows.push(newwin(
-                h - 1,
-                w - 1,
-                (s - y - 1) * h + 1 + ypos,
-                hoff + x * w + 1 + xpos,
-            ));
-        }
-
-        let bg = BoardGUI {
-            board_window,
-            cell_windows,
-            size,
-            cell_height,
-            cell_width,
-            hoff,
-            cur_cell: Position { x: 0, y: 0 },
-            has_colours,
-            black_colour,
-            white_colour,
-        };
-
-        bg.board_window.keypad(true);
-        bg.board_window.nodelay(false);
-
-        bg.draw_grid();
-
-        bg.mv_to_cell(&bg.cur_cell, 0);
-        bg.board_window.refresh();
-        bg
-    }
-}
-
-pub struct ActionEntry {
-    window: Window,
-    max_len: usize,
-    xstart: i32,
-}
-
-impl ActionEntry {
-    pub fn clear_entry_area(&self) {
-        self.window.mv(0, self.xstart);
-        for _i in 0..self.max_len {
-            self.window.addch('_');
-        }
-
-        self.window.mv(0, self.xstart);
-        self.window.refresh();
-    }
-
-    pub fn new(ypos: i32, xpos: i32, max_len: usize) -> ActionEntry {
-        let txt = "Enter action: ";
-        let xstart = txt.len() as i32;
-        let width = max_len as i32 + xstart + 1;
-
-        let ae = ActionEntry {
-            window: newwin(1, width, ypos, xpos),
-            max_len,
-            xstart,
-        };
-
-        ae.window.nodelay(false);
-        ae.window.keypad(true);
-
-        ae.window.addstr(txt);
-        ae.clear_entry_area();
-        ae
-    }
-
-    pub fn read_action(&self) -> GUIResult {
-        self.window.mv(0, self.xstart);
-        self.window.refresh();
-
-        let mut result = String::new();
-        loop {
-            if let Some(inp) = self.window.getch() {
-                match inp {
-                    Character('\t') => return GUIResult::SwitchElement,
-                    Character('\n') => break,
-
-                    Character(c) => {
-                        // Annoyingly there are two backspace possibilities
-                        let ascii = c as usize;
-                        if !result.is_empty() && (ascii == 127) || (ascii == 8) {
-                            result.pop();
-                            let (y, x) = (self.window.get_cur_y(), self.window.get_cur_x());
-                            self.window.mv(y, x - 1);
-                            self.window.addch('_');
-                            self.window.mv(y, x - 1);
-                        } else {
-                            if (result.len() < self.max_len) && (ascii > 32) && (ascii < 127) {
-                                result.push(c);
-                                self.window.addch(c);
-                            }
-                        }
-                    }
-                    KeyBackspace => {
-                        if !result.is_empty() {
-                            result.pop();
-                            let (y, x) = (self.window.get_cur_y(), self.window.get_cur_x());
-                            self.window.mv(y, x - 1);
-                            self.window.addch('_');
-                            self.window.mv(y, x - 1);
-                        }
-                    }
-
-                    KeyEnter => break,
-                    _ => (),
-                };
-            }
-            self.window.refresh();
-        }
-        self.clear_entry_area();
-        return GUIResult::Raw(result);
-    }
-}
-
-pub struct MessageLog {
-    window: Window,
-    has_colours: bool,
-    red_colour: u8,
-}
-
-impl MessageLog {
-    pub fn new(
-        ypos: i32,
-        xpos: i32,
-        height: i32,
-        width: i32,
-        has_colours: bool,
-        red_colour: u8,
-    ) -> MessageLog {
-        MessageLog {
-            window: newwin(height, width, ypos, xpos),
-            has_colours: has_colours,
-            red_colour: red_colour,
-        }
-    }
-
-    pub fn log_message(&self, str: String) {
-        self.window.clear();
-        if self.has_colours {
-            self.window.attrset(Attribute::Normal);
-        }
-        self.window.addstr(str);
-        self.window.refresh();
-    }
-
-    pub fn log_error(&self, str: String) {
-        self.window.clear();
-        if self.has_colours {
-            self.window.attrset(ColorPair(self.red_colour));
-        }
-        self.window.addstr(str);
-        self.window.refresh();
-    }
-}
-
-enum InputSource {
-    Player,
-    Log,
-}
-
-const ACTION_HEADER: &str = "Enter action in PTN";
-const LOG_HEADER: &str = "U to undo a turn | <UP>/<DOWN> to scroll | S to save PTN | Q to quit";
-
-pub struct GUI {
-    screen: Window,
-    game_log: GameLog,
-    pub message_log: MessageLog,
-    action_entry: ActionEntry,
-    board_gui: BoardGUI,
-    input_source: InputSource,
-}
-
-impl GUI {
-    fn write_header(&self, header: &str) {
-        self.screen.mv(0, 0);
-        self.screen.clrtoeol();
-        self.screen.addstr(format!(
-            "takwrap {} | <TAB> to switch GUI element | {}",
-            env!("CARGO_PKG_VERSION").to_string(),
-            header
-        ));
-        self.screen.mvchgat(0, 0, -1, A_REVERSE, -1);
-        self.screen.refresh();
-    }
-
-    fn save(&self, game: &Game) {
-        let file = File::create(format!("Game_{}.ptn", game.get_date_string()));
-
-        match file {
-            Err(e) => {
-                self.message_log
-                    .log_error(format!("Unable to open PTN file for writing: {}", e));
-            }
-            Ok(file) => {
-                if let Err(e) = write!(&file, "{}", game.to_string()) {
-                    self.message_log
-                        .log_error(format!("Unable to write PTN to file: {}", e));
-                } else {
-                    self.message_log.log_message(String::from("PTN saved."));
-                }
-            }
-        }
-    }
-
-    pub fn new(game: &Game, warning: String) -> GUI {
-        let screen = initscr();
-        cbreak();
-        noecho();
-        curs_set(2);
-
-        let has_colours = has_colors();
-        let (black_colour, white_colour, red_colour): (u8, u8, u8) = (1, 2, 3);
-
-        if has_colours {
-            start_color();
-            use_default_colors();
-            init_pair(black_colour as i16, -1, COLOR_RED);
-            init_pair(white_colour as i16, -1, COLOR_BLUE);
-            init_pair(red_colour as i16, COLOR_RED, -1);
-        }
-
-        let voff = 2;
-
-        let height = screen.get_max_y() - voff;
-
-        screen.refresh();
-
-        let cell_height = 4;
-        let cell_width = 8;
-        let hoff = 3;
-        let size = game.get_size();
-
-        let board_bottom = voff + (size * cell_height + 3) as i32;
-        let board_right = (hoff + size * cell_width + 3) as i32;
-
-        let board_gui = BoardGUI::new(
-            voff,
-            0,
-            size,
-            cell_height,
-            cell_width,
-            hoff,
-            has_colours,
-            white_colour,
-            black_colour,
-        );
-
-        let game_log = GameLog::new(
-            voff,
-            board_right,
-            height - 2,
-            30,
-            has_colours,
-            white_colour,
-            black_colour,
-        );
-
-        // Need room for '8___011111111', for example
-        let action_entry = ActionEntry::new(board_bottom, 0, 13);
-
-        let message_log = MessageLog::new(
-            board_bottom + 2,
-            0,
-            height - board_bottom - 1,
-            board_right,
-            has_colours,
-            red_colour,
-        );
-
-        let mut gui = GUI {
-            screen,
-            game_log,
-            message_log,
-            action_entry,
-            board_gui,
-            input_source: InputSource::Player,
-        };
-
-        gui.write_header(ACTION_HEADER);
-        gui.message_log.log_error(warning);
-        gui.game_log.update(game);
-
-        gui
-    }
-
-    pub fn query_input(
-        &mut self,
-        game: &Game,
-        call_proc: bool,
-        p1_white: bool,
-        engine: &str,
-    ) -> Result<GUIResult, String> {
-        match self.input_source {
-            InputSource::Player => {
-                let player = game.get_current_player();
-
-                let inp = match player {
-                    Player::Black => {
-                        if call_proc && p1_white {
-                            self.message_log
-                                .log_message(String::from("Opponent is thinking..."));
-                            consult_next_action(&game, &engine)
-                        } else {
-                            Ok(self.action_entry.read_action())
-                        }
-                    }
-                    Player::White => {
-                        if call_proc && (!p1_white) {
-                            self.message_log
-                                .log_message(String::from("Opponent is thinking..."));
-                            consult_next_action(&game, &engine)
-                        } else {
-                            Ok(self.action_entry.read_action())
-                        }
-                    }
-                };
-
-                match inp {
-                    Err(e) => Err(format!("Error: {}", e)),
-                    Ok(ok) => Ok(ok),
-                }
-            }
-            InputSource::Log => Ok(self.game_log.read_action()),
-        }
-    }
-
-    pub fn handle_input(
-        &mut self,
-        game: &mut Game,
-        call_proc: bool,
-        p1_white: bool,
-        input: Result<GUIResult, String>,
-    ) -> bool {
-        let player = game.get_current_player();
-        let engine_turn = call_proc
-            && ((p1_white && player == Player::Black) || ((!p1_white) && player == Player::White));
-
-        match input {
-            Err(e) => {
-                if engine_turn {
-                    self.message_log
-                        .log_error(format!("Unrecoverable error: {}", e));
-                    return false;
-                }
-            }
-            Ok(gui_result) => match gui_result {
-                GUIResult::Quit => {
-                    self.message_log
-                        .log_message(String::from("Press any key to quit."));
-                    self.screen.getch();
-                    return false;
-                }
-                GUIResult::Save => {
-                    self.save(game);
-                    self.screen.getch();
-                    return false;
-                }
-                GUIResult::SwitchElement => match self.input_source {
-                    InputSource::Player => {
-                        self.input_source = InputSource::Log;
-                        self.write_header(LOG_HEADER);
-                    }
-                    InputSource::Log => {
-                        self.input_source = InputSource::Player;
-                        self.write_header(ACTION_HEADER);
-                    }
-                },
-                GUIResult::Undo => match game.undo() {
-                    Ok(pos_vec) => {
-                        self.message_log
-                            .log_message(String::from("Game undone by one turn."));
-                        self.board_gui.update(&game, pos_vec);
-                        self.game_log.update(&game);
-                    }
-                    Err(err) => {
-                        self.message_log.log_error(err);
-                    }
-                },
-                GUIResult::Raw(raw) => {
-                    let stone_owner = game.get_stone_owner();
-                    let act = parse_action(stone_owner, &raw);
-                    match act {
-                        Err(err) => {
-                            self.message_log
-                                .log_error(format!("Input \"{}\": {}", raw, err));
-                            if engine_turn {
-                                return false;
-                            }
-                        }
-                        Ok(act) => {
-                            let pn = game.get_current_player_name();
-                            self.message_log.log_message(format!(
-                                "{} performs {}{}",
-                                pn,
-                                act,
-                                if stone_owner != player {
-                                    format!(" with a {} stone.", stone_owner)
-                                } else {
-                                    String::from(".")
-                                }
-                            ));
-                            let act_string = act.to_string();
-                            match game.perform_action(act) {
-                                Err(e) => {
-                                    if engine_turn {
-                                        self.message_log.log_error(String::from(
-                                    "Error: external and internal game states disagree. Press any key to quit.",
-                                        ));
-                                        self.screen.getch();
-                                        return false;
-                                    } else {
-                                        self.message_log.log_error(format!(
-                                            "Cannot perform \"{}\": {}",
-                                            act_string, e
-                                        ));
-                                    }
-                                }
-
-                                Ok((pos_vec, win)) => {
-                                    self.board_gui.update(&game, pos_vec);
-                                    self.game_log.update(&game);
-                                    if let Some(w) = win {
-                                        self.message_log.log_message(format!(
-                                            "Game over: {}\nPress S to save PTN and quit, or Q to quit.",
-                                            w
-                                        ));
-                                        loop {
-                                            if let Some(inp) = self.screen.getch() {
-                                                match inp {
-                                                    Character('S') => {
-                                                        self.save(game);
-                                                        return false;
-                                                    }
-                                                    Character('Q') => {
-                                                        return false;
-                                                    }
-                                                    _ => (),
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            },
-        }
-        return true;
     }
+    Ok(())
 }