From 0469ac14f553c5867c34d9f1e9fd7c4bc8c63685 Mon Sep 17 00:00:00 2001
From: vzex <vzex@163.com>
Date: Wed, 22 Dec 2021 01:06:22 +0800
Subject: [PATCH] rename pre_is_dead to prev_dead_key

---
 src/window/keyboard_manager.rs | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/window/keyboard_manager.rs b/src/window/keyboard_manager.rs
index 81b7bcd..18ca96d 100644
--- a/src/window/keyboard_manager.rs
+++ b/src/window/keyboard_manager.rs
@@ -17,7 +17,7 @@ pub struct KeyboardManager {
     shift: bool,
     ctrl: bool,
     alt: bool,
-    pre_is_dead: Option<char>,
+    prev_dead_key: Option<char>,
     logo: bool,
     ignore_input_this_frame: bool,
     queued_input_events: Vec<InputEvent>,
@@ -29,7 +29,7 @@ impl KeyboardManager {
             shift: false,
             ctrl: false,
             alt: false,
-            pre_is_dead: None,
+            prev_dead_key: None,
             logo: false,
             ignore_input_this_frame: false,
             queued_input_events: Vec::new(),
@@ -82,14 +82,14 @@ impl KeyboardManager {
 
                 if !self.should_ignore_input(&settings) {
                     // If we have a keyboard event this frame
-                    let mut pre_is_dead = self.pre_is_dead;
+                    let mut prev_dead_key = self.prev_dead_key;
                     for input_event in self.queued_input_events.iter() {
                         match input_event {
                             InputEvent::KeyEvent(key_event) => {
                                 // And a key was pressed
                                 if key_event.state == ElementState::Pressed {
                                     if let Some(keybinding) =
-                                        self.maybe_get_keybinding(key_event, &mut pre_is_dead)
+                                        self.maybe_get_keybinding(key_event, &mut prev_dead_key)
                                     {
                                         EVENT_AGGREGATOR
                                             .send(UiCommand::Serial(SerialCommand::Keyboard(keybinding)));
@@ -97,19 +97,19 @@ impl KeyboardManager {
                                 } else if key_event.state == ElementState::Released {
                                     // dead key detect here
                                     if let Dead(dead_key) = key_event.logical_key {
-                                        pre_is_dead = dead_key; //should wait for the next input text_with_all_modifiers, and ignore the next ime.
+                                        prev_dead_key = dead_key; //should wait for the next input text_with_all_modifiers, and ignore the next ime.
                                     }
                                 }
                             }
                             InputEvent::ImeInput(raw_input) => {
-                                if pre_is_dead.is_none() {
+                                if prev_dead_key.is_none() {
                                     EVENT_AGGREGATOR
                                         .send(UiCommand::Serial(SerialCommand::Keyboard(raw_input.to_string())));
                                 }
                             }
                         }
                     }
-                    self.pre_is_dead = pre_is_dead;
+                    self.prev_dead_key = prev_dead_key;
                 }
 
                 // Regardless of whether this was a valid keyboard input or not, rest ignoring and
@@ -128,26 +128,26 @@ impl KeyboardManager {
     fn maybe_get_keybinding(
         &self,
         key_event: &KeyEvent,
-        pre_is_dead: &mut Option<char>,
+        prev_dead_key: &mut Option<char>,
     ) -> Option<String> {
         // Determine if this key event represents a key which won't ever
         // present text.
         if let Some(key_text) = is_control_key(key_event.logical_key) {
-            if pre_is_dead.is_some() {
+            if prev_dead_key.is_some() {
                 //recover dead key to normal character
-                let real_char = String::from(pre_is_dead.unwrap());
-                *pre_is_dead = None;
+                let real_char = String::from(prev_dead_key.unwrap());
+                *prev_dead_key = None;
                 Some(real_char + &self.format_keybinding_string(true, true, key_text))
             } else {
                 Some(self.format_keybinding_string(true, true, key_text))
             }
         } else {
-            let key_text = if pre_is_dead.is_none() {
+            let key_text = if prev_dead_key.is_none() {
                 key_event.text
             } else {
                 key_event.text_with_all_modifiers()
             };
-            *pre_is_dead = None;
+            *prev_dead_key = None;
             if let Some(ori_key_text) = key_text {
                 let mut key_text = ori_key_text;
                 if self.alt {