Merge lp:~3v1n0/nux/text-entry-compose-ignore-modifiers into lp:nux

[Marco Trevisan (Treviño)]

TextEntry: ignore meta keypresses when in composition mode

When in composition mode any pressure of a modifier key (such as AltGr) should be ignored, so that it's possible to continue to compose a correct char.

Tests covered by gtest.

[Andrea Azzarone (azzar1)]

+1

review: Approve

=== modified file 'Nux/TextEntry.cpp'
--- Nux/TextEntry.cpp	2012-07-03 23:24:53 +0000
+++ Nux/TextEntry.cpp	2012-07-04 02:35:22 +0000
@@ -371,6 +371,7 @@
     unsigned int keyval = keysym;
     bool shift = (state & NUX_STATE_SHIFT);
     bool ctrl = (state & NUX_STATE_CTRL);
+    bool handled = false;
 
     // DLOG("TextEntry::key_down(%d, shift:%d ctrl:%d)", keyval, shift, ctrl);
     if (event_type == NUX_KEYDOWN)
@@ -381,6 +382,8 @@
           MoveCursor(VISUALLY, -1, shift);
         else
           MoveCursor(WORDS, -1, shift);
+
+        handled = true;
       }
       else if (keyval == NUX_VK_RIGHT)
       {
@@ -388,16 +391,20 @@
           MoveCursor(VISUALLY, 1, shift);
         else
           MoveCursor(WORDS, 1, shift);
+
+        handled = true;
       }
       else if (keyval == NUX_VK_UP)
       {
         // move cursor to start of line
         MoveCursor(DISPLAY_LINES, -1, shift);
+        handled = true;
       }
       else if (keyval == NUX_VK_DOWN)
       {
         // move cursor to end of line
         MoveCursor(DISPLAY_LINES, 1, shift);
+        handled = true;
       }
       else if (keyval == NUX_VK_HOME)
       {
@@ -405,6 +412,8 @@
           MoveCursor(DISPLAY_LINE_ENDS, -1, shift);
         else
           MoveCursor(BUFFER, -1, shift);
+
+        handled = true;
       }
       else if (keyval == NUX_VK_END)
       {
@@ -412,6 +421,8 @@
           MoveCursor(DISPLAY_LINE_ENDS, 1, shift);
         else
           MoveCursor(BUFFER, 1, shift);
+
+        handled = true;
       }
       else if (keyval == NUX_VK_PAGE_UP)
       {
@@ -419,6 +430,8 @@
           MoveCursor(PAGES, -1, shift);
         else
           MoveCursor(BUFFER, -1, shift);
+
+        handled = true;
       }
       else if (keyval == NUX_VK_PAGE_DOWN)
       {
@@ -426,23 +439,28 @@
           MoveCursor(PAGES, 1, shift);
         else
           MoveCursor(BUFFER, 1, shift);
+
+        handled = true;
       }
       else if (((keyval == NUX_VK_x) && ctrl && !shift) || ((keyval == NUX_VK_DELETE) && shift && !ctrl))
       {
         CutClipboard();
+        handled = true;
       }
       else if (((keyval == NUX_VK_c) && ctrl && (!shift)) || ((keyval == NUX_VK_INSERT) && ctrl && (!shift)))
       {
         CopyClipboard();
+        handled = true;
       }
       else if (((keyval == NUX_VK_v) && ctrl && (!shift)) || ((keyval == NUX_VK_INSERT) && shift && (!ctrl)))
       {
         PasteClipboard();
+        handled = true;
       }
       else if ((keyval == NUX_VK_a) && ctrl)
       {
         SelectAll();
-        return;
+        handled = true;
       }
       else if (keyval == NUX_VK_BACKSPACE)
       {
@@ -450,6 +468,8 @@
           BackSpace(VISUALLY);
         else
           BackSpace(WORDS);
+
+        handled = true;
       }
       else if ((keyval == NUX_VK_DELETE) && (!shift))
       {
@@ -457,10 +477,13 @@
           Delete(VISUALLY);
         else
           Delete(WORDS);
+
+        handled = true;
       }
       else if ((keyval == NUX_VK_INSERT) && (!shift) && (!ctrl))
       {
         ToggleOverwrite();
+        handled = true;
       }
 //       else
 //       {
