use rust-i18n for translations

Author: Ivan-1F

Cargo.lock

@@ -73,3 +73,4 @@ rfd = "0.14.1"
 futures-lite = "2.3.0"
 anyhow = "1.0.83"
 egui-toast = "0.13.0"
+rust-i18n = "3.0.1"

Cargo.toml

@@ -1,6 +1,6 @@
 menu_bar:
   file:
-    .: File
+    title: File
     quit: Quit
     save: Save
 

lang/en_us.yml

@@ -1,6 +1,6 @@
 menu_bar:
   file:
-    .: 文件
+    title: 文件
     quit: 退出
     save: 保存
 

lang/zh_cn.yml

@@ -16,7 +16,6 @@ mod selection;
 mod serialzation;
 mod tab;
 mod timing;
-mod translation;
 mod widgets;
 
 use crate::assets::AssetsPlugin;
@@ -42,14 +41,15 @@ use crate::tab::timeline::{TimelineTabPlugin, TimelineViewport};
 use crate::tab::TabPlugin;
 use crate::tab::{EditorTab, TabRegistry};
 use crate::timing::TimingPlugin;
-use crate::translation::{TranslationPlugin, Translator};
 use bevy::diagnostic::{DiagnosticsStore, FrameTimeDiagnosticsPlugin};
-use bevy::ecs::system::SystemState;
 use bevy::prelude::*;
 use bevy_egui::egui::{Color32, Frame};
 use bevy_egui::{EguiContext, EguiPlugin};
 use bevy_mod_picking::prelude::*;
 use egui_dock::{DockArea, DockState, NodeIndex, Style};
