monorepo/kifu/gtk/src/ui/home.rs

197 lines
5.4 KiB
Rust
Raw Normal View History

2023-08-20 00:46:43 +00:00
use crate::{ui::GamePreview, CoreApi};
use glib::{Object, Properties};
use gtk::{glib, prelude::*, subclass::prelude::*};
2023-06-15 04:09:50 +00:00
use kifu_core::{
2023-08-20 00:46:43 +00:00
ui::{GamePreviewElement, HomeView, PlayerElement},
2023-06-15 04:09:50 +00:00
CoreRequest, CreateGameRequest, HotseatPlayerRequest, PlayerInfoRequest,
};
2023-08-20 00:46:43 +00:00
use std::{
cell::{Cell, RefCell},
rc::Rc,
};
use super::GameDatabase;
struct PlayerDataEntryPrivate {
name: gtk::Text,
rank: gtk::DropDown,
}
impl Default for PlayerDataEntryPrivate {
fn default() -> Self {
let rank = gtk::DropDown::builder().build();
Self {
name: gtk::Text::builder().build(),
rank,
}
}
}
#[glib::object_subclass]
impl ObjectSubclass for PlayerDataEntryPrivate {
const NAME: &'static str = "PlayerDataEntry";
type Type = PlayerDataEntry;
type ParentType = gtk::Box;
}
impl ObjectImpl for PlayerDataEntryPrivate {}
impl WidgetImpl for PlayerDataEntryPrivate {}
impl BoxImpl for PlayerDataEntryPrivate {}
glib::wrapper! {
struct PlayerDataEntry(ObjectSubclass<PlayerDataEntryPrivate>) @extends gtk::Box, gtk::Widget;
}
impl PlayerDataEntry {
pub fn new(element: PlayerElement) -> PlayerDataEntry {
let s: Self = Object::builder().build();
let rank_model = gio::ListStore::new(gtk::StringObject::static_type());
s.imp().rank.set_model(Some(&rank_model));
match element {
PlayerElement::Hotseat(player) => {
if let Some(placeholder) = player.placeholder {
s.imp().name.set_placeholder_text(Some(&placeholder));
}
player.ranks.iter().for_each(|rank| rank_model.append(&gtk::StringObject::new(rank)));
}
// PlayerElement::Remote(_) => s.imp().placeholder.set_text("remote player"),
// PlayerElement::Bot(_) => s.imp().placeholder.set_text("bot player"),
}
s.append(&s.imp().name);
s.append(&s.imp().rank);
s
}
pub fn text(&self) -> String {
let name = self.imp().name.buffer().text().to_string();
if name.is_empty() {
self.imp()
.name
.placeholder_text()
.map(|s| s.to_string())
.unwrap_or("".to_owned())
} else {
name
}
}
pub fn rank(&self) -> Option<String> {
self.imp().rank.selected_item().and_then(|obj| {
let str_obj = obj.downcast::<gtk::StringObject>().ok()?;
Some(str_obj.string().clone().to_string())
})
}
}
2023-05-26 04:16:40 +00:00
2023-08-20 00:46:43 +00:00
pub struct DatabaseGamePrivate {
game: Rc<RefCell<GamePreviewElement>>,
}
impl Default for DatabaseGamePrivate {
fn default() -> Self {
Self {
game: Rc::new(RefCell::new(GamePreviewElement {
date: vec![],
black_player: "".to_owned(),
black_rank: None,
white_player: "".to_owned(),
white_rank: None,
})),
}
}
}
#[glib::object_subclass]
impl ObjectSubclass for DatabaseGamePrivate {
const NAME: &'static str = "DatabaseGame";
type Type = DatabaseGame;
}
impl ObjectImpl for DatabaseGamePrivate {}
glib::wrapper! {
pub struct DatabaseGame(ObjectSubclass<DatabaseGamePrivate>);
}
impl DatabaseGame {
pub fn new(preview: GamePreviewElement) -> Self {
let s: Self = Object::builder().build();
*s.imp().game.borrow_mut() = preview;
s
}
}
2023-07-24 23:43:22 +00:00
pub struct HomePrivate {
black_player: Rc<RefCell<Option<PlayerDataEntry>>>,
white_player: Rc<RefCell<Option<PlayerDataEntry>>>,
2023-05-26 04:16:40 +00:00
}
2023-07-24 23:43:22 +00:00
impl Default for HomePrivate {
2023-05-26 04:16:40 +00:00
fn default() -> Self {
Self {
black_player: Rc::new(RefCell::new(None)),
white_player: Rc::new(RefCell::new(None)),
2023-05-26 04:16:40 +00:00
}
}
}
#[glib::object_subclass]
2023-07-24 23:43:22 +00:00
impl ObjectSubclass for HomePrivate {
const NAME: &'static str = "Home";
type Type = Home;
2023-05-26 04:16:40 +00:00
type ParentType = gtk::Grid;
}
2023-07-24 23:43:22 +00:00
impl ObjectImpl for HomePrivate {}
impl WidgetImpl for HomePrivate {}
impl GridImpl for HomePrivate {}
2023-05-26 04:16:40 +00:00
glib::wrapper! {
2023-07-24 23:43:22 +00:00
pub struct Home(ObjectSubclass<HomePrivate>) @extends gtk::Grid, gtk::Widget;
2023-05-26 04:16:40 +00:00
}
2023-07-24 23:43:22 +00:00
impl Home {
pub fn new(api: CoreApi, view: HomeView) -> Home {
2023-05-26 04:16:40 +00:00
let s: Self = Object::builder().build();
let black_player = PlayerDataEntry::new(view.black_player);
s.attach(&black_player, 1, 1, 1, 1);
*s.imp().black_player.borrow_mut() = Some(black_player.clone());
2023-05-26 04:16:40 +00:00
let white_player = PlayerDataEntry::new(view.white_player);
s.attach(&white_player, 2, 1, 1, 1);
*s.imp().white_player.borrow_mut() = Some(white_player.clone());
2023-06-15 04:09:50 +00:00
let new_game_button = gtk::Button::builder().label(&view.start_game.label).build();
s.attach(&new_game_button, 2, 2, 1, 1);
2023-08-20 00:46:43 +00:00
let database = GameDatabase::new();
s.attach(&database, 0, 3, 2, 2);
new_game_button.connect_clicked({
move |_| {
let black_player = black_player.clone();
let white_player = white_player.clone();
api.dispatch(CoreRequest::CreateGame(CreateGameRequest {
black_player: player_info(black_player.clone()),
white_player: player_info(white_player.clone()),
}));
}
});
2023-05-26 04:16:40 +00:00
s
}
}
fn player_info(player: PlayerDataEntry) -> PlayerInfoRequest {
PlayerInfoRequest::Hotseat(HotseatPlayerRequest {
name: player.text(),
rank: player.rank(),
})
}