@@ -483,7 +506,7 @@
 //       }
     }
 
-    if (character)
+    if (!handled && character)
     {
       unsigned int utf_char = g_utf8_get_char(character);
 
@@ -672,9 +695,19 @@
       return true;
     }
 
-    if (composition_mode_ && character)
+    if (composition_mode_)
     {
-      if (strncmp(character, "", 1) == 0 && keysym != NUX_VK_SHIFT)
+      /* Excluding meta keys and shifts as composition cancellation */
+      if ((keysym >= XK_Shift_L && keysym <= XK_Hyper_R) ||
+          keysym == XK_ISO_Level3_Shift)
+      {
+        return true;
+      }
+
+      if (!character)
+        return true;
+
+      if (strncmp(character, "", 1) == 0)
       {
         composition_mode_ = false;
         composition_string_.clear();

=== modified file 'tests/gtest-nux-textentry.cpp'
--- tests/gtest-nux-textentry.cpp	2012-07-03 16:32:17 +0000
+++ tests/gtest-nux-textentry.cpp	2012-07-04 02:35:22 +0000
@@ -61,6 +61,11 @@
     TextEntry::SetCursor(cursor);
   }
 
+  bool InCompositionMode() const
+  {
+    return composition_mode_;
+  }
+
   nux::IBusIMEContext* ime() const
   {
 #if defined(NUX_OS_LINUX)
@@ -70,12 +75,6 @@
 #endif
   }
 
-  void WaitEvent()
-  {
-    if (im_running())
-      Utils::WaitForTimeoutMSec(100);
-  }
-
   MOCK_METHOD0(CutClipboard, void());
   MOCK_METHOD0(CopyClipboard, void());
   MOCK_METHOD0(PasteClipboard, void());
@@ -87,22 +86,23 @@
 class TestEvent : public Event
 {
 public:
-  TestEvent(KeyModifier keymod, unsigned long keysym)
+  TestEvent(KeyModifier keymod, unsigned long keysym, EventType type = NUX_KEYDOWN)
   {
-    type = NUX_KEYDOWN;
+    Init(keysym, type);
     key_modifiers = keymod;
-#if defined(NUX_OS_LINUX)
-    x11_keysym = keysym;
-#elif defined(NUX_OS_WINDOWS)
-    win32_keysym = keysym;
-#endif
-  }
-
-  TestEvent(unsigned long keysym)
-  {
-    type = NUX_KEYDOWN;
-#if defined(NUX_OS_LINUX)
-    x11_keysym = keysym;
+  }
+
+  TestEvent(unsigned long keysym, EventType type = NUX_KEYDOWN)
+  {
+    Init(keysym, type);
+  }
+
+  void Init(unsigned long keysym, EventType etype)
+  {
+    type = etype;
+#if defined(NUX_OS_LINUX)
+    x11_keysym = keysym;
+    g_unichar_to_utf8(x11_keysym, text);
 #elif defined(NUX_OS_WINDOWS)
     win32_keysym = keysym;
 #endif
@@ -126,6 +126,18 @@
     GetWindowCompositor().SetKeyFocusArea(text_entry);
   }
 
+  void WaitEvent()
+  {
+    if (text_entry->im_running())
+      Utils::WaitForTimeoutMSec(100);
+  }
+
+  void SendEvent(Event& event)
+  {
+    GetWindowCompositor().ProcessEvent(event);
+    WaitEvent();
+  }
+
   std::unique_ptr<WindowThread> wnd_thread;
   MockTextEntry* text_entry;
 };
@@ -212,7 +224,7 @@
     unsigned int keysym = g_utf8_get_char(c.c_str());
     text_entry->DeleteText(0, std::numeric_limits<int>::max());
     text_entry->key_down.emit(NUX_KEYDOWN, keysym, 0, c.c_str(), 1);
-    text_entry->WaitEvent();
+    WaitEvent();
     EXPECT_EQ(text_entry->GetText(), "");
   }
 }