+use rust_i18n::{i18n, t};
+
+i18n!("lang", fallback = "en_us");
 
 fn main() {
     App::new()
@@ -71,7 +71,6 @@ fn main() {
         .add_plugins(EditingPlugin)
         .add_plugins(FrameTimeDiagnosticsPlugin)
         .add_plugins(AssetsPlugin)
-        .add_plugins(TranslationPlugin)
         .add_plugins(NotificationPlugin)
         .add_plugins(FilePickingPlugin)
         .add_systems(Startup, setup_egui_image_loader_system)
@@ -125,7 +124,7 @@ fn setup_egui_font_system(
     font_def
         .families
         .get_mut(&font_family)
-        .expect("Failed to setuo font")
+        .expect("Failed to setup font")
         .insert(0, font_name);
 
     ctx.set_fonts(font_def);
@@ -176,13 +175,10 @@ impl egui_dock::TabViewer for TabViewer<'_> {
     type Tab = EditorTab;
 
     fn title(&mut self, tab: &mut Self::Tab) -> egui::WidgetText {
-        let mut system_state: SystemState<Translator> = SystemState::new(self.world);
-        let translator = system_state.get(self.world);
-
         self.registry
             .get(tab)
-            .map(|t| translator.tr(t.title()))
-            .unwrap_or("Unknown".to_string())
+            .map(|t| t!(t.title()))
+            .unwrap_or("Unknown".into())
             .into()
     }
 
@@ -248,16 +244,10 @@ fn ui_system(world: &mut World) {
         fps = value;
     }
 
-    let mut system_state: SystemState<Translator> = SystemState::new(world);
-    let translator = system_state.get(world);
-    let file = translator.tr("menu_bar.file");
-    let save = translator.tr("menu_bar.file.save");
-    let quit = translator.tr("menu_bar.file.quit");
-
     egui::TopBottomPanel::top("phichain.MenuBar").show(ctx, |ui| {
         egui::menu::bar(ui, |ui| {
-            ui.menu_button(file, |ui| {
-                if ui.button(save).clicked() {
+            ui.menu_button(t!("menu_bar.file.title"), |ui| {
+                if ui.button(t!("menu_bar.file.save")).clicked() {
                     if let Ok(chart) = PhiChainExporter::export(world) {
                         let project = world.resource::<Project>();
                         let result = std::fs::write(project.root_dir.join("chart.json"), chart);
@@ -273,16 +263,24 @@ fn ui_system(world: &mut World) {
                     }
                 }
                 ui.separator();
-                if ui.button(quit).clicked() {
+                if ui.button(t!("menu_bar.file.quit")).clicked() {
                     std::process::exit(0);
                 }
             });
             ui.menu_button("Tabs", |ui| {
                 world.resource_scope(|world, mut ui_state: Mut<UiState>| {
                     world.resource_scope(|_, registry: Mut<TabRegistry>| {
                         for (tab, registered_tab) in registry.iter() {
-                            let opened = ui_state.state.iter_all_tabs().map(|x| x.1).collect::<Vec<_>>().contains(&tab);
-                            if ui.selectable_label(opened, registered_tab.title()).clicked() {
+                            let opened = ui_state
+                                .state
+                                .iter_all_tabs()
+                                .map(|x| x.1)
+                                .collect::<Vec<_>>()
+                                .contains(&tab);
+                            if ui
+                                .selectable_label(opened, t!(registered_tab.title()))
+                                .clicked()
+                            {
                                 if opened {
                                     if let Some(node) = ui_state.state.find_tab(tab) {
                                         ui_state.state.remove_tab(node);

src/main.rs

@@ -1,28 +1,23 @@
 use crate::audio::AudioSettings;
 use bevy::prelude::*;
 use egui::Ui;
+use rust_i18n::t;
 
-use crate::translation::Translator;
-
-pub fn audio_setting_tab(
-    In(ui): In<&mut Ui>,
-    mut audio_settings: ResMut<AudioSettings>,
-    translator: Translator,
-) {
+pub fn audio_setting_tab(In(ui): In<&mut Ui>, mut audio_settings: ResMut<AudioSettings>) {
     egui::Grid::new("audio_setting_grid")
         .num_columns(2)
         .spacing([40.0, 2.0])
         .striped(true)
         .show(ui, |ui| {
-            ui.label(translator.tr("tab.audio_setting.music_volume"));
+            ui.label(t!("tab.audio_setting.music_volume"));
             ui.add(
                 egui::DragValue::new(&mut audio_settings.music_volume)
                     .clamp_range(0.00..=1.2)
                     .speed(0.01),
             );
             ui.end_row();
 
-            ui.label(translator.tr("tab.audio_setting.hit_sound_volume"));
+            ui.label(t!("tab.audio_setting.hit_sound_volume"));
             ui.add(
                 egui::DragValue::new(&mut audio_settings.hit_sound_volume)
                     .clamp_range(0.00..=1.2)

src/tab/audio_setting.rs

@@ -1,20 +1,15 @@
 use crate::audio::Offset;
 use bevy::prelude::*;
 use egui::Ui;
+use rust_i18n::t;
 
-use crate::translation::Translator;
-
-pub fn chart_basic_setting_tab(
-    In(ui): In<&mut Ui>,
-    mut offset: ResMut<Offset>,
-    translator: Translator,
-) {
+pub fn chart_basic_setting_tab(In(ui): In<&mut Ui>, mut offset: ResMut<Offset>) {
     egui::Grid::new("chart_basic_setting_grid")
         .num_columns(2)
         .spacing([40.0, 2.0])
         .striped(true)
         .show(ui, |ui| {
-            ui.label(translator.tr("tab.chart_basic_setting.offset"));
+            ui.label(t!("tab.chart_basic_setting.offset"));
             ui.add(egui::DragValue::new(&mut offset.0).speed(1));
             ui.end_row();
         });

src/tab/chart_basic_setting.rs

@@ -1,6 +1,7 @@
 use bevy::prelude::*;
 use egui::Ui;
 use num::Rational32;
+use rust_i18n::t;
 
 use crate::chart::event::{LineEvent, LineEventKind};
 use crate::{
@@ -9,23 +10,21 @@ use crate::{
         note::{Note, NoteKind},
     },
     selection::Selected,
-    translation::Translator,
 };
 
 pub fn inspector_ui_system(
     In(ui): In<&mut Ui>,
     mut selected_notes: Query<&mut Note, With<Selected>>,
     mut selected_events: Query<&mut LineEvent, With<Selected>>,
-    translator: Translator,
 ) {
     let mut selected_notes: Vec<_> = selected_notes.iter_mut().collect();
     let mut selected_events: Vec<_> = selected_events.iter_mut().collect();
     if selected_notes.len() == 1 && selected_events.is_empty() {
         let selected_note = selected_notes.get_mut(0).unwrap();
-        single_note_inspector(ui, selected_note, &translator);
+        single_note_inspector(ui, selected_note);
     } else if selected_notes.is_empty() && selected_events.len() == 1 {
         let selected_event = selected_events.get_mut(0).unwrap();
-        single_event_inspector(ui, selected_event, &translator);
+        single_event_inspector(ui, selected_event);
     }
 }
 
@@ -62,21 +61,21 @@ impl BeatExt for Ui {
     }
 }
 
-fn single_event_inspector(ui: &mut Ui, event: &mut LineEvent, translator: &Translator) {
+fn single_event_inspector(ui: &mut Ui, event: &mut LineEvent) {
     egui::Grid::new("inspector_grid")
         .num_columns(2)
         .spacing([40.0, 2.0])
         .striped(true)
         .show(ui, |ui| {
-            ui.label(translator.tr("tab.inspector.single_event.start_beat"));
+            ui.label(t!("tab.inspector.single_event.start_beat"));
             ui.beat(&mut event.start_beat);
             ui.end_row();
 
-            ui.label(translator.tr("tab.inspector.single_event.end_beat"));
+            ui.label(t!("tab.inspector.single_event.end_beat"));
             ui.beat(&mut event.end_beat);
             ui.end_row();
 
-            ui.label(translator.tr("tab.inspector.single_event.start_value"));
+            ui.label(t!("tab.inspector.single_event.start_value"));
             let range = match event.kind {
                 LineEventKind::Opacity => 0.0..=255.0,
                 _ => f32::MIN..=f32::MAX,
@@ -88,7 +87,7 @@ fn single_event_inspector(ui: &mut Ui, event: &mut LineEvent, translator: &Trans
             );
             ui.end_row();
 
-            ui.label(translator.tr("tab.inspector.single_event.end_value"));
+            ui.label(t!("tab.inspector.single_event.end_value"));
             ui.add(
                 egui::DragValue::new(&mut event.end)
                     .clamp_range(range.clone())
@@ -98,22 +97,22 @@ fn single_event_inspector(ui: &mut Ui, event: &mut LineEvent, translator: &Trans
         });
 }
 
-fn single_note_inspector(ui: &mut Ui, note: &mut Note, translator: &Translator) {
+fn single_note_inspector(ui: &mut Ui, note: &mut Note) {
     egui::Grid::new("inspector_grid")
         .num_columns(2)
         .spacing([40.0, 2.0])
         .striped(true)
         .show(ui, |ui| {
-            ui.label(translator.tr("tab.inspector.single_note.x"));
+            ui.label(t!("tab.inspector.single_note.x"));
             ui.add(egui::DragValue::new(&mut note.x).speed(1));
             ui.end_row();
 
-            ui.label(translator.tr("tab.inspector.single_note.beat"));
+            ui.label(t!("tab.inspector.single_note.beat"));
             ui.beat(&mut note.beat);
             ui.end_row();
 
             if let NoteKind::Hold { hold_beat } = note.kind {
-                ui.label(translator.tr("tab.inspector.single_note.hold_beat"));
+                ui.label(t!("tab.inspector.single_note.hold_beat"));
 
                 let mut bind = hold_beat;
                 ui.beat(&mut bind);
@@ -124,7 +123,7 @@ fn single_note_inspector(ui: &mut Ui, note: &mut Note, translator: &Translator)
                 ui.end_row();
             }
 
-            ui.label(translator.tr("tab.inspector.single_note.above"));
+            ui.label(t!("tab.inspector.single_note.above"));
             ui.checkbox(&mut note.above, "");
         });
 }

src/tab/inspector.rs

@@ -1,37 +1,32 @@
 use bevy::prelude::*;
 use egui::Ui;
-
-use crate::translation::Translator;
+use rust_i18n::t;
 
 use super::timeline::TimelineSettings;
 
-pub fn timeline_setting_tab(
-    In(ui): In<&mut Ui>,
-    mut timeline_settings: ResMut<TimelineSettings>,
-    translator: Translator,
-) {
+pub fn timeline_setting_tab(In(ui): In<&mut Ui>, mut timeline_settings: ResMut<TimelineSettings>) {
     egui::Grid::new("timeline_setting_grid")
         .num_columns(2)
         .spacing([40.0, 2.0])
         .striped(true)
         .show(ui, |ui| {
-            ui.label(translator.tr("tab.timeline_setting.zoom"));
+            ui.label(t!("tab.timeline_setting.zoom"));
             ui.add(
                 egui::DragValue::new(&mut timeline_settings.zoom)
                     .clamp_range(0.1..=f32::MAX)
                     .speed(0.01),
             );
             ui.end_row();
 
-            ui.label(translator.tr("tab.timeline_setting.density"));
+            ui.label(t!("tab.timeline_setting.density"));
             ui.add(
                 egui::DragValue::new(&mut timeline_settings.density)
                     .clamp_range(1..=32)
                     .speed(1),
             );
             ui.end_row();
 
-            ui.label(translator.tr("tab.timeline_setting.lane"));
+            ui.label(t!("tab.timeline_setting.lane"));
             ui.add(
                 egui::DragValue::new(&mut timeline_settings.lanes)
                     .clamp_range(1..=32)