122 lines
3.7 KiB
Rust
122 lines
3.7 KiB
Rust
use crate::data::repositories::Repository;
|
|
use crate::data_provider::card_states::CardStateRepository;
|
|
use crate::data_provider::decks::DeckRepository;
|
|
use crate::data_provider::history::HistoryRepository;
|
|
use crate::data_provider::settings::get_setting;
|
|
use crate::data_provider::sqlite::SqliteConnection;
|
|
use crate::data_provider::word_groups::WordGroupRepository;
|
|
use crate::data_provider::words::WordRepository;
|
|
use crate::navigation::RootMessage::Keyboard;
|
|
use crate::navigation::{AppSettings, RootMessage, ScreenState};
|
|
use iced::{Subscription, keyboard, window};
|
|
use iced_core::window::Position;
|
|
#[cfg(target_os = "linux")]
|
|
use iced_core::window::settings::PlatformSpecific;
|
|
use iced_core::{Font, Size, Theme};
|
|
use log::info;
|
|
use parking_lot::{Mutex, RwLock};
|
|
use rusqlite::Connection;
|
|
use std::sync::Arc;
|
|
|
|
pub const USER_FONT: Font = Font::with_name("Noto Sans JP");
|
|
|
|
pub fn start() -> iced::Result {
|
|
info!("Welcome to JapLearn");
|
|
iced::application(ScreenState::boot, ScreenState::update, ScreenState::view)
|
|
.window(window_settings())
|
|
.subscription(subscription)
|
|
.title("JapLearn")
|
|
.settings(iced::Settings {
|
|
default_text_size: iced::Pixels(18.0),
|
|
..iced::Settings::default()
|
|
})
|
|
.font(include_bytes!("../noto.ttf"))
|
|
.default_font(USER_FONT)
|
|
.theme(Theme::GruvboxDark)
|
|
.run()
|
|
}
|
|
|
|
#[allow(unused_mut)]
|
|
fn window_settings() -> window::Settings {
|
|
let mut settings = window::Settings {
|
|
position: Position::Centered,
|
|
min_size: Some(Size::new(700.0_f32, 700.0_f32)),
|
|
..Default::default()
|
|
};
|
|
|
|
#[cfg(target_os = "linux")]
|
|
{
|
|
settings.platform_specific = PlatformSpecific {
|
|
application_id: "JapLearn".to_string(),
|
|
override_redirect: false,
|
|
};
|
|
}
|
|
|
|
settings
|
|
}
|
|
|
|
fn subscription(_state: &ScreenState) -> Subscription<RootMessage> {
|
|
keyboard::listen().map(Keyboard)
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct AppState {
|
|
pub dictionary: WordRepository,
|
|
pub decks: DeckRepository,
|
|
pub word_groups: WordGroupRepository,
|
|
pub card_states: CardStateRepository,
|
|
pub connection: Arc<Mutex<SqliteConnection>>,
|
|
pub sync_data: Arc<RwLock<AppSettings>>,
|
|
pub history: HistoryRepository,
|
|
}
|
|
|
|
impl Default for AppState {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl AppState {
|
|
pub fn new() -> Self {
|
|
let connection = Arc::new(Mutex::new(SqliteConnection::default()));
|
|
Self {
|
|
dictionary: WordRepository::new(connection.clone()),
|
|
decks: DeckRepository::new(connection.clone()),
|
|
word_groups: WordGroupRepository::new(connection.clone()),
|
|
card_states: CardStateRepository::new(connection.clone()),
|
|
history: HistoryRepository::new(connection.clone()),
|
|
sync_data: Arc::new(RwLock::new(AppSettings {
|
|
key: None,
|
|
auto_web_fetch: false,
|
|
})),
|
|
connection,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn fill_state(state: &mut AppState) {
|
|
let connection = state.connection.lock();
|
|
|
|
let setting = load_settings(&connection);
|
|
drop(connection);
|
|
state.word_groups.write().start().unwrap();
|
|
state.dictionary.write().start().unwrap();
|
|
state.decks.write().start().unwrap();
|
|
state.history.write().start().unwrap();
|
|
state.card_states.write().start().unwrap();
|
|
|
|
state.sync_data = Arc::new(RwLock::new(setting))
|
|
}
|
|
|
|
fn load_settings(connection: &Connection) -> AppSettings {
|
|
let key = get_setting("SYNC_KEY".to_string(), connection);
|
|
let fetch = get_setting("AUTO_WEB_FETCH".to_string(), connection)
|
|
.unwrap_or("false".to_string())
|
|
.parse::<bool>()
|
|
.unwrap();
|
|
AppSettings {
|
|
key,
|
|
auto_web_fetch: fetch,
|
|
}
|
|
}
|