332 lines
11 KiB
Rust
332 lines
11 KiB
Rust
use crate::{perftrace, CoreApi};
|
|
use gio::resources_lookup_data;
|
|
use glib::Object;
|
|
use gtk::{
|
|
gdk_pixbuf::{InterpType, Pixbuf},
|
|
prelude::*,
|
|
subclass::prelude::*,
|
|
};
|
|
use image::io::Reader as ImageReader;
|
|
use otg_core::{
|
|
Color,
|
|
};
|
|
use std::{cell::RefCell, io::Cursor, rc::Rc};
|
|
|
|
const WIDTH: i32 = 800;
|
|
const HEIGHT: i32 = 800;
|
|
const MARGIN: i32 = 20;
|
|
|
|
#[derive(Clone, Default, PartialEq)]
|
|
struct Addr {
|
|
row: u8,
|
|
column: u8,
|
|
}
|
|
|
|
pub struct BoardPrivate {
|
|
drawing_area: gtk::DrawingArea,
|
|
|
|
current_player: Rc<RefCell<Color>>,
|
|
// board: Rc<RefCell<BoardElement>>,
|
|
cursor_location: Rc<RefCell<Option<Addr>>>,
|
|
|
|
api: Rc<RefCell<Option<CoreApi>>>,
|
|
}
|
|
|
|
#[glib::object_subclass]
|
|
impl ObjectSubclass for BoardPrivate {
|
|
const NAME: &'static str = "Board";
|
|
type Type = Board;
|
|
type ParentType = gtk::Grid;
|
|
|
|
fn new() -> BoardPrivate {
|
|
BoardPrivate {
|
|
drawing_area: Default::default(),
|
|
current_player: Rc::new(RefCell::new(Color::Black)),
|
|
// board: Default::default(),
|
|
cursor_location: Default::default(),
|
|
api: Default::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ObjectImpl for BoardPrivate {
|
|
fn constructed(&self) {
|
|
self.drawing_area.set_width_request(WIDTH);
|
|
self.drawing_area.set_height_request(HEIGHT);
|
|
|
|
// let board = self.board.clone();
|
|
let cursor_location = self.cursor_location.clone();
|
|
let current_player = self.current_player.clone();
|
|
|
|
let wood_texture = resources_lookup_data(
|
|
"/com/luminescent-dreams/otg-gtk/wood_texture.jpg",
|
|
gio::ResourceLookupFlags::NONE,
|
|
)
|
|
.unwrap();
|
|
let background = ImageReader::new(Cursor::new(wood_texture))
|
|
.with_guessed_format()
|
|
.unwrap()
|
|
.decode();
|
|
let background = background.map(|background| {
|
|
Pixbuf::from_bytes(
|
|
&glib::Bytes::from(background.as_bytes()),
|
|
gtk::gdk_pixbuf::Colorspace::Rgb,
|
|
false,
|
|
8,
|
|
background.width() as i32,
|
|
background.height() as i32,
|
|
background.to_rgb8().sample_layout().height_stride as i32,
|
|
)
|
|
.scale_simple(WIDTH, HEIGHT, InterpType::Nearest)
|
|
});
|
|
|
|
self.drawing_area
|
|
.set_draw_func(move |_, context, width, height| {
|
|
perftrace("render drawing area", || {
|
|
let render_start = std::time::Instant::now();
|
|
/*
|
|
let board = board.borrow();
|
|
|
|
match background {
|
|
Ok(Some(ref background)) => {
|
|
context.set_source_pixbuf(background, 0., 0.);
|
|
context.paint().expect("paint should succeed");
|
|
}
|
|
Ok(None) | Err(_) => context.set_source_rgb(0.7, 0.7, 0.7),
|
|
};
|
|
let _ = context.paint();
|
|
|
|
context.set_source_rgb(0.1, 0.1, 0.1);
|
|
context.set_line_width(2.);
|
|
let hspace_between = ((width - 40) as f64) / ((board.size.width - 1) as f64);
|
|
let vspace_between = ((height - 40) as f64) / ((board.size.height - 1) as f64);
|
|
|
|
let pen = Pen {
|
|
x_offset: MARGIN as f64,
|
|
y_offset: MARGIN as f64,
|
|
hspace_between,
|
|
vspace_between,
|
|
};
|
|
|
|
(0..board.size.width).for_each(|col| {
|
|
context.move_to(
|
|
(MARGIN as f64) + (col as f64) * hspace_between,
|
|
MARGIN as f64,
|
|
);
|
|
context.line_to(
|
|
(MARGIN as f64) + (col as f64) * hspace_between,
|
|
(height as f64) - (MARGIN as f64),
|
|
);
|
|
let _ = context.stroke();
|
|
});
|
|
(0..board.size.height).for_each(|row| {
|
|
context.move_to(
|
|
MARGIN as f64,
|
|
(MARGIN as f64) + (row as f64) * vspace_between,
|
|
);
|
|
context.line_to(
|
|
(width - MARGIN) as f64,
|
|
(MARGIN as f64) + (row as f64) * vspace_between,
|
|
);
|
|
let _ = context.stroke();
|
|
});
|
|
|
|
context.set_source_rgb(0.1, 0.1, 0.0);
|
|
vec![3, 9, 15].into_iter().for_each(|col| {
|
|
vec![3, 9, 15].into_iter().for_each(|row| {
|
|
pen.star_point(context, col, row);
|
|
});
|
|
});
|
|
*/
|
|
|
|
/*
|
|
(0..19).for_each(|col| {
|
|
(0..19).for_each(|row| {
|
|
if let IntersectionElement::Filled(stone) = board.stone(row, col) {
|
|
pen.stone(context, row, col, stone.color, stone.liberties);
|
|
};
|
|
})
|
|
});
|
|
|
|
let cursor = cursor_location.borrow();
|
|
match *cursor {
|
|
None => {}
|
|
Some(ref cursor) => {
|
|
if let IntersectionElement::Empty(_) =
|
|
board.stone(cursor.row, cursor.column)
|
|
{
|
|
pen.ghost_stone(
|
|
context,
|
|
cursor.row,
|
|
cursor.column,
|
|
*current_player.borrow(),
|
|
)
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
let render_end = std::time::Instant::now();
|
|
println!("board rendering time: {:?}", render_end - render_start);
|
|
})
|
|
});
|
|
|
|
let motion_controller = gtk::EventControllerMotion::new();
|
|
{
|
|
// let board = self.board.clone();
|
|
let cursor = self.cursor_location.clone();
|
|
let drawing_area = self.drawing_area.clone();
|
|
motion_controller.connect_motion(move |_, x, y| {
|
|
/*
|
|
let board = board.borrow();
|
|
let mut cursor = cursor.borrow_mut();
|
|
let hspace_between = ((WIDTH - 40) as f64) / ((board.size.width - 1) as f64);
|
|
let vspace_between = ((HEIGHT - 40) as f64) / ((board.size.height - 1) as f64);
|
|
|
|
let addr = if x.round() < MARGIN as f64
|
|
|| x.round() > (WIDTH - MARGIN) as f64
|
|
|| y.round() < MARGIN as f64
|
|
|| y.round() > (HEIGHT - MARGIN) as f64
|
|
{
|
|
None
|
|
} else {
|
|
Some(Addr {
|
|
column: ((x.round() - MARGIN as f64) / hspace_between).round() as u8,
|
|
row: ((y.round() - MARGIN as f64) / vspace_between).round() as u8,
|
|
})
|
|
};
|
|
|
|
if *cursor != addr.clone() {
|
|
*cursor = addr;
|
|
drawing_area.queue_draw();
|
|
}
|
|
*/
|
|
});
|
|
}
|
|
|
|
let gesture = gtk::GestureClick::new();
|
|
{
|
|
// let board = self.board.clone();
|
|
let cursor = self.cursor_location.clone();
|
|
let api = self.api.clone();
|
|
gesture.connect_released(move |_, _, _, _| {
|
|
/*
|
|
let board = board.borrow();
|
|
let cursor = cursor.borrow();
|
|
*/
|
|
/*
|
|
match *cursor {
|
|
None => {}
|
|
Some(ref cursor) => {
|
|
if let IntersectionElement::Empty(request) =
|
|
board.stone(cursor.row, cursor.column)
|
|
{
|
|
println!("need to send request: {:?}", request);
|
|
api.borrow()
|
|
.as_ref()
|
|
.expect("API must exist")
|
|
.dispatch(request);
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
});
|
|
}
|
|
|
|
self.drawing_area.add_controller(motion_controller);
|
|
self.drawing_area.add_controller(gesture);
|
|
}
|
|
}
|
|
impl WidgetImpl for BoardPrivate {}
|
|
impl GridImpl for BoardPrivate {}
|
|
|
|
glib::wrapper! {
|
|
pub struct Board(ObjectSubclass<BoardPrivate>) @extends gtk::Grid, gtk::Widget;
|
|
}
|
|
|
|
impl Board {
|
|
pub fn new(api: CoreApi) -> Self {
|
|
let s: Self = Object::builder().build();
|
|
|
|
*s.imp().api.borrow_mut() = Some(api);
|
|
s.attach(&s.imp().drawing_area, 1, 1, 1, 1);
|
|
|
|
s
|
|
}
|
|
|
|
/*
|
|
pub fn set_board(&self, board: BoardElement) {
|
|
*self.imp().board.borrow_mut() = board;
|
|
self.imp().drawing_area.queue_draw();
|
|
}
|
|
*/
|
|
|
|
pub fn set_current_player(&self, color: Color) {
|
|
*self.imp().current_player.borrow_mut() = color;
|
|
}
|
|
}
|
|
|
|
struct Pen {
|
|
x_offset: f64,
|
|
y_offset: f64,
|
|
hspace_between: f64,
|
|
vspace_between: f64,
|
|
}
|
|
|
|
impl Pen {
|
|
fn star_point(&self, context: &cairo::Context, row: u8, col: u8) {
|
|
context.arc(
|
|
self.x_offset + (col as f64) * self.hspace_between,
|
|
self.y_offset + (row as f64) * self.vspace_between,
|
|
5.,
|
|
0.,
|
|
2. * std::f64::consts::PI,
|
|
);
|
|
let _ = context.fill();
|
|
}
|
|
|
|
fn stone(
|
|
&self,
|
|
context: &cairo::Context,
|
|
row: u8,
|
|
col: u8,
|
|
color: Color,
|
|
liberties: Option<u8>,
|
|
) {
|
|
match color {
|
|
Color::White => context.set_source_rgb(0.9, 0.9, 0.9),
|
|
Color::Black => context.set_source_rgb(0.0, 0.0, 0.0),
|
|
};
|
|
self.draw_stone(context, row, col);
|
|
|
|
if let Some(liberties) = liberties {
|
|
let stone_location = self.stone_location(row, col);
|
|
context.set_source_rgb(1., 0., 1.);
|
|
context.set_font_size(32.);
|
|
context.move_to(stone_location.0 - 10., stone_location.1 + 10.);
|
|
let _ = context.show_text(&format!("{}", liberties));
|
|
}
|
|
}
|
|
|
|
fn ghost_stone(&self, context: &cairo::Context, row: u8, col: u8, color: Color) {
|
|
match color {
|
|
Color::White => context.set_source_rgba(0.9, 0.9, 0.9, 0.5),
|
|
Color::Black => context.set_source_rgba(0.0, 0.0, 0.0, 0.5),
|
|
};
|
|
self.draw_stone(context, row, col);
|
|
}
|
|
|
|
fn draw_stone(&self, context: &cairo::Context, row: u8, col: u8) {
|
|
let radius = self.hspace_between / 2. - 2.;
|
|
let (x_loc, y_loc) = self.stone_location(row, col);
|
|
context.arc(x_loc, y_loc, radius, 0.0, 2.0 * std::f64::consts::PI);
|
|
let _ = context.fill();
|
|
}
|
|
|
|
fn stone_location(&self, row: u8, col: u8) -> (f64, f64) {
|
|
(
|
|
self.x_offset + (col as f64) * self.hspace_between,
|
|
self.y_offset + (row as f64) * self.vspace_between,
|
|
)
|
|
}
|
|
}
|