Merge lp:~3v1n0/nux/text-entry-double-deadkeys-fix into lp:nux

[Marco Trevisan (Treviño)]

TextEntry: correctly handle a "double-deadkey" pressure

Correctly reset the dead_key mode when terminated.

When a deadkey was pressed twice it worked correctly only once, since we were not handling correctly this case.
Now if we're in dead_key_mode and the user types another dead_key we check if the one that has been pressed is equal to the first one, in that case we accept it and we exit from the dead_key mode.

Added gtests.

[Brandon Schaefer (brandontschaefer)]

Looks good, and all tests pass.

review: Approve

=== modified file 'Nux/TextEntry.cpp'
--- Nux/TextEntry.cpp	2012-07-05 03:04:23 +0000
+++ Nux/TextEntry.cpp	2012-07-05 03:04:23 +0000
@@ -326,6 +326,7 @@
     if (dead_key_mode_ && keysym == XK_space)
     {
       dead_key_mode_ = false;
+      composition_mode_ = false;
       EnterText(dead_key_string_.c_str());
       QueueRefresh(false, true);
       return;
@@ -649,18 +650,21 @@
   {
 #if defined(NUX_OS_LINUX)
     /* Checks if the keysym between the first and last dead key */
-    if (character && (keysym >= XK_dead_grave) && (keysym <= XK_dead_stroke) && !dead_key_mode_)
+    if (character && (keysym >= XK_dead_grave) && (keysym <= XK_dead_stroke))
     {
       int key = keysym - XK_dead_grave;
-      dead_key_mode_ = true;
 
       if (dead_keys_map[key])
       {
         composition_mode_ = true;
-        composition_string_.clear();
-
-        dead_key_string_ = character;
-
+
+        if (!dead_key_mode_)
+        {
+          composition_string_.clear();
+          dead_key_string_ = character;
+        }
+
+        dead_key_mode_ = true;
         std::string dead_key;
         dead_key = dead_keys_map[key];
         HandledComposition(keysym, dead_key.c_str());
@@ -668,14 +672,8 @@
         return true;
       }
     }
-    else if (dead_key_mode_ && (state & IBUS_IGNORED_MASK))
-    {
-      dead_key_mode_ = false;
-    }
-    return false;
-#else
-    return false;
 #endif
+    return false;
   }
 
   bool TextEntry::HandledComposition(int keysym, const char* character)
@@ -714,11 +712,9 @@
         return true;
       }
 
+      std::string composition_match;
       composition_string_ += character;
-
-      std::string composition_match;
-
-      int match = LookForMatch(composition_match);
+      SearchState match = GetCompositionForString(composition_string_, composition_match);
 
       if (match == PARTIAL)
       {
@@ -726,6 +722,7 @@
       }
       else if (match == NO_MATCH)
       {
+        dead_key_mode_ = false;
         composition_mode_ = false;
         composition_string_.clear();
       }
@@ -733,12 +730,10 @@
       {
         EnterText(composition_match.c_str());
         composition_mode_ = false;
+        dead_key_mode_ = false;
         composition_string_.clear();
         QueueRefresh(false, true);
 
-        if (dead_key_mode_)
-          dead_key_mode_ = false;
-
         return true;
       }
     }
@@ -1299,25 +1294,34 @@
     return cached_layout_;
   }
 