@@ -221,32 +233,28 @@
 {
   EXPECT_CALL(*text_entry, CopyClipboard());
   TestEvent event(KEY_MODIFIER_CTRL, NUX_VK_c);
-  GetWindowCompositor().ProcessEvent(event);
-  text_entry->WaitEvent();
+  SendEvent(event);
 }
 
 TEST_F(TestTextEntry, CopyCtrlIns)
 {
   EXPECT_CALL(*text_entry, CopyClipboard());
   TestEvent event(KEY_MODIFIER_CTRL, NUX_VK_INSERT);
-  GetWindowCompositor().ProcessEvent(event);
-  text_entry->WaitEvent();
+  SendEvent(event);
 }
 
 TEST_F(TestTextEntry, PasteCtrlV)
 {
   EXPECT_CALL(*text_entry, PasteClipboard());
   TestEvent event(KEY_MODIFIER_CTRL, NUX_VK_v);
-  GetWindowCompositor().ProcessEvent(event);
-  text_entry->WaitEvent();
+  SendEvent(event);
 }
 
 TEST_F(TestTextEntry, PasteShiftIns)
 {
   EXPECT_CALL(*text_entry, PasteClipboard());
   TestEvent event(KEY_MODIFIER_SHIFT, NUX_VK_INSERT);
-  GetWindowCompositor().ProcessEvent(event);
-  text_entry->WaitEvent();
+  SendEvent(event);
 }
 
 #if defined(NUX_OS_LINUX)
@@ -267,16 +275,14 @@
 {
   EXPECT_CALL(*text_entry, CutClipboard());
   TestEvent event(KEY_MODIFIER_CTRL, NUX_VK_x);
-  GetWindowCompositor().ProcessEvent(event);
-  text_entry->WaitEvent();
+  SendEvent(event);
 }
 
 TEST_F(TestTextEntry, CutShiftDel)
 {
   EXPECT_CALL(*text_entry, CutClipboard());
   TestEvent event(KEY_MODIFIER_SHIFT, NUX_VK_DELETE);
-  GetWindowCompositor().ProcessEvent(event);
-  text_entry->WaitEvent();
+  SendEvent(event);
 }
 
 TEST_F(TestTextEntry, CtrlA)
@@ -289,8 +295,7 @@
   ASSERT_EQ(start, end);
   ASSERT_EQ(start, test_str.length());
 
-  GetWindowCompositor().ProcessEvent(selectall);
-  text_entry->WaitEvent();
+  SendEvent(selectall);
   EXPECT_TRUE(text_entry->GetSelectionBounds(&start, &end));
   EXPECT_EQ(start, 0);
   EXPECT_EQ(end, test_str.length());
@@ -305,23 +310,19 @@
   ASSERT_EQ(text_entry->GetCursor(), 0);
 
   TestEvent right(NUX_VK_RIGHT);
-  GetWindowCompositor().ProcessEvent(right);
-  text_entry->WaitEvent();
+  SendEvent(right);
   EXPECT_EQ(text_entry->GetCursor(), 1);
 
   TestEvent end(NUX_VK_END);
-  GetWindowCompositor().ProcessEvent(end);
-  text_entry->WaitEvent();
+  SendEvent(end);
   EXPECT_EQ(text_entry->GetCursor(), test_str.length());
 
   TestEvent left(NUX_VK_LEFT);
-  GetWindowCompositor().ProcessEvent(left);
-  text_entry->WaitEvent();
+  SendEvent(left);
   EXPECT_EQ(text_entry->GetCursor(), 2);
 
   TestEvent home(NUX_VK_HOME);
-  GetWindowCompositor().ProcessEvent(home);
-  text_entry->WaitEvent();
+  SendEvent(home);
   EXPECT_EQ(text_entry->GetCursor(), 0);
 }
 
@@ -334,23 +335,19 @@
   ASSERT_EQ(text_entry->GetCursor(), 0);
 
   TestEvent right(KEY_MODIFIER_CTRL, NUX_VK_RIGHT);
-  GetWindowCompositor().ProcessEvent(right);
-  text_entry->WaitEvent();
+  SendEvent(right);
   EXPECT_EQ(text_entry->GetCursor(), 3);
 
   TestEvent left(KEY_MODIFIER_CTRL, NUX_VK_LEFT);
-  GetWindowCompositor().ProcessEvent(left);
-  text_entry->WaitEvent();
+  SendEvent(left);
   EXPECT_EQ(text_entry->GetCursor(), 0);
 
   TestEvent end(KEY_MODIFIER_CTRL, NUX_VK_END);
-  GetWindowCompositor().ProcessEvent(end);
-  text_entry->WaitEvent();
+  SendEvent(end);
   EXPECT_EQ(text_entry->GetCursor(), test_str.length());
 
   TestEvent home(KEY_MODIFIER_CTRL, NUX_VK_HOME);
-  GetWindowCompositor().ProcessEvent(home);
-  text_entry->WaitEvent();
+  SendEvent(home);
   EXPECT_EQ(text_entry->GetCursor(), 0);
 }
 
@@ -361,14 +358,12 @@
   text_entry->SetCursor(0);
 
   TestEvent del(NUX_VK_DELETE);
-  GetWindowCompositor().ProcessEvent(del);
-  text_entry->WaitEvent();
+  SendEvent(del);
   EXPECT_EQ(text_entry->GetText(), "ux");
 
   text_entry->SetCursor(std::string(text_entry->GetText()).length());
   TestEvent backspace(NUX_VK_BACKSPACE);
-  GetWindowCompositor().ProcessEvent(backspace);
-  text_entry->WaitEvent();
+  SendEvent(backspace);
   EXPECT_EQ(text_entry->GetText(), "u");
 }
 
@@ -379,14 +374,67 @@
   text_entry->SetCursor(0);
 
   TestEvent del(KEY_MODIFIER_CTRL, NUX_VK_DELETE);
-  GetWindowCompositor().ProcessEvent(del);
-  text_entry->WaitEvent();
+  SendEvent(del);
   EXPECT_EQ(text_entry->GetText(), " Text Entry");
 
   text_entry->SetCursor(std::string(text_entry->GetText()).length());
   TestEvent backspace(KEY_MODIFIER_CTRL, NUX_VK_BACKSPACE);
-  GetWindowCompositor().ProcessEvent(backspace);
-  text_entry->WaitEvent();
+  SendEvent(backspace);
   EXPECT_EQ(text_entry->GetText(), " Text ");
 }
+
+#if defined(NUX_OS_LINUX)
+TEST_F(TestTextEntry, CompositionStart)
+{
+  ASSERT_FALSE(text_entry->InCompositionMode());
+  TestEvent compose(XK_Multi_key);
+  SendEvent(compose);
+  EXPECT_TRUE(text_entry->InCompositionMode());
+}
+
+TEST_F(TestTextEntry, CompositionWrite)
+{
+  ASSERT_FALSE(text_entry->InCompositionMode());
+  TestEvent compose(XK_Multi_key);
+  SendEvent(compose);
+
+  TestEvent tilde(XK_asciitilde);
+  SendEvent(tilde);
+  EXPECT_TRUE(text_entry->InCompositionMode());
+
+  TestEvent n(TestEvent(XK_n));
+  SendEvent(n);
+  EXPECT_FALSE(text_entry->InCompositionMode());
+
+  EXPECT_EQ(text_entry->GetText(), "ñ");
+}
+
+TEST_F(TestTextEntry, CompositionIgnoreModifiers)
+{
+  ASSERT_FALSE(text_entry->InCompositionMode());
+  TestEvent compose(XK_Multi_key);
+  SendEvent(compose);
+
+  TestEvent tilde(XK_asciitilde);
+  SendEvent(tilde);
+  EXPECT_TRUE(text_entry->InCompositionMode());
+
+  for (auto keysym = XK_Shift_L; keysym <= XK_Hyper_R; ++keysym)
+  {
+    TestEvent modifier(keysym);
+    SendEvent(modifier);
+    EXPECT_TRUE(text_entry->InCompositionMode());
+  }
+
+  TestEvent AltGr(XK_ISO_Level3_Shift);
+  SendEvent(AltGr);
+  EXPECT_TRUE(text_entry->InCompositionMode());
+
+  TestEvent n(TestEvent(XK_n));
+  SendEvent(n);
+  EXPECT_FALSE(text_entry->InCompositionMode());
+
+  EXPECT_EQ(text_entry->GetText(), "ñ");
+}
+#endif
 }