wip

Author: functora

rust/cryptonote/src/i18n.rs

@@ -27,10 +27,12 @@ impl Language {
 
 #[derive(Clone)]
 pub struct Translations {
+    pub note: &'static str,
     pub note_placeholder: &'static str,
+    pub mode: &'static str,
     pub no_encryption: &'static str,
     pub password_encryption: &'static str,
-    pub cipher: &'static str,
+    pub algorithm: &'static str,
     pub password: &'static str,
     pub password_placeholder: &'static str,
     pub generate_button: &'static str,
@@ -60,10 +62,12 @@ pub struct Translations {
 pub fn get_translations(lang: Language) -> Translations {
     match lang {
         Language::English => Translations {
+            note: "Note",
             note_placeholder: "Enter your note here...",
+            mode: "Mode",
             no_encryption: "No encryption (plaintext)",
             password_encryption: "Password encryption",
-            cipher: "Cipher",
+            algorithm: "Algorithm",
             password: "Password",
             password_placeholder: "Enter password",
             generate_button: "Generate Shareable Link",
@@ -90,10 +94,12 @@ pub fn get_translations(lang: Language) -> Translations {
             url_error: "Invalid URL format",
         },
         Language::Spanish => Translations {
+            note: "Nota",
             note_placeholder: "Escribe tu nota aquí...",
+            mode: "Modo",
             no_encryption: "Sin cifrado (texto plano)",
             password_encryption: "Cifrado con contraseña",
-            cipher: "Cifrado",
+            algorithm: "Algoritmo",
             password: "Contraseña",
             password_placeholder: "Ingresa contraseña",
             generate_button: "Generar Enlace Compartible",
@@ -120,10 +126,12 @@ pub fn get_translations(lang: Language) -> Translations {
             url_error: "Formato de URL inválido",
         },
         Language::Russian => Translations {
+            note: "Заметка",
             note_placeholder: "Введите вашу заметку здесь...",
+            mode: "Режим",
             no_encryption: "Без шифрования (открытый текст)",
             password_encryption: "Шифрование паролем",
-            cipher: "Шифр",
+            algorithm: "Алгоритм",
             password: "Пароль",
             password_placeholder: "Введите пароль",
             generate_button: "Создать Ссылку для Обмена",

rust/cryptonote/src/views/home.rs

@@ -11,7 +11,8 @@ pub fn Home() -> Element {
     let t = get_translations(language());
 
     let mut note_text = use_signal(|| String::new());
-    let mut encryption = use_signal(|| Option::<CipherType>::None);
+    let mut encryption =
+        use_signal(|| Option::<CipherType>::None);
     let mut password = use_signal(|| String::new());
     let mut generated_url =
         use_signal(|| Option::<String>::None);
@@ -44,11 +45,12 @@ pub fn Home() -> Element {
                     &pwd,
                     cipher,
                 ) {
-                    Ok(encrypted) => NoteData::CipherText(encrypted),
+                    Ok(encrypted) => {
+                        NoteData::CipherText(encrypted)
+                    }
                     Err(e) => {
-                        error_message.set(Some(
-                            e.localized(&t)
-                        ));
+                        error_message
+                            .set(Some(e.localized(&t)));
                         return;
                     }
                 }
@@ -70,59 +72,55 @@ pub fn Home() -> Element {
             Ok(url) => {
                 match generate_qr_code(&url) {
                     Ok(svg) => qr_code_svg.set(Some(svg)),
-                    Err(e) => {
-                        error_message.set(Some(
-                            e.localized(&t)
-                        ))
-                    }
+                    Err(e) => error_message
+                        .set(Some(e.localized(&t))),
                 }
                 generated_url.set(Some(url));
             }
-            Err(e) => error_message.set(Some(
-                e.localized(&t)
-            )),
+            Err(e) => {
+                error_message.set(Some(e.localized(&t)))
+            }
         }
     };
 
     rsx! {
         section {
             fieldset {
 
-                label { "{t.password}" }
+                label { "{t.note}" }
                 textarea {
                     placeholder: "{t.note_placeholder}",
                     rows: "8",
                     value: "{note_text}",
                     oninput: move |evt| note_text.set(evt.value()),
                 }
 
-                br {}
+                label { "{t.mode}" }
 
                 input {
                     r#type: "radio",
-                    id: "enc_none",
-                    name: "encryption",
                     value: "none",
                     checked: encryption().is_none(),
                     onchange: move |_| encryption.set(None),
                 }
-                label { r#for: "enc_none", "{t.no_encryption}" }
+                label { "{t.no_encryption}" }
 
                 br {}
 
                 input {
                     r#type: "radio",
-                    id: "enc_symmetric",
-                    name: "encryption",
                     value: "symmetric",
                     checked: encryption().is_some(),
                     onchange: move |_| encryption.set(Some(CipherType::ChaCha20Poly1305)),
                 }
-                label { r#for: "enc_symmetric", "{t.password_encryption}" }
+                label { "{t.password_encryption}" }
 
                 if let Some(cipher) = encryption() {
 
-                    label { "{t.cipher}" }
+                    br {}
+                    br {}
+
+                    label { "{t.algorithm}" }
                     select {
                         value: match cipher {
                             CipherType::ChaCha20Poly1305 => "chacha20",

rust/cryptonote/src/views/view.rs

@@ -86,7 +86,7 @@ pub fn View() -> Element {
 
                         if let Some(enc) = encrypted_data() {
                             p {
-                                strong { "{t.cipher}: " }
+                                strong { "{t.algorithm}: " }
                                 match enc.cipher {
                                     crate::crypto::CipherType::ChaCha20Poly1305 => "ChaCha20-Poly1305",
                                     crate::crypto::CipherType::Aes256Gcm => "AES-256-GCM",