-  int TextEntry::LookForMatch(std::string& str)
+  TextEntry::SearchState TextEntry::GetCompositionForString(std::string const& input, std::string& composition)
   {
-    str.clear();
-    int search_state = NO_MATCH;
-
-    // Check if the string we have is a match,partial match or doesnt match
+    composition.clear();
+    SearchState search_state = NO_MATCH;
+
+    /* If we have two dead keys concatenated, then we should just write one */
+    if (dead_key_mode_ && input.length() == 2)
+    {
+      if (input[0] == input[1])
+      {
+        composition = input[0];
+        return MATCH;
+      }
+    }
+
+    /* Check if the string we have is a match, partial match or doesn't match */
     for (int i = 0; nux_compose_seqs_compact[i] != "\0"; i++)
     {
-      if (nux_compose_seqs_compact[i].compare(composition_string_) == 0)
+      if (nux_compose_seqs_compact[i] == input)
       {
         // advance to the next sequence after ::
-        while (nux_compose_seqs_compact[++i].compare("::") != 0)
-        {
-        }
+        while (nux_compose_seqs_compact[++i] != "::")
+        {}
 
-        str = nux_compose_seqs_compact[++i];
+        composition = nux_compose_seqs_compact[++i];
         return MATCH;
       }
-      else if (nux_compose_seqs_compact[i].find(composition_string_) != std::string::npos)
+      else if (nux_compose_seqs_compact[i].find(input) == 0)
       {
         search_state = PARTIAL;
       }

=== modified file 'Nux/TextEntry.h'
--- Nux/TextEntry.h	2012-07-03 23:24:53 +0000
+++ Nux/TextEntry.h	2012-07-05 03:04:23 +0000
@@ -352,7 +352,7 @@
     void GetCursorLocationInLayout(int* strong_x, int* strong_y, int* strong_height,
                                    int* weak_x, int* weak_y, int* weak_height);
 
-    int LookForMatch(std::string& str);
+    SearchState GetCompositionForString(std::string const& input, std::string& composition);
 
     /** The CairoCanvas which hold cairo_t inside */
     CairoGraphics* canvas_;

=== modified file 'tests/gtest-nux-textentry.cpp'
--- tests/gtest-nux-textentry.cpp	2012-07-05 03:04:23 +0000
+++ tests/gtest-nux-textentry.cpp	2012-07-05 03:04:23 +0000
@@ -66,6 +66,23 @@
     return composition_mode_;
   }
 
+  bool InDeadKeyMode() const
+  {
+    return dead_key_mode_;
+  }
+
+  enum class CompositionResult
+  {
+    NO_MATCH,
+    PARTIAL,
+    MATCH
+  };
+
+  CompositionResult GetCompositionForString(std::string const& input, std::string& composition)
+  {
+    return static_cast<CompositionResult>(TextEntry::GetCompositionForString(input, composition));
+  }
+
   nux::IBusIMEContext* ime() const
   {
 #if defined(NUX_OS_LINUX)
@@ -436,5 +453,96 @@
 
   EXPECT_EQ(text_entry->GetText(), "ñ");
 }
+
+TEST_F(TestTextEntry, CompositionDeadKey)
+{
+  ASSERT_FALSE(text_entry->InCompositionMode());
+  TestEvent dead_key(XK_dead_circumflex);
+  SendEvent(dead_key);
+  EXPECT_TRUE(text_entry->InDeadKeyMode());
+  EXPECT_TRUE(text_entry->InCompositionMode());
+
+  TestEvent a(XK_a);
+  SendEvent(a);
+  EXPECT_FALSE(text_entry->InCompositionMode());
+  EXPECT_FALSE(text_entry->InDeadKeyMode());
+
+  EXPECT_EQ(text_entry->GetText(), "â");
+}
+
+TEST_F(TestTextEntry, CompositionDeadKeyRepeat)
+{
+  ASSERT_FALSE(text_entry->InCompositionMode());
+  TestEvent dead_key(XK_dead_grave);
+  SendEvent(dead_key);
+  EXPECT_TRUE(text_entry->InDeadKeyMode());
+  EXPECT_TRUE(text_entry->InCompositionMode());
+
+  SendEvent(dead_key);
+  EXPECT_FALSE(text_entry->InCompositionMode());
+  EXPECT_FALSE(text_entry->InDeadKeyMode());
+
+  EXPECT_EQ(text_entry->GetText(), "`");
+}
+
+TEST_F(TestTextEntry, CompositionDeadKeyComplex)
+{
+  ASSERT_FALSE(text_entry->InCompositionMode());
+  TestEvent dead_key(XK_dead_circumflex);
+  SendEvent(dead_key);
+  EXPECT_TRUE(text_entry->InDeadKeyMode());
+  EXPECT_TRUE(text_entry->InCompositionMode());
+
+  SendEvent(dead_key);
+  EXPECT_FALSE(text_entry->InCompositionMode());
+  EXPECT_FALSE(text_entry->InDeadKeyMode());
+  EXPECT_EQ(text_entry->GetText(), "^");
+
+  SendEvent(dead_key);
+  TestEvent o(XK_o);
+  SendEvent(o);
+  EXPECT_FALSE(text_entry->InCompositionMode());
+  EXPECT_FALSE(text_entry->InDeadKeyMode());
+
+  EXPECT_EQ(text_entry->GetText(), "^ô");
+}
+
+TEST_F(TestTextEntry, CompositionDeadKeysMix)
+{
+  ASSERT_FALSE(text_entry->InCompositionMode());
+  TestEvent dead_key1(XK_dead_grave);
+  SendEvent(dead_key1);
+  EXPECT_TRUE(text_entry->InDeadKeyMode());
+  EXPECT_TRUE(text_entry->InCompositionMode());
+
+  TestEvent dead_key2(XK_dead_circumflex);
+  SendEvent(dead_key2);
+  EXPECT_FALSE(text_entry->InCompositionMode());
+  EXPECT_FALSE(text_entry->InDeadKeyMode());
+
+  EXPECT_EQ(text_entry->GetText(), "");
+}
+
+TEST_F(TestTextEntry, CompositionResultValid)
+{
+  std::string composed;
+  auto result = text_entry->GetCompositionForString("o", composed);
+
+  EXPECT_EQ(result, MockTextEntry::CompositionResult::PARTIAL);
+  EXPECT_TRUE(composed.empty());
+
+  result = text_entry->GetCompositionForString("ox", composed);
+  EXPECT_EQ(result, MockTextEntry::CompositionResult::MATCH);
+  EXPECT_EQ(composed, "¤");
+}
+
+TEST_F(TestTextEntry, CompositionResultInValid)
+{
+  std::string composed;
+  auto result = text_entry->GetCompositionForString("nux", composed);
+
+  EXPECT_EQ(result, MockTextEntry::CompositionResult::NO_MATCH);
+  EXPECT_TRUE(composed.empty());
+}
 #endif
 }