From 8590ae083900bd92bb26f5ab9c5d6497e457d7db Mon Sep 17 00:00:00 2001
From: Arjun <arjunbalgovind@gmail.com>
Date: Mon, 20 Apr 2020 17:44:12 -0700
Subject: [PATCH 1/6] Added grid to edit keyboard

---
 .../keyboardmanager/ui/EditKeyboardWindow.cpp | 39 ++++++++++++-----
 .../ui/EditShortcutsWindow.cpp                |  8 ++--
 .../ui/SingleKeyRemapControl.cpp              | 43 +++++++++++++------
 .../ui/SingleKeyRemapControl.h                |  2 +-
 4 files changed, 64 insertions(+), 28 deletions(-)

diff --git a/src/modules/keyboardmanager/ui/EditKeyboardWindow.cpp b/src/modules/keyboardmanager/ui/EditKeyboardWindow.cpp
index 09cac2964f34..2e0ff469fa81 100644
--- a/src/modules/keyboardmanager/ui/EditKeyboardWindow.cpp
+++ b/src/modules/keyboardmanager/ui/EditKeyboardWindow.cpp
@@ -78,20 +78,22 @@ void createEditKeyboardWindow(HINSTANCE hInst, KeyboardManagerState& keyboardMan
     xamlContainer.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
 
     // Header for the window
-    Windows::UI::Xaml::Controls::StackPanel header;
-    header.Orientation(Windows::UI::Xaml::Controls::Orientation::Horizontal);
+    Windows::UI::Xaml::Controls::RelativePanel header;
+    //header.Orientation(Windows::UI::Xaml::Controls::Orientation::Horizontal);
     header.Margin({ 10, 10, 10, 30 });
-    header.Spacing(10);
+    //header.Spacing(10);
 
     // Header text
     TextBlock headerText;
     headerText.Text(winrt::to_hstring("Remap Keyboard"));
     headerText.Foreground(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::Black() });
     headerText.FontSize(30);
-    headerText.Margin({ 0, 0, 1000, 0 });
+    headerText.Margin({ 0, 0, 0, 0 });
+    header.SetAlignLeftWithPanel(headerText, true);
 
     // Header Cancel button
     Button cancelButton;
+    cancelButton.Margin({ 0, 0, 10, 0 });
     cancelButton.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
     cancelButton.Foreground(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::Black() });
     cancelButton.Content(winrt::box_value(winrt::to_hstring("Cancel")));
@@ -107,10 +109,17 @@ void createEditKeyboardWindow(HINSTANCE hInst, KeyboardManagerState& keyboardMan
     keyRemapInfoHeader.Margin({ 10, 0, 0, 10 });
 
     // Table to display the key remaps
-    Windows::UI::Xaml::Controls::StackPanel keyRemapTable;
-    keyRemapTable.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
+    Grid keyRemapTable;
+    ColumnDefinition firstColumn;
+    ColumnDefinition secondColumn;
+    ColumnDefinition thirdColumn;
     keyRemapTable.Margin({ 10, 10, 10, 20 });
-    keyRemapTable.Spacing(10);
+    keyRemapTable.HorizontalAlignment(HorizontalAlignment::Stretch);
+    keyRemapTable.ColumnSpacing(10);
+    keyRemapTable.ColumnDefinitions().Append(firstColumn);
+    keyRemapTable.ColumnDefinitions().Append(secondColumn);
+    keyRemapTable.ColumnDefinitions().Append(thirdColumn);
+    keyRemapTable.RowDefinitions().Append(RowDefinition());
 
     // Header row of the keys remap table
     Windows::UI::Xaml::Controls::StackPanel tableHeaderRow;
@@ -124,7 +133,7 @@ void createEditKeyboardWindow(HINSTANCE hInst, KeyboardManagerState& keyboardMan
     originalKeyRemapHeader.Foreground(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::Black() });
     originalKeyRemapHeader.FontWeight(Text::FontWeights::Bold());
     originalKeyRemapHeader.Margin({ 0, 0, 0, 10 });
-    tableHeaderRow.Children().Append(originalKeyRemapHeader);
+    //tableHeaderRow.Children().Append(originalKeyRemapHeader);
 
     // Second header textblock in the header row of the keys remap table
     TextBlock newKeyRemapHeader;
@@ -132,9 +141,17 @@ void createEditKeyboardWindow(HINSTANCE hInst, KeyboardManagerState& keyboardMan
     newKeyRemapHeader.Foreground(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::Black() });
     newKeyRemapHeader.FontWeight(Text::FontWeights::Bold());
     newKeyRemapHeader.Margin({ 0, 0, 0, 10 });
-    tableHeaderRow.Children().Append(newKeyRemapHeader);
+    //tableHeaderRow.Children().Append(newKeyRemapHeader);
+    ColumnDefinition primary;
+    ColumnDefinition secondary;
 
-    keyRemapTable.Children().Append(tableHeaderRow);
+    keyRemapTable.SetColumn(originalKeyRemapHeader, 0);
+    keyRemapTable.SetRow(originalKeyRemapHeader, 0);
+    keyRemapTable.SetColumn(newKeyRemapHeader, 1);
+    keyRemapTable.SetRow(newKeyRemapHeader, 0);
+
+    keyRemapTable.Children().Append(originalKeyRemapHeader);
+    keyRemapTable.Children().Append(newKeyRemapHeader);
 
     // Message to display success/failure of saving settings.
     Flyout applyFlyout;
@@ -161,6 +178,8 @@ void createEditKeyboardWindow(HINSTANCE hInst, KeyboardManagerState& keyboardMan
 
     // Main Header Apply button
     Button applyButton;
+    header.SetAlignRightWithPanel(applyButton, true);
+    header.SetLeftOf(cancelButton, applyButton);
     applyButton.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
     applyButton.Foreground(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::Black() });
     applyButton.Content(winrt::box_value(winrt::to_hstring("Apply")));
diff --git a/src/modules/keyboardmanager/ui/EditShortcutsWindow.cpp b/src/modules/keyboardmanager/ui/EditShortcutsWindow.cpp
index c30d12de49a7..6eac7ee9720c 100644
--- a/src/modules/keyboardmanager/ui/EditShortcutsWindow.cpp
+++ b/src/modules/keyboardmanager/ui/EditShortcutsWindow.cpp
@@ -79,20 +79,20 @@ void createEditShortcutsWindow(HINSTANCE hInst, KeyboardManagerState& keyboardMa
     xamlContainer.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
 
     // Header for the window
-    Windows::UI::Xaml::Controls::StackPanel header;
+    Windows::UI::Xaml::Controls::RelativePanel header;
     header.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
-    header.Orientation(Windows::UI::Xaml::Controls::Orientation::Horizontal);
     header.Margin({ 10, 10, 10, 30 });
-    header.Spacing(10);
 
     // Header text
     TextBlock headerText;
     headerText.Text(winrt::to_hstring("Edit Shortcuts"));
     headerText.FontSize(30);
     headerText.Margin({ 0, 0, 100, 0 });
+    header.SetAlignLeftWithPanel(headerText, true);
 
     // Cancel button
     Button cancelButton;
+    cancelButton.Margin({ 0, 0, 10, 0 });
     cancelButton.Content(winrt::box_value(winrt::to_hstring("Cancel")));
     cancelButton.Click([&](winrt::Windows::Foundation::IInspectable const& sender, RoutedEventArgs const&) {
         // Close the window since settings do not need to be saved
@@ -152,6 +152,8 @@ void createEditShortcutsWindow(HINSTANCE hInst, KeyboardManagerState& keyboardMa
 
     // Apply button
     Button applyButton;
+    header.SetAlignRightWithPanel(applyButton, true);
+    header.SetLeftOf(cancelButton, applyButton);
     applyButton.Content(winrt::box_value(winrt::to_hstring("Apply")));
     applyButton.Flyout(applyFlyout);
     applyButton.Click([&](winrt::Windows::Foundation::IInspectable const& sender, RoutedEventArgs const&) {
diff --git a/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp b/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
index 265fd819e87b..f25e290ef039 100644
--- a/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
+++ b/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
@@ -8,23 +8,31 @@ KeyboardManagerState* SingleKeyRemapControl::keyboardManagerState = nullptr;
 std::vector<std::vector<DWORD>> SingleKeyRemapControl::singleKeyRemapBuffer;
 
 // Function to add a new row to the remap keys table. If the originalKey and newKey args are provided, then the displayed remap keys are set to those values.
-void SingleKeyRemapControl::AddNewControlKeyRemapRow(StackPanel& parent, std::vector<std::vector<std::unique_ptr<SingleKeyRemapControl>>>& keyboardRemapControlObjects, const DWORD originalKey, const DWORD newKey)
+void SingleKeyRemapControl::AddNewControlKeyRemapRow(Grid& parent, std::vector<std::vector<std::unique_ptr<SingleKeyRemapControl>>>& keyboardRemapControlObjects, const DWORD originalKey, const DWORD newKey)
 {
     // Parent element for the row
-    Windows::UI::Xaml::Controls::StackPanel tableRow;
-    tableRow.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
-    tableRow.Spacing(100);
-    tableRow.Orientation(Windows::UI::Xaml::Controls::Orientation::Horizontal);
+    //Windows::UI::Xaml::Controls::StackPanel tableRow;
+    //tableRow.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
+    //tableRow.Spacing(100);
+    //tableRow.Orientation(Windows::UI::Xaml::Controls::Orientation::Horizontal);
 
     // Create new SingleKeyRemapControl objects dynamically so that we does not get destructed
     std::vector<std::unique_ptr<SingleKeyRemapControl>> newrow;
     newrow.push_back(std::move(std::unique_ptr<SingleKeyRemapControl>(new SingleKeyRemapControl(singleKeyRemapBuffer.size(), 0))));
     newrow.push_back(std::move(std::unique_ptr<SingleKeyRemapControl>(new SingleKeyRemapControl(singleKeyRemapBuffer.size(), 1))));
     keyboardRemapControlObjects.push_back(std::move(newrow));
+
+    // Add to grid
+    int debug = parent.RowDefinitions().Size();
+    parent.RowDefinitions().Append(RowDefinition());
+    parent.SetColumn(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][0]->getSingleKeyRemapControl(), 0);
+    parent.SetRow(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][0]->getSingleKeyRemapControl(), parent.RowDefinitions().Size() - 1);
+    parent.SetColumn(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][1]->getSingleKeyRemapControl(), 1);
+    parent.SetRow(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][1]->getSingleKeyRemapControl(), parent.RowDefinitions().Size() - 1);
     // SingleKeyRemapControl for the original key.
-    tableRow.Children().Append(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][0]->getSingleKeyRemapControl());
+    parent.Children().Append(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][0]->getSingleKeyRemapControl());
     // SingleKeyRemapControl for the new remap key
-    tableRow.Children().Append(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][1]->getSingleKeyRemapControl());
+    parent.Children().Append(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][1]->getSingleKeyRemapControl());
 
     // Set the key text if the two keys are not null (i.e. default args)
     if (originalKey != NULL && newKey != NULL)
@@ -57,17 +65,24 @@ void SingleKeyRemapControl::AddNewControlKeyRemapRow(StackPanel& parent, std::ve
     deleteSymbol.Glyph(L"\xE74D");
     deleteRemapKeys.Content(deleteSymbol);
     deleteRemapKeys.Click([&](winrt::Windows::Foundation::IInspectable const& sender, RoutedEventArgs const&) {
-        StackPanel currentRow = sender.as<Button>().Parent().as<StackPanel>();
+        Button currentButton = sender.as<Button>();
         uint32_t index;
-        parent.Children().IndexOf(currentRow, index);
+        // Get index of delete button
+        parent.Children().IndexOf(currentButton, index);
         parent.Children().RemoveAt(index);
-        // delete the row from the buffer. Since first child of the stackpanel is the header, the effective index starts from 1
-        singleKeyRemapBuffer.erase(singleKeyRemapBuffer.begin() + (index - 1));
+        parent.Children().RemoveAt(index - 1);
+        parent.Children().RemoveAt(index - 2);
+
+        // Calculate row index in the buffer from the grid child index (first two children are header elements and then three children in each row)
+        int bufferIndex = int(index / 3) - 1;
+        // delete the row from the buffer. 
+        singleKeyRemapBuffer.erase(singleKeyRemapBuffer.begin() + bufferIndex);
         // delete the SingleKeyRemapControl objects so that they get destructed
-        keyboardRemapControlObjects.erase(keyboardRemapControlObjects.begin() + (index - 1));
+        keyboardRemapControlObjects.erase(keyboardRemapControlObjects.begin() + bufferIndex);
     });
-    tableRow.Children().Append(deleteRemapKeys);
-    parent.Children().Append(tableRow);
+    parent.SetColumn(deleteRemapKeys, 2);
+    parent.SetRow(deleteRemapKeys, parent.RowDefinitions().Size() - 1);
+    parent.Children().Append(deleteRemapKeys);
 }
 
 // Function to return the stack panel element of the SingleKeyRemapControl. This is the externally visible UI element which can be used to add it to other layouts
diff --git a/src/modules/keyboardmanager/ui/SingleKeyRemapControl.h b/src/modules/keyboardmanager/ui/SingleKeyRemapControl.h
index 4e8d7f064377..478012af0e43 100644
--- a/src/modules/keyboardmanager/ui/SingleKeyRemapControl.h
+++ b/src/modules/keyboardmanager/ui/SingleKeyRemapControl.h
@@ -44,7 +44,7 @@ class SingleKeyRemapControl
     }
 
     // Function to add a new row to the remap keys table. If the originalKey and newKey args are provided, then the displayed remap keys are set to those values.
-    static void AddNewControlKeyRemapRow(StackPanel& parent, std::vector<std::vector<std::unique_ptr<SingleKeyRemapControl>>>& keyboardRemapControlObjects, const DWORD originalKey = NULL, const DWORD newKey = NULL);
+    static void AddNewControlKeyRemapRow(Grid& parent, std::vector<std::vector<std::unique_ptr<SingleKeyRemapControl>>>& keyboardRemapControlObjects, const DWORD originalKey = NULL, const DWORD newKey = NULL);
 
     // Function to return the stack panel element of the SingleKeyRemapControl. This is the externally visible UI element which can be used to add it to other layouts
     StackPanel getSingleKeyRemapControl();

From 7d1a4990df45f1ad3226d7fab5688ef0f7416aaf Mon Sep 17 00:00:00 2001
From: Arjun <arjunbalgovind@gmail.com>
Date: Mon, 20 Apr 2020 19:08:04 -0700
Subject: [PATCH 2/6] Fixed all issues for Edit keyboard window with grid

---
 .../keyboardmanager/ui/KeyDropDownControl.h   | 45 ++++++++++++-------
 .../ui/SingleKeyRemapControl.cpp              | 12 +++--
 .../ui/SingleKeyRemapControl.h                | 12 ++---
 3 files changed, 40 insertions(+), 29 deletions(-)

diff --git a/src/modules/keyboardmanager/ui/KeyDropDownControl.h b/src/modules/keyboardmanager/ui/KeyDropDownControl.h
index 3c98dd602d9b..41da7fb603f6 100644
--- a/src/modules/keyboardmanager/ui/KeyDropDownControl.h
+++ b/src/modules/keyboardmanager/ui/KeyDropDownControl.h
@@ -23,24 +23,9 @@ class KeyDropDownControl
     static KeyboardManagerState* keyboardManagerState;
 
     // Constructor for single key drop down
-    KeyDropDownControl(size_t rowIndex, size_t colIndex, std::vector<std::vector<DWORD>>& singleKeyRemapBuffer)
+    KeyDropDownControl(bool isShortcut)
     {
-        SetDefaultProperties(false);
-        dropDown.SelectionChanged([&, rowIndex, colIndex](winrt::Windows::Foundation::IInspectable const& sender, SelectionChangedEventArgs const& args) {
-            ComboBox currentDropDown = sender.as<ComboBox>();
-            int selectedKeyIndex = currentDropDown.SelectedIndex();
-
-            // Check if the element was not found or the index exceeds the known keys
-            if (selectedKeyIndex != -1 && keyCodeList.size() > selectedKeyIndex)
-            {
-                singleKeyRemapBuffer[rowIndex][colIndex] = keyCodeList[selectedKeyIndex];
-            }
-            else
-            {
-                // Reset to null if the key is not found
-                singleKeyRemapBuffer[rowIndex][colIndex] = NULL;
-            }
-        });
+        SetDefaultProperties(isShortcut);
     }
 
     // Constructor for shortcut drop down
@@ -170,6 +155,32 @@ class KeyDropDownControl
         });
     }
 
+    // Function to set selection handler for single key remap drop down. Needs to be called after the constructor since the singleKeyControl StackPanel is null if called in the constructor
+    void SetSelectionHandler(Grid& table, StackPanel& singleKeyControl, size_t colIndex, std::vector<std::vector<DWORD>>& singleKeyRemapBuffer)
+    {
+        dropDown.SelectionChanged([&, table, singleKeyControl, colIndex](winrt::Windows::Foundation::IInspectable const& sender, SelectionChangedEventArgs const& args) {
+            ComboBox currentDropDown = sender.as<ComboBox>();
+            int selectedKeyIndex = currentDropDown.SelectedIndex();
+            // Get row index of the single key control
+            uint32_t controlIndex;
+            bool indexFound = table.Children().IndexOf(singleKeyControl, controlIndex);
+            if (indexFound)
+            {
+                int rowIndex = (controlIndex - 2) / 3;
+                // Check if the element was not found or the index exceeds the known keys
+                if (selectedKeyIndex != -1 && keyCodeList.size() > selectedKeyIndex)
+                {
+                    singleKeyRemapBuffer[rowIndex][colIndex] = keyCodeList[selectedKeyIndex];
+                }
+                else
+                {
+                    // Reset to null if the key is not found
+                    singleKeyRemapBuffer[rowIndex][colIndex] = NULL;
+                }
+            }
+        });
+    }
+
     // Function to set the selected index of the drop down
     void SetSelectedIndex(int32_t index);
 
diff --git a/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp b/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
index f25e290ef039..d7828fd6ea3f 100644
--- a/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
+++ b/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
@@ -18,8 +18,8 @@ void SingleKeyRemapControl::AddNewControlKeyRemapRow(Grid& parent, std::vector<s
 
     // Create new SingleKeyRemapControl objects dynamically so that we does not get destructed
     std::vector<std::unique_ptr<SingleKeyRemapControl>> newrow;
-    newrow.push_back(std::move(std::unique_ptr<SingleKeyRemapControl>(new SingleKeyRemapControl(singleKeyRemapBuffer.size(), 0))));
-    newrow.push_back(std::move(std::unique_ptr<SingleKeyRemapControl>(new SingleKeyRemapControl(singleKeyRemapBuffer.size(), 1))));
+    newrow.push_back(std::move(std::unique_ptr<SingleKeyRemapControl>(new SingleKeyRemapControl(parent, 0))));
+    newrow.push_back(std::move(std::unique_ptr<SingleKeyRemapControl>(new SingleKeyRemapControl(parent, 1))));
     keyboardRemapControlObjects.push_back(std::move(newrow));
 
     // Add to grid
@@ -74,7 +74,7 @@ void SingleKeyRemapControl::AddNewControlKeyRemapRow(Grid& parent, std::vector<s
         parent.Children().RemoveAt(index - 2);
 
         // Calculate row index in the buffer from the grid child index (first two children are header elements and then three children in each row)
-        int bufferIndex = int(index / 3) - 1;
+        int bufferIndex = (index - 2) / 3;
         // delete the row from the buffer. 
         singleKeyRemapBuffer.erase(singleKeyRemapBuffer.begin() + bufferIndex);
         // delete the SingleKeyRemapControl objects so that they get destructed
@@ -92,7 +92,7 @@ StackPanel SingleKeyRemapControl::getSingleKeyRemapControl()
 }
 
 // Function to create the detect remap key UI window
-void SingleKeyRemapControl::createDetectKeyWindow(winrt::Windows::Foundation::IInspectable const& sender, XamlRoot xamlRoot, std::vector<std::vector<DWORD>>& singleKeyRemapBuffer, KeyboardManagerState& keyboardManagerState, const size_t rowIndex, const size_t colIndex)
+void SingleKeyRemapControl::createDetectKeyWindow(winrt::Windows::Foundation::IInspectable const& sender, XamlRoot xamlRoot, std::vector<std::vector<DWORD>>& singleKeyRemapBuffer, KeyboardManagerState& keyboardManagerState)
 {
     // ContentDialog for detecting remap key. This is the parent UI element.
     ContentDialog detectRemapKeyBox;
@@ -119,9 +119,7 @@ void SingleKeyRemapControl::createDetectKeyWindow(winrt::Windows::Foundation::II
                      detectRemapKeyBox,
                      &keyboardManagerState,
                      &singleKeyRemapBuffer,
-                     unregisterKeys,
-                     rowIndex,
-                     colIndex] {
+                     unregisterKeys] {
         // Save the detected key in the linked text block
         DWORD detectedKey = keyboardManagerState.GetDetectedSingleRemapKey();
 
diff --git a/src/modules/keyboardmanager/ui/SingleKeyRemapControl.h b/src/modules/keyboardmanager/ui/SingleKeyRemapControl.h
index 478012af0e43..bfdf18027ba1 100644
--- a/src/modules/keyboardmanager/ui/SingleKeyRemapControl.h
+++ b/src/modules/keyboardmanager/ui/SingleKeyRemapControl.h
@@ -22,16 +22,16 @@ class SingleKeyRemapControl
     // Stores the current list of remappings
     static std::vector<std::vector<DWORD>> singleKeyRemapBuffer;
 
-    SingleKeyRemapControl(const size_t rowIndex, const size_t colIndex) :
-        singleKeyRemapDropDown(rowIndex, colIndex, singleKeyRemapBuffer)
+    SingleKeyRemapControl(Grid table, const size_t colIndex) :
+        singleKeyRemapDropDown(false)
     {
         typeKey.Content(winrt::box_value(winrt::to_hstring("Type Key")));
         typeKey.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
         typeKey.Foreground(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::Black() });
-        typeKey.Click([&, rowIndex, colIndex](winrt::Windows::Foundation::IInspectable const& sender, RoutedEventArgs const&) {
+        typeKey.Click([&](winrt::Windows::Foundation::IInspectable const& sender, RoutedEventArgs const&) {
             keyboardManagerState->SetUIState(KeyboardManagerUIState::DetectSingleKeyRemapWindowActivated, EditKeyboardWindowHandle);
             // Using the XamlRoot of the typeKey to get the root of the XAML host
-            createDetectKeyWindow(sender, sender.as<Button>().XamlRoot(), singleKeyRemapBuffer, *keyboardManagerState, rowIndex, colIndex);
+            createDetectKeyWindow(sender, sender.as<Button>().XamlRoot(), singleKeyRemapBuffer, *keyboardManagerState);
         });
 
         singleKeyRemapControlLayout.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
@@ -40,6 +40,8 @@ class SingleKeyRemapControl
 
         singleKeyRemapControlLayout.Children().Append(typeKey);
         singleKeyRemapControlLayout.Children().Append(singleKeyRemapDropDown.GetComboBox());
+        // Set selection handler for the drop down
+        singleKeyRemapDropDown.SetSelectionHandler(table, singleKeyRemapControlLayout, colIndex, singleKeyRemapBuffer);
         singleKeyRemapControlLayout.UpdateLayout();
     }
 
@@ -50,5 +52,5 @@ class SingleKeyRemapControl
     StackPanel getSingleKeyRemapControl();
 
     // Function to create the detect remap keys UI window
-    void createDetectKeyWindow(winrt::Windows::Foundation::IInspectable const& sender, XamlRoot xamlRoot, std::vector<std::vector<DWORD>>& singleKeyRemapBuffer, KeyboardManagerState& keyboardManagerState, const size_t rowIndex, const size_t colIndex);
+    void createDetectKeyWindow(winrt::Windows::Foundation::IInspectable const& sender, XamlRoot xamlRoot, std::vector<std::vector<DWORD>>& singleKeyRemapBuffer, KeyboardManagerState& keyboardManagerState);
 };

From 54333f94dad4b296644a6f7003ecf672b540b6ae Mon Sep 17 00:00:00 2001
From: Arjun <arjunbalgovind@gmail.com>
Date: Tue, 21 Apr 2020 08:53:46 -0700
Subject: [PATCH 3/6] Added step to delete row definition and move row indices

---
 .../keyboardmanager/ui/SingleKeyRemapControl.cpp    | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp b/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
index d7828fd6ea3f..ae0a4ef832fa 100644
--- a/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
+++ b/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
@@ -68,14 +68,23 @@ void SingleKeyRemapControl::AddNewControlKeyRemapRow(Grid& parent, std::vector<s
         Button currentButton = sender.as<Button>();
         uint32_t index;
         // Get index of delete button
-        parent.Children().IndexOf(currentButton, index);
+        UIElementCollection children = parent.Children();
+        children.IndexOf(currentButton, index);
+        // Change the row index of elements appearing after the current row, as we will delete the row definition
+        for (int i = index + 1; i < children.Size(); i++)
+        {
+            int32_t elementRowIndex = parent.GetRow(children.GetAt(i).as<FrameworkElement>());
+            parent.SetRow(children.GetAt(i).as<FrameworkElement>(), elementRowIndex - 1);
+        }
         parent.Children().RemoveAt(index);
         parent.Children().RemoveAt(index - 1);
         parent.Children().RemoveAt(index - 2);
 
         // Calculate row index in the buffer from the grid child index (first two children are header elements and then three children in each row)
         int bufferIndex = (index - 2) / 3;
-        // delete the row from the buffer. 
+        // Delete the row definition
+        parent.RowDefinitions().RemoveAt(bufferIndex + 1);
+        // delete the row from the buffer.
         singleKeyRemapBuffer.erase(singleKeyRemapBuffer.begin() + bufferIndex);
         // delete the SingleKeyRemapControl objects so that they get destructed
         keyboardRemapControlObjects.erase(keyboardRemapControlObjects.begin() + bufferIndex);

From 5918a40f72f15c87f6ab96c6a340bf4bd82ed78f Mon Sep 17 00:00:00 2001
From: Arjun <arjunbalgovind@gmail.com>
Date: Tue, 21 Apr 2020 09:26:06 -0700
Subject: [PATCH 4/6] Handled grid operations for Edit Shortcuts

---
 .../keyboardmanager/ui/EditKeyboardWindow.cpp | 12 -----
 .../ui/EditShortcutsWindow.cpp                | 29 ++++++-----
 .../keyboardmanager/ui/ShortcutControl.cpp    | 49 ++++++++++++-------
 .../keyboardmanager/ui/ShortcutControl.h      |  2 +-
 4 files changed, 50 insertions(+), 42 deletions(-)

diff --git a/src/modules/keyboardmanager/ui/EditKeyboardWindow.cpp b/src/modules/keyboardmanager/ui/EditKeyboardWindow.cpp
index 2e0ff469fa81..a5288f1a3e70 100644
--- a/src/modules/keyboardmanager/ui/EditKeyboardWindow.cpp
+++ b/src/modules/keyboardmanager/ui/EditKeyboardWindow.cpp
@@ -79,9 +79,7 @@ void createEditKeyboardWindow(HINSTANCE hInst, KeyboardManagerState& keyboardMan
 
     // Header for the window
     Windows::UI::Xaml::Controls::RelativePanel header;
-    //header.Orientation(Windows::UI::Xaml::Controls::Orientation::Horizontal);
     header.Margin({ 10, 10, 10, 30 });
-    //header.Spacing(10);
 
     // Header text
     TextBlock headerText;
@@ -121,19 +119,12 @@ void createEditKeyboardWindow(HINSTANCE hInst, KeyboardManagerState& keyboardMan
     keyRemapTable.ColumnDefinitions().Append(thirdColumn);
     keyRemapTable.RowDefinitions().Append(RowDefinition());
 
-    // Header row of the keys remap table
-    Windows::UI::Xaml::Controls::StackPanel tableHeaderRow;
-    tableHeaderRow.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
-    tableHeaderRow.Spacing(100);
-    tableHeaderRow.Orientation(Windows::UI::Xaml::Controls::Orientation::Horizontal);
-
     // First header textblock in the header row of the keys remap table
     TextBlock originalKeyRemapHeader;
     originalKeyRemapHeader.Text(winrt::to_hstring("Original Key:"));
     originalKeyRemapHeader.Foreground(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::Black() });
     originalKeyRemapHeader.FontWeight(Text::FontWeights::Bold());
     originalKeyRemapHeader.Margin({ 0, 0, 0, 10 });
-    //tableHeaderRow.Children().Append(originalKeyRemapHeader);
 
     // Second header textblock in the header row of the keys remap table
     TextBlock newKeyRemapHeader;
@@ -141,9 +132,6 @@ void createEditKeyboardWindow(HINSTANCE hInst, KeyboardManagerState& keyboardMan
     newKeyRemapHeader.Foreground(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::Black() });
     newKeyRemapHeader.FontWeight(Text::FontWeights::Bold());
     newKeyRemapHeader.Margin({ 0, 0, 0, 10 });
-    //tableHeaderRow.Children().Append(newKeyRemapHeader);
-    ColumnDefinition primary;
-    ColumnDefinition secondary;
 
     keyRemapTable.SetColumn(originalKeyRemapHeader, 0);
     keyRemapTable.SetRow(originalKeyRemapHeader, 0);
diff --git a/src/modules/keyboardmanager/ui/EditShortcutsWindow.cpp b/src/modules/keyboardmanager/ui/EditShortcutsWindow.cpp
index 6eac7ee9720c..94913664b856 100644
--- a/src/modules/keyboardmanager/ui/EditShortcutsWindow.cpp
+++ b/src/modules/keyboardmanager/ui/EditShortcutsWindow.cpp
@@ -100,32 +100,37 @@ void createEditShortcutsWindow(HINSTANCE hInst, KeyboardManagerState& keyboardMa
     });
 
     // Table to display the shortcuts
-    Windows::UI::Xaml::Controls::StackPanel shortcutTable;
-    shortcutTable.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
+    Windows::UI::Xaml::Controls::Grid shortcutTable;
+    ColumnDefinition firstColumn;
+    ColumnDefinition secondColumn;
+    ColumnDefinition thirdColumn;
     shortcutTable.Margin({ 10, 10, 10, 20 });
-    shortcutTable.Spacing(10);
-
-    // Header row of the shortcut table
-    Windows::UI::Xaml::Controls::StackPanel tableHeaderRow;
-    tableHeaderRow.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
-    tableHeaderRow.Spacing(100);
-    tableHeaderRow.Orientation(Windows::UI::Xaml::Controls::Orientation::Horizontal);
+    shortcutTable.HorizontalAlignment(HorizontalAlignment::Stretch);
+    shortcutTable.ColumnSpacing(10);
+    shortcutTable.ColumnDefinitions().Append(firstColumn);
+    shortcutTable.ColumnDefinitions().Append(secondColumn);
+    shortcutTable.ColumnDefinitions().Append(thirdColumn);
+    shortcutTable.RowDefinitions().Append(RowDefinition());
 
     // First header textblock in the header row of the shortcut table
     TextBlock originalShortcutHeader;
     originalShortcutHeader.Text(winrt::to_hstring("Original Shortcut:"));
     originalShortcutHeader.FontWeight(Text::FontWeights::Bold());
     originalShortcutHeader.Margin({ 0, 0, 0, 10 });
-    tableHeaderRow.Children().Append(originalShortcutHeader);
 
     // Second header textblock in the header row of the shortcut table
     TextBlock newShortcutHeader;
     newShortcutHeader.Text(winrt::to_hstring("New Shortcut:"));
     newShortcutHeader.FontWeight(Text::FontWeights::Bold());
     newShortcutHeader.Margin({ 0, 0, 0, 10 });
-    tableHeaderRow.Children().Append(newShortcutHeader);
 
-    shortcutTable.Children().Append(tableHeaderRow);
+    shortcutTable.SetColumn(originalShortcutHeader, 0);
+    shortcutTable.SetRow(newShortcutHeader, 0);
+    shortcutTable.SetColumn(originalShortcutHeader, 1);
+    shortcutTable.SetRow(newShortcutHeader, 0);
+
+    shortcutTable.Children().Append(originalShortcutHeader);
+    shortcutTable.Children().Append(newShortcutHeader);
 
     // Message to display success/failure of saving settings.
     Flyout applyFlyout;
diff --git a/src/modules/keyboardmanager/ui/ShortcutControl.cpp b/src/modules/keyboardmanager/ui/ShortcutControl.cpp
index 2bb2d7eeca4f..910fb5286808 100644
--- a/src/modules/keyboardmanager/ui/ShortcutControl.cpp
+++ b/src/modules/keyboardmanager/ui/ShortcutControl.cpp
@@ -9,23 +9,24 @@ KeyboardManagerState* ShortcutControl::keyboardManagerState = nullptr;
 std::vector<std::vector<Shortcut>> ShortcutControl::shortcutRemapBuffer;
 
 // Function to add a new row to the shortcut table. If the originalKeys and newKeys args are provided, then the displayed shortcuts are set to those values.
-void ShortcutControl::AddNewShortcutControlRow(StackPanel& parent, std::vector<std::vector<std::unique_ptr<ShortcutControl>>>& keyboardRemapControlObjects, Shortcut originalKeys, Shortcut newKeys)
+void ShortcutControl::AddNewShortcutControlRow(Grid& parent, std::vector<std::vector<std::unique_ptr<ShortcutControl>>>& keyboardRemapControlObjects, Shortcut originalKeys, Shortcut newKeys)
 {
-    // Parent element for the row
-    Windows::UI::Xaml::Controls::StackPanel tableRow;
-    tableRow.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
-    tableRow.Spacing(100);
-    tableRow.Orientation(Windows::UI::Xaml::Controls::Orientation::Horizontal);
-
     // Create new ShortcutControl objects dynamically so that we does not get destructed
     std::vector<std::unique_ptr<ShortcutControl>> newrow;
     newrow.push_back(std::move(std::unique_ptr<ShortcutControl>(new ShortcutControl(shortcutRemapBuffer.size(), 0))));
     newrow.push_back(std::move(std::unique_ptr<ShortcutControl>(new ShortcutControl(shortcutRemapBuffer.size(), 1))));
     keyboardRemapControlObjects.push_back(std::move(newrow));
+
+    // Add to grid
+    parent.RowDefinitions().Append(RowDefinition());
+    parent.SetColumn(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][0]->getShortcutControl(), 0);
+    parent.SetRow(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][0]->getShortcutControl(), parent.RowDefinitions().Size() - 1);
+    parent.SetColumn(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][1]->getShortcutControl(), 1);
+    parent.SetRow(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][1]->getShortcutControl(), parent.RowDefinitions().Size() - 1);
     // ShortcutControl for the original shortcut
-    tableRow.Children().Append(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][0]->getShortcutControl());
+    parent.Children().Append(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][0]->getShortcutControl());
     // ShortcutControl for the new shortcut
-    tableRow.Children().Append(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][1]->getShortcutControl());
+    parent.Children().Append(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][1]->getShortcutControl());
 
     
     // Delete row button
@@ -35,18 +36,32 @@ void ShortcutControl::AddNewShortcutControlRow(StackPanel& parent, std::vector<s
     deleteSymbol.Glyph(L"\xE74D");
     deleteShortcut.Content(deleteSymbol);
     deleteShortcut.Click([&](winrt::Windows::Foundation::IInspectable const& sender, RoutedEventArgs const&) {
-        StackPanel currentRow = sender.as<Button>().Parent().as<StackPanel>();
+        Button currentButton = sender.as<Button>();
         uint32_t index;
-        parent.Children().IndexOf(currentRow, index);
+        // Get index of delete button
+        UIElementCollection children = parent.Children();
+        children.IndexOf(currentButton, index);
+        // Change the row index of elements appearing after the current row, as we will delete the row definition
+        for (int i = index + 1; i < children.Size(); i++)
+        {
+            int32_t elementRowIndex = parent.GetRow(children.GetAt(i).as<FrameworkElement>());
+            parent.SetRow(children.GetAt(i).as<FrameworkElement>(), elementRowIndex - 1);
+        }
         parent.Children().RemoveAt(index);
-        // delete the row from the buffer. Since first child of the stackpanel is the header, the effective index starts from 1
-        shortcutRemapBuffer.erase(shortcutRemapBuffer.begin() + (index - 1));
+        parent.Children().RemoveAt(index - 1);
+        parent.Children().RemoveAt(index - 2);
+
+        // Calculate row index in the buffer from the grid child index (first two children are header elements and then three children in each row)
+        int bufferIndex = (index - 2) / 3;
+        // Delete the row definition
+        parent.RowDefinitions().RemoveAt(bufferIndex + 1);
+        // delete the row from the buffer
+        shortcutRemapBuffer.erase(shortcutRemapBuffer.begin() + bufferIndex);
         // delete the ShortcutControl objects so that they get destructed
-        keyboardRemapControlObjects.erase(keyboardRemapControlObjects.begin() + (index - 1));
+        keyboardRemapControlObjects.erase(keyboardRemapControlObjects.begin() + bufferIndex);
     });
-    tableRow.Children().Append(deleteShortcut);
-    tableRow.UpdateLayout();
-    parent.Children().Append(tableRow);
+    parent.SetColumn(deleteShortcut, 2);
+    parent.SetRow(deleteShortcut, parent.RowDefinitions().Size() - 1);
     parent.UpdateLayout();
 
     // Set the shortcut text if the two vectors are not empty (i.e. default args)
diff --git a/src/modules/keyboardmanager/ui/ShortcutControl.h b/src/modules/keyboardmanager/ui/ShortcutControl.h
index 246bac190172..13c389ec18c5 100644
--- a/src/modules/keyboardmanager/ui/ShortcutControl.h
+++ b/src/modules/keyboardmanager/ui/ShortcutControl.h
@@ -53,7 +53,7 @@ class ShortcutControl
     }
 
     // Function to add a new row to the shortcut table. If the originalKeys and newKeys args are provided, then the displayed shortcuts are set to those values.
-    static void AddNewShortcutControlRow(StackPanel& parent, std::vector<std::vector<std::unique_ptr<ShortcutControl>>>& keyboardRemapControlObjects, Shortcut originalKeys = Shortcut(), Shortcut newKeys = Shortcut());
+    static void AddNewShortcutControlRow(Grid& parent, std::vector<std::vector<std::unique_ptr<ShortcutControl>>>& keyboardRemapControlObjects, Shortcut originalKeys = Shortcut(), Shortcut newKeys = Shortcut());
 
     // Function to add a shortcut to the shortcut control as combo boxes
     void AddShortcutToControl(Shortcut& shortcut, StackPanel parent, KeyboardManagerState& keyboardManagerState, const size_t rowIndex, const size_t colIndex);

From cf9c5d3d1d7d9c2372a0a40fa3c3f784c514b273 Mon Sep 17 00:00:00 2001
From: Arjun <arjunbalgovind@gmail.com>
Date: Tue, 21 Apr 2020 12:21:59 -0700
Subject: [PATCH 5/6] Added dynamic layout for edit shortcuts

---
 .../keyboardmanager/ui/KeyDropDownControl.cpp |   5 +-
 .../keyboardmanager/ui/KeyDropDownControl.h   | 178 +++++++++---------
 .../keyboardmanager/ui/ShortcutControl.cpp    |  23 ++-
 .../keyboardmanager/ui/ShortcutControl.h      |  12 +-
 .../ui/SingleKeyRemapControl.cpp              |   6 -
 5 files changed, 112 insertions(+), 112 deletions(-)

diff --git a/src/modules/keyboardmanager/ui/KeyDropDownControl.cpp b/src/modules/keyboardmanager/ui/KeyDropDownControl.cpp
index fca34d3db3b6..d322f97a32c4 100644
--- a/src/modules/keyboardmanager/ui/KeyDropDownControl.cpp
+++ b/src/modules/keyboardmanager/ui/KeyDropDownControl.cpp
@@ -48,14 +48,15 @@ ComboBox KeyDropDownControl::GetComboBox()
 }
 
 // Function to add a drop down to the shortcut stack panel
-void KeyDropDownControl::AddDropDown(StackPanel parent, const size_t rowIndex, const size_t colIndex, std::vector<std::vector<Shortcut>>& shortcutRemapBuffer, std::vector<std::unique_ptr<KeyDropDownControl>>& keyDropDownControlObjects)
+void KeyDropDownControl::AddDropDown(Grid table, StackPanel shortcutControl, StackPanel parent, const size_t colIndex, std::vector<std::vector<Shortcut>>& shortcutRemapBuffer, std::vector<std::unique_ptr<KeyDropDownControl>>& keyDropDownControlObjects)
 {
-    keyDropDownControlObjects.push_back(std::move(std::unique_ptr<KeyDropDownControl>(new KeyDropDownControl(rowIndex, colIndex, shortcutRemapBuffer, keyDropDownControlObjects, parent))));
+    keyDropDownControlObjects.push_back(std::move(std::unique_ptr<KeyDropDownControl>(new KeyDropDownControl(true))));
     // Flyout to display the warning on the drop down element
     Flyout warningFlyout;
     TextBlock warningMessage;
     warningFlyout.Content(warningMessage);
     parent.Children().Append(keyDropDownControlObjects[keyDropDownControlObjects.size() - 1]->GetComboBox());
+    keyDropDownControlObjects[keyDropDownControlObjects.size() - 1]->SetSelectionHandler(table, shortcutControl, parent, colIndex, shortcutRemapBuffer, keyDropDownControlObjects);
     parent.UpdateLayout();
 }
 
diff --git a/src/modules/keyboardmanager/ui/KeyDropDownControl.h b/src/modules/keyboardmanager/ui/KeyDropDownControl.h
index 41da7fb603f6..c9cc7a85d069 100644
--- a/src/modules/keyboardmanager/ui/KeyDropDownControl.h
+++ b/src/modules/keyboardmanager/ui/KeyDropDownControl.h
@@ -28,130 +28,136 @@ class KeyDropDownControl
         SetDefaultProperties(isShortcut);
     }
 
-    // Constructor for shortcut drop down
-    KeyDropDownControl(size_t rowIndex, size_t colIndex, std::vector<std::vector<Shortcut>>& shortcutRemapBuffer, std::vector<std::unique_ptr<KeyDropDownControl>>& keyDropDownControlObjects, StackPanel parent)
+    // Function to set selection handler for shortcut drop down. Needs to be called after the constructor since the shortcutControl StackPanel is null if called in the constructor
+    void SetSelectionHandler(Grid& table, StackPanel& shortcutControl, StackPanel parent, size_t colIndex, std::vector<std::vector<Shortcut>>& shortcutRemapBuffer, std::vector<std::unique_ptr<KeyDropDownControl>>& keyDropDownControlObjects)
     {
-        SetDefaultProperties(true);
         Flyout warningFlyout;
         TextBlock warningMessage;
         warningFlyout.Content(warningMessage);
         dropDown.ContextFlyout().SetAttachedFlyout((FrameworkElement)dropDown, warningFlyout);
 
         // drop down selection handler
-        dropDown.SelectionChanged([&, rowIndex, colIndex, parent, warningMessage](winrt::Windows::Foundation::IInspectable const& sender, SelectionChangedEventArgs const&) {
+        dropDown.SelectionChanged([&, table, shortcutControl, colIndex, parent, warningMessage](winrt::Windows::Foundation::IInspectable const& sender, SelectionChangedEventArgs const&) {
             ComboBox currentDropDown = sender.as<ComboBox>();
             int selectedKeyIndex = currentDropDown.SelectedIndex();
             uint32_t dropDownIndex = -1;
             bool dropDownFound = parent.Children().IndexOf(currentDropDown, dropDownIndex);
+            // Get row index of the single key control
+            uint32_t controlIndex;
+            bool controlIindexFound = table.Children().IndexOf(shortcutControl, controlIndex);
 
-            if (selectedKeyIndex != -1 && keyCodeList.size() > selectedKeyIndex && dropDownFound)
+            if (controlIindexFound)
             {
-                // If only 1 drop down and action key is chosen: Warn that a modifier must be chosen
-                if (parent.Children().Size() == 1 && !KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]))
-                {
-                    // warn and reset the drop down
-                    SetDropDownError(currentDropDown, warningMessage, L"Shortcut must start with a modifier key");
-                }
-                // If it is the last drop down
-                else if (dropDownIndex == parent.Children().Size() - 1)
+                int rowIndex = (controlIndex - 2) / 3;
+                if (selectedKeyIndex != -1 && keyCodeList.size() > selectedKeyIndex && dropDownFound)
                 {
-                    // If last drop down and a modifier is selected: add a new drop down (max of 5 drop downs should be enforced)
-                    if (KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]) && parent.Children().Size() < 5)
+                    // If only 1 drop down and action key is chosen: Warn that a modifier must be chosen
+                    if (parent.Children().Size() == 1 && !KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]))
+                    {
+                        // warn and reset the drop down
+                        SetDropDownError(currentDropDown, warningMessage, L"Shortcut must start with a modifier key");
+                    }
+                    // If it is the last drop down
+                    else if (dropDownIndex == parent.Children().Size() - 1)
                     {
-                        // If it matched any of the previous modifiers then reset that drop down
-                        if (CheckRepeatedModifier(parent, dropDownIndex, selectedKeyIndex, keyCodeList))
+                        // If last drop down and a modifier is selected: add a new drop down (max of 5 drop downs should be enforced)
+                        if (KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]) && parent.Children().Size() < 5)
                         {
-                            // warn and reset the drop down
-                            SetDropDownError(currentDropDown, warningMessage, L"Shortcut cannot contain a repeated modifier");
+                            // If it matched any of the previous modifiers then reset that drop down
+                            if (CheckRepeatedModifier(parent, dropDownIndex, selectedKeyIndex, keyCodeList))
+                            {
+                                // warn and reset the drop down
+                                SetDropDownError(currentDropDown, warningMessage, L"Shortcut cannot contain a repeated modifier");
+                            }
+                            // If not, add a new drop down
+                            else
+                            {
+                                AddDropDown(table, shortcutControl, parent, colIndex, shortcutRemapBuffer, keyDropDownControlObjects);
+                            }
                         }
-                        // If not, add a new drop down
-                        else
+                        // If last drop down and a modifier is selected but there are already 5 drop downs: warn the user
+                        else if (KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]) && parent.Children().Size() >= 5)
                         {
-                            AddDropDown(parent, rowIndex, colIndex, shortcutRemapBuffer, keyDropDownControlObjects);
+                            // warn and reset the drop down
+                            SetDropDownError(currentDropDown, warningMessage, L"Shortcut must contain an action key");
                         }
-                    }
-                    // If last drop down and a modifier is selected but there are already 5 drop downs: warn the user
-                    else if (KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]) && parent.Children().Size() >= 5)
-                    {
-                        // warn and reset the drop down
-                        SetDropDownError(currentDropDown, warningMessage, L"Shortcut must contain an action key");
-                    }
-                    // If None is selected but it's the last index: warn
-                    else if (keyCodeList[selectedKeyIndex] == 0)
-                    {
-                        // warn and reset the drop down
-                        SetDropDownError(currentDropDown, warningMessage, L"Shortcut must contain an action key");
-                    }
-                    // If none of the above, then the action key will be set
-                }
-                // If it is the not the last drop down
-                else
-                {
-                    if (KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]))
-                    {
-                        // If it matched any of the previous modifiers then reset that drop down
-                        if (CheckRepeatedModifier(parent, dropDownIndex, selectedKeyIndex, keyCodeList))
+                        // If None is selected but it's the last index: warn
+                        else if (keyCodeList[selectedKeyIndex] == 0)
                         {
                             // warn and reset the drop down
-                            SetDropDownError(currentDropDown, warningMessage, L"Shortcut cannot contain a repeated modifier");
+                            SetDropDownError(currentDropDown, warningMessage, L"Shortcut must contain an action key");
                         }
-                        // If not, the modifier key will be set
+                        // If none of the above, then the action key will be set
                     }
-                    // If None is selected and there are more than 2 drop downs
-                    else if (keyCodeList[selectedKeyIndex] == 0 && parent.Children().Size() > 2)
-                    {
-                        // delete drop down
-                        parent.Children().RemoveAt(dropDownIndex);
-                        // delete drop down control object from the vector so that it can be destructed
-                        keyDropDownControlObjects.erase(keyDropDownControlObjects.begin() + dropDownIndex);
-                        parent.UpdateLayout();
-                    }
-                    else if (keyCodeList[selectedKeyIndex] == 0 && parent.Children().Size() <= 2)
-                    {
-                        // warn and reset the drop down
-                        SetDropDownError(currentDropDown, warningMessage, L"Shortcut must have atleast 2 keys");
-                    }
-                    // If the user tries to set an action key check if all drop down menus after this are empty if it is not the first key
-                    else if (dropDownIndex != 0)
+                    // If it is the not the last drop down
+                    else
                     {
-                        bool isClear = true;
-                        for (int i = dropDownIndex + 1; i < (int)parent.Children().Size(); i++)
+                        if (KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]))
                         {
-                            ComboBox currentDropDown = parent.Children().GetAt(i).as<ComboBox>();
-                            if (currentDropDown.SelectedIndex() != -1)
+                            // If it matched any of the previous modifiers then reset that drop down
+                            if (CheckRepeatedModifier(parent, dropDownIndex, selectedKeyIndex, keyCodeList))
                             {
-                                isClear = false;
-                                break;
+                                // warn and reset the drop down
+                                SetDropDownError(currentDropDown, warningMessage, L"Shortcut cannot contain a repeated modifier");
                             }
+                            // If not, the modifier key will be set
                         }
-
-                        if (isClear)
+                        // If None is selected and there are more than 2 drop downs
+                        else if (keyCodeList[selectedKeyIndex] == 0 && parent.Children().Size() > 2)
+                        {
+                            // delete drop down
+                            parent.Children().RemoveAt(dropDownIndex);
+                            // delete drop down control object from the vector so that it can be destructed
+                            keyDropDownControlObjects.erase(keyDropDownControlObjects.begin() + dropDownIndex);
+                            parent.UpdateLayout();
+                        }
+                        else if (keyCodeList[selectedKeyIndex] == 0 && parent.Children().Size() <= 2)
+                        {
+                            // warn and reset the drop down
+                            SetDropDownError(currentDropDown, warningMessage, L"Shortcut must have atleast 2 keys");
+                        }
+                        // If the user tries to set an action key check if all drop down menus after this are empty if it is not the first key
+                        else if (dropDownIndex != 0)
                         {
-                            // remove all the drop down
-                            int elementsToBeRemoved = parent.Children().Size() - dropDownIndex - 1;
-                            for (int i = 0; i < elementsToBeRemoved; i++)
+                            bool isClear = true;
+                            for (int i = dropDownIndex + 1; i < (int)parent.Children().Size(); i++)
                             {
-                                parent.Children().RemoveAtEnd();
+                                ComboBox currentDropDown = parent.Children().GetAt(i).as<ComboBox>();
+                                if (currentDropDown.SelectedIndex() != -1)
+                                {
+                                    isClear = false;
+                                    break;
+                                }
+                            }
+
+                            if (isClear)
+                            {
+                                // remove all the drop down
+                                int elementsToBeRemoved = parent.Children().Size() - dropDownIndex - 1;
+                                for (int i = 0; i < elementsToBeRemoved; i++)
+                                {
+                                    parent.Children().RemoveAtEnd();
+                                }
+                                parent.UpdateLayout();
+                            }
+                            else
+                            {
+                                // warn and reset the drop down
+                                SetDropDownError(currentDropDown, warningMessage, L"Shortcut cannot have more than one action key");
                             }
-                            parent.UpdateLayout();
                         }
+                        // If there an action key is chosen on the first drop down and there are more than one drop down menus
                         else
                         {
                             // warn and reset the drop down
-                            SetDropDownError(currentDropDown, warningMessage, L"Shortcut cannot have more than one action key");
+                            SetDropDownError(currentDropDown, warningMessage, L"Shortcut must start with a modifier key");
                         }
                     }
-                    // If there an action key is chosen on the first drop down and there are more than one drop down menus
-                    else
-                    {
-                        // warn and reset the drop down
-                        SetDropDownError(currentDropDown, warningMessage, L"Shortcut must start with a modifier key");
-                    }
                 }
-            }
 
-            // Reset the buffer based on the new selected drop down items
-            shortcutRemapBuffer[rowIndex][colIndex].SetKeyCodes(GetKeysFromStackPanel(parent));
+                // Reset the buffer based on the new selected drop down items
+                shortcutRemapBuffer[rowIndex][colIndex].SetKeyCodes(GetKeysFromStackPanel(parent));
+            }
         });
     }
 
@@ -188,7 +194,7 @@ class KeyDropDownControl
     ComboBox GetComboBox();
 
     // Function to add a drop down to the shortcut stack panel
-    static void AddDropDown(StackPanel parent, const size_t rowIndex, const size_t colIndex, std::vector<std::vector<Shortcut>>& shortcutRemapBuffer, std::vector<std::unique_ptr<KeyDropDownControl>>& keyDropDownControlObjects);
+    static void AddDropDown(Grid table, StackPanel shortcutControl, StackPanel parent, const size_t colIndex, std::vector<std::vector<Shortcut>>& shortcutRemapBuffer, std::vector<std::unique_ptr<KeyDropDownControl>>& keyDropDownControlObjects);
 
     // Function to get the list of key codes from the shortcut combo box stack panel
     std::vector<DWORD> GetKeysFromStackPanel(StackPanel parent);
diff --git a/src/modules/keyboardmanager/ui/ShortcutControl.cpp b/src/modules/keyboardmanager/ui/ShortcutControl.cpp
index 910fb5286808..0e5eaea63aaf 100644
--- a/src/modules/keyboardmanager/ui/ShortcutControl.cpp
+++ b/src/modules/keyboardmanager/ui/ShortcutControl.cpp
@@ -13,8 +13,8 @@ void ShortcutControl::AddNewShortcutControlRow(Grid& parent, std::vector<std::ve
 {
     // Create new ShortcutControl objects dynamically so that we does not get destructed
     std::vector<std::unique_ptr<ShortcutControl>> newrow;
-    newrow.push_back(std::move(std::unique_ptr<ShortcutControl>(new ShortcutControl(shortcutRemapBuffer.size(), 0))));
-    newrow.push_back(std::move(std::unique_ptr<ShortcutControl>(new ShortcutControl(shortcutRemapBuffer.size(), 1))));
+    newrow.push_back(std::move(std::unique_ptr<ShortcutControl>(new ShortcutControl(parent, 0))));
+    newrow.push_back(std::move(std::unique_ptr<ShortcutControl>(new ShortcutControl(parent, 1))));
     keyboardRemapControlObjects.push_back(std::move(newrow));
 
     // Add to grid
@@ -28,7 +28,6 @@ void ShortcutControl::AddNewShortcutControlRow(Grid& parent, std::vector<std::ve
     // ShortcutControl for the new shortcut
     parent.Children().Append(keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][1]->getShortcutControl());
 
-    
     // Delete row button
     Windows::UI::Xaml::Controls::Button deleteShortcut;
     FontIcon deleteSymbol;
@@ -62,25 +61,25 @@ void ShortcutControl::AddNewShortcutControlRow(Grid& parent, std::vector<std::ve
     });
     parent.SetColumn(deleteShortcut, 2);
     parent.SetRow(deleteShortcut, parent.RowDefinitions().Size() - 1);
+    parent.Children().Append(deleteShortcut);
     parent.UpdateLayout();
 
     // Set the shortcut text if the two vectors are not empty (i.e. default args)
     if (originalKeys.IsValidShortcut() && newKeys.IsValidShortcut())
     {
         shortcutRemapBuffer.push_back(std::vector<Shortcut>{ Shortcut(), Shortcut() });
-        keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][0]->AddShortcutToControl(originalKeys, keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][0]->shortcutDropDownStackPanel, *keyboardManagerState, shortcutRemapBuffer.size() - 1, 0);
-        keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][1]->AddShortcutToControl(newKeys, keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][1]->shortcutDropDownStackPanel, *keyboardManagerState, shortcutRemapBuffer.size() - 1, 1);
+        keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][0]->AddShortcutToControl(originalKeys, parent, keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][0]->shortcutDropDownStackPanel, *keyboardManagerState, 0);
+        keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][1]->AddShortcutToControl(newKeys, parent, keyboardRemapControlObjects[keyboardRemapControlObjects.size() - 1][1]->shortcutDropDownStackPanel, *keyboardManagerState, 1);
     }
     else
     {
         // Initialize both shortcuts as empty shortcuts
         shortcutRemapBuffer.push_back(std::vector<Shortcut>{ Shortcut(), Shortcut() });
     }
-
 }
 
 // Function to add a shortcut to the shortcut control as combo boxes
-void ShortcutControl::AddShortcutToControl(Shortcut& shortcut, StackPanel parent, KeyboardManagerState& keyboardManagerState, const size_t rowIndex, const size_t colIndex)
+void ShortcutControl::AddShortcutToControl(Shortcut& shortcut, Grid table, StackPanel parent, KeyboardManagerState& keyboardManagerState, const size_t colIndex)
 {
     // Delete the existing drop down menus
     parent.Children().Clear();
@@ -91,7 +90,7 @@ void ShortcutControl::AddShortcutToControl(Shortcut& shortcut, StackPanel parent
     std::vector<DWORD> keyCodeList = keyboardManagerState.keyboardMap.GetKeyCodeList(true);
     if (shortcutKeyCodes.size() != 0)
     {
-        KeyDropDownControl::AddDropDown(parent, rowIndex, colIndex, shortcutRemapBuffer, keyDropDownControlObjects);
+        KeyDropDownControl::AddDropDown(table, shortcutControlLayout, parent, colIndex, shortcutRemapBuffer, keyDropDownControlObjects);
         for (int i = 0; i < shortcutKeyCodes.size(); i++)
         {
             // New drop down gets added automatically when the SelectedIndex is set
@@ -116,7 +115,7 @@ StackPanel ShortcutControl::getShortcutControl()
 }
 
 // Function to create the detect shortcut UI window
-void ShortcutControl::createDetectShortcutWindow(winrt::Windows::Foundation::IInspectable const& sender, XamlRoot xamlRoot, std::vector<std::vector<Shortcut>>& shortcutRemapBuffer, KeyboardManagerState& keyboardManagerState, const size_t rowIndex, const size_t colIndex)
+void ShortcutControl::createDetectShortcutWindow(winrt::Windows::Foundation::IInspectable const& sender, XamlRoot xamlRoot, std::vector<std::vector<Shortcut>>& shortcutRemapBuffer, KeyboardManagerState& keyboardManagerState, const size_t colIndex, Grid table)
 {
     // ContentDialog for detecting shortcuts. This is the parent UI element.
     ContentDialog detectShortcutBox;
@@ -150,15 +149,15 @@ void ShortcutControl::createDetectShortcutWindow(winrt::Windows::Foundation::IIn
                      &keyboardManagerState,
                      &shortcutRemapBuffer,
                      unregisterKeys,
-                     rowIndex,
-                     colIndex] {
+                     colIndex,
+                     table] {
         // Save the detected shortcut in the linked text block
         Shortcut detectedShortcutKeys = keyboardManagerState.GetDetectedShortcut();
 
         if (!detectedShortcutKeys.IsEmpty())
         {
             // The shortcut buffer gets set in this function
-            AddShortcutToControl(detectedShortcutKeys, linkedShortcutStackPanel, keyboardManagerState, rowIndex, colIndex);
+            AddShortcutToControl(detectedShortcutKeys, table, linkedShortcutStackPanel, keyboardManagerState, colIndex);
         }
 
         // Reset the keyboard manager UI state
diff --git a/src/modules/keyboardmanager/ui/ShortcutControl.h b/src/modules/keyboardmanager/ui/ShortcutControl.h
index 13c389ec18c5..42b18b361f02 100644
--- a/src/modules/keyboardmanager/ui/ShortcutControl.h
+++ b/src/modules/keyboardmanager/ui/ShortcutControl.h
@@ -29,18 +29,17 @@ class ShortcutControl
     // Vector to store dynamically allocated KeyDropDownControl objects to avoid early destruction
     std::vector<std::unique_ptr<KeyDropDownControl>> keyDropDownControlObjects;
 
-    ShortcutControl(const size_t rowIndex, const size_t colIndex)
+    ShortcutControl(Grid table, const size_t colIndex)
     {
         shortcutDropDownStackPanel.RequestedTheme(ElementTheme::Light);
         shortcutDropDownStackPanel.Spacing(10);
         shortcutDropDownStackPanel.Orientation(Windows::UI::Xaml::Controls::Orientation::Horizontal);
-        KeyDropDownControl::AddDropDown(shortcutDropDownStackPanel, rowIndex, colIndex, shortcutRemapBuffer, keyDropDownControlObjects);
 
         typeShortcut.Content(winrt::box_value(winrt::to_hstring("Type Shortcut")));
-        typeShortcut.Click([&, rowIndex, colIndex](winrt::Windows::Foundation::IInspectable const& sender, RoutedEventArgs const&) {
+        typeShortcut.Click([&, table, colIndex](winrt::Windows::Foundation::IInspectable const& sender, RoutedEventArgs const&) {
             keyboardManagerState->SetUIState(KeyboardManagerUIState::DetectShortcutWindowActivated, EditShortcutsWindowHandle);
             // Using the XamlRoot of the typeShortcut to get the root of the XAML host
-            createDetectShortcutWindow(sender, sender.as<Button>().XamlRoot(), shortcutRemapBuffer, *keyboardManagerState, rowIndex, colIndex);
+            createDetectShortcutWindow(sender, sender.as<Button>().XamlRoot(), shortcutRemapBuffer, *keyboardManagerState, colIndex, table);
         });
 
         shortcutControlLayout.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
@@ -49,6 +48,7 @@ class ShortcutControl
 
         shortcutControlLayout.Children().Append(typeShortcut);
         shortcutControlLayout.Children().Append(shortcutDropDownStackPanel);
+        KeyDropDownControl::AddDropDown(table, shortcutControlLayout, shortcutDropDownStackPanel, colIndex, shortcutRemapBuffer, keyDropDownControlObjects);
         shortcutControlLayout.UpdateLayout();
     }
 
@@ -56,11 +56,11 @@ class ShortcutControl
     static void AddNewShortcutControlRow(Grid& parent, std::vector<std::vector<std::unique_ptr<ShortcutControl>>>& keyboardRemapControlObjects, Shortcut originalKeys = Shortcut(), Shortcut newKeys = Shortcut());
 
     // Function to add a shortcut to the shortcut control as combo boxes
-    void AddShortcutToControl(Shortcut& shortcut, StackPanel parent, KeyboardManagerState& keyboardManagerState, const size_t rowIndex, const size_t colIndex);
+    void AddShortcutToControl(Shortcut& shortcut, Grid table, StackPanel parent, KeyboardManagerState& keyboardManagerState, const size_t colIndex);
 
     // Function to return the stack panel element of the ShortcutControl. This is the externally visible UI element which can be used to add it to other layouts
     StackPanel getShortcutControl();
 
     // Function to create the detect shortcut UI window
-    void createDetectShortcutWindow(winrt::Windows::Foundation::IInspectable const& sender, XamlRoot xamlRoot, std::vector<std::vector<Shortcut>>& shortcutRemapBuffer, KeyboardManagerState& keyboardManagerState, const size_t rowIndex, const size_t colIndex);
+    void createDetectShortcutWindow(winrt::Windows::Foundation::IInspectable const& sender, XamlRoot xamlRoot, std::vector<std::vector<Shortcut>>& shortcutRemapBuffer, KeyboardManagerState& keyboardManagerState, const size_t colIndex, Grid table);
 };
diff --git a/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp b/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
index ae0a4ef832fa..c7ab8b0a4ae8 100644
--- a/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
+++ b/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
@@ -10,12 +10,6 @@ std::vector<std::vector<DWORD>> SingleKeyRemapControl::singleKeyRemapBuffer;
 // Function to add a new row to the remap keys table. If the originalKey and newKey args are provided, then the displayed remap keys are set to those values.
 void SingleKeyRemapControl::AddNewControlKeyRemapRow(Grid& parent, std::vector<std::vector<std::unique_ptr<SingleKeyRemapControl>>>& keyboardRemapControlObjects, const DWORD originalKey, const DWORD newKey)
 {
-    // Parent element for the row
-    //Windows::UI::Xaml::Controls::StackPanel tableRow;
-    //tableRow.Background(Windows::UI::Xaml::Media::SolidColorBrush{ Windows::UI::Colors::LightGray() });
-    //tableRow.Spacing(100);
-    //tableRow.Orientation(Windows::UI::Xaml::Controls::Orientation::Horizontal);
-
     // Create new SingleKeyRemapControl objects dynamically so that we does not get destructed
     std::vector<std::unique_ptr<SingleKeyRemapControl>> newrow;
     newrow.push_back(std::move(std::unique_ptr<SingleKeyRemapControl>(new SingleKeyRemapControl(parent, 0))));

From 84f8f1142d04b43452ff0c219ceefcd96fd23af7 Mon Sep 17 00:00:00 2001
From: Arjun <arjunbalgovind@gmail.com>
Date: Tue, 21 Apr 2020 13:12:53 -0700
Subject: [PATCH 6/6] Fixed resize windows message behaviour and removed
 warnings

---
 .../keyboardmanager/ui/EditKeyboardWindow.cpp |   2 +
 .../ui/EditShortcutsWindow.cpp                |   2 +
 .../keyboardmanager/ui/KeyDropDownControl.cpp | 172 ++++++++++++++++++
 .../keyboardmanager/ui/KeyDropDownControl.h   | 161 +---------------
 .../keyboardmanager/ui/ShortcutControl.cpp    |   2 +-
 .../ui/SingleKeyRemapControl.cpp              |   2 +-
 6 files changed, 182 insertions(+), 159 deletions(-)

diff --git a/src/modules/keyboardmanager/ui/EditKeyboardWindow.cpp b/src/modules/keyboardmanager/ui/EditKeyboardWindow.cpp
index a5288f1a3e70..8a74e927d827 100644
--- a/src/modules/keyboardmanager/ui/EditKeyboardWindow.cpp
+++ b/src/modules/keyboardmanager/ui/EditKeyboardWindow.cpp
@@ -263,7 +263,9 @@ LRESULT CALLBACK EditKeyboardWindowProc(HWND hWnd, UINT messageCode, WPARAM wPar
     RECT rcClient;
     switch (messageCode)
     {
+    // Resize the XAML window whenever the parent window is painted or resized
     case WM_PAINT:
+    case WM_SIZE:
         GetClientRect(hWnd, &rcClient);
         SetWindowPos(hWndXamlIslandEditKeyboardWindow, 0, rcClient.left, rcClient.top, rcClient.right, rcClient.bottom, SWP_SHOWWINDOW);
         break;
diff --git a/src/modules/keyboardmanager/ui/EditShortcutsWindow.cpp b/src/modules/keyboardmanager/ui/EditShortcutsWindow.cpp
index 94913664b856..a0f5ba458c23 100644
--- a/src/modules/keyboardmanager/ui/EditShortcutsWindow.cpp
+++ b/src/modules/keyboardmanager/ui/EditShortcutsWindow.cpp
@@ -250,7 +250,9 @@ LRESULT CALLBACK EditShortcutsWindowProc(HWND hWnd, UINT messageCode, WPARAM wPa
     RECT rcClient;
     switch (messageCode)
     {
+    // Resize the XAML window whenever the parent window is painted or resized
     case WM_PAINT:
+    case WM_SIZE:
         GetClientRect(hWnd, &rcClient);
         SetWindowPos(hWndXamlIslandEditShortcutsWindow, 0, rcClient.left, rcClient.top, rcClient.right, rcClient.bottom, SWP_SHOWWINDOW);
         break;
diff --git a/src/modules/keyboardmanager/ui/KeyDropDownControl.cpp b/src/modules/keyboardmanager/ui/KeyDropDownControl.cpp
index d322f97a32c4..3d91863eb203 100644
--- a/src/modules/keyboardmanager/ui/KeyDropDownControl.cpp
+++ b/src/modules/keyboardmanager/ui/KeyDropDownControl.cpp
@@ -35,6 +35,178 @@ void KeyDropDownControl::CheckAndUpdateKeyboardLayout(ComboBox currentDropDown,
     }
 }
 
+// Function to set selection handler for single key remap drop down. Needs to be called after the constructor since the singleKeyControl StackPanel is null if called in the constructor
+void KeyDropDownControl::SetSelectionHandler(Grid& table, StackPanel& singleKeyControl, size_t colIndex, std::vector<std::vector<DWORD>>& singleKeyRemapBuffer)
+{
+    dropDown.SelectionChanged([&, table, singleKeyControl, colIndex](winrt::Windows::Foundation::IInspectable const& sender, SelectionChangedEventArgs const& args) {
+        ComboBox currentDropDown = sender.as<ComboBox>();
+        int selectedKeyIndex = currentDropDown.SelectedIndex();
+        // Get row index of the single key control
+        uint32_t controlIndex;
+        bool indexFound = table.Children().IndexOf(singleKeyControl, controlIndex);
+        if (indexFound)
+        {
+            int rowIndex = (controlIndex - 2) / 3;
+            // Check if the element was not found or the index exceeds the known keys
+            if (selectedKeyIndex != -1 && keyCodeList.size() > selectedKeyIndex)
+            {
+                singleKeyRemapBuffer[rowIndex][colIndex] = keyCodeList[selectedKeyIndex];
+            }
+            else
+            {
+                // Reset to null if the key is not found
+                singleKeyRemapBuffer[rowIndex][colIndex] = NULL;
+            }
+        }
+    });
+}
+
+// Function to set selection handler for shortcut drop down. Needs to be called after the constructor since the shortcutControl StackPanel is null if called in the constructor
+void KeyDropDownControl::SetSelectionHandler(Grid& table, StackPanel& shortcutControl, StackPanel parent, size_t colIndex, std::vector<std::vector<Shortcut>>& shortcutRemapBuffer, std::vector<std::unique_ptr<KeyDropDownControl>>& keyDropDownControlObjects)
+{
+    Flyout warningFlyout;
+    TextBlock warningMessage;
+    warningFlyout.Content(warningMessage);
+    dropDown.ContextFlyout().SetAttachedFlyout((FrameworkElement)dropDown, warningFlyout);
+
+    // drop down selection handler
+    dropDown.SelectionChanged([&, table, shortcutControl, colIndex, parent, warningMessage](winrt::Windows::Foundation::IInspectable const& sender, SelectionChangedEventArgs const&) {
+        ComboBox currentDropDown = sender.as<ComboBox>();
+        int selectedKeyIndex = currentDropDown.SelectedIndex();
+        uint32_t dropDownIndex = -1;
+        bool dropDownFound = parent.Children().IndexOf(currentDropDown, dropDownIndex);
+        // Get row index of the single key control
+        uint32_t controlIndex;
+        bool controlIindexFound = table.Children().IndexOf(shortcutControl, controlIndex);
+
+        if (controlIindexFound)
+        {
+            int rowIndex = (controlIndex - 2) / 3;
+            if (selectedKeyIndex != -1 && keyCodeList.size() > selectedKeyIndex && dropDownFound)
+            {
+                // If only 1 drop down and action key is chosen: Warn that a modifier must be chosen
+                if (parent.Children().Size() == 1 && !KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]))
+                {
+                    // warn and reset the drop down
+                    SetDropDownError(currentDropDown, warningMessage, L"Shortcut must start with a modifier key");
+                }
+                // If it is the last drop down
+                else if (dropDownIndex == parent.Children().Size() - 1)
+                {
+                    // If last drop down and a modifier is selected: add a new drop down (max of 5 drop downs should be enforced)
+                    if (KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]) && parent.Children().Size() < 5)
+                    {
+                        // If it matched any of the previous modifiers then reset that drop down
+                        if (CheckRepeatedModifier(parent, dropDownIndex, selectedKeyIndex, keyCodeList))
+                        {
+                            // warn and reset the drop down
+                            SetDropDownError(currentDropDown, warningMessage, L"Shortcut cannot contain a repeated modifier");
+                        }
+                        // If not, add a new drop down
+                        else
+                        {
+                            AddDropDown(table, shortcutControl, parent, colIndex, shortcutRemapBuffer, keyDropDownControlObjects);
+                        }
+                    }
+                    // If last drop down and a modifier is selected but there are already 5 drop downs: warn the user
+                    else if (KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]) && parent.Children().Size() >= 5)
+                    {
+                        // warn and reset the drop down
+                        SetDropDownError(currentDropDown, warningMessage, L"Shortcut must contain an action key");
+                    }
+                    // If None is selected but it's the last index: warn
+                    else if (keyCodeList[selectedKeyIndex] == 0)
+                    {
+                        // warn and reset the drop down
+                        SetDropDownError(currentDropDown, warningMessage, L"Shortcut must contain an action key");
+                    }
+                    // If none of the above, then the action key will be set
+                }
+                // If it is the not the last drop down
+                else
+                {
+                    if (KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]))
+                    {
+                        // If it matched any of the previous modifiers then reset that drop down
+                        if (CheckRepeatedModifier(parent, dropDownIndex, selectedKeyIndex, keyCodeList))
+                        {
+                            // warn and reset the drop down
+                            SetDropDownError(currentDropDown, warningMessage, L"Shortcut cannot contain a repeated modifier");
+                        }
+                        // If not, the modifier key will be set
+                    }
+                    // If None is selected and there are more than 2 drop downs
+                    else if (keyCodeList[selectedKeyIndex] == 0 && parent.Children().Size() > 2)
+                    {
+                        // delete drop down
+                        parent.Children().RemoveAt(dropDownIndex);
+                        // delete drop down control object from the vector so that it can be destructed
+                        keyDropDownControlObjects.erase(keyDropDownControlObjects.begin() + dropDownIndex);
+                        parent.UpdateLayout();
+                    }
+                    else if (keyCodeList[selectedKeyIndex] == 0 && parent.Children().Size() <= 2)
+                    {
+                        // warn and reset the drop down
+                        SetDropDownError(currentDropDown, warningMessage, L"Shortcut must have atleast 2 keys");
+                    }
+                    // If the user tries to set an action key check if all drop down menus after this are empty if it is not the first key
+                    else if (dropDownIndex != 0)
+                    {
+                        bool isClear = true;
+                        for (int i = dropDownIndex + 1; i < (int)parent.Children().Size(); i++)
+                        {
+                            ComboBox currentDropDown = parent.Children().GetAt(i).as<ComboBox>();
+                            if (currentDropDown.SelectedIndex() != -1)
+                            {
+                                isClear = false;
+                                break;
+                            }
+                        }
+
+                        if (isClear)
+                        {
+                            // remove all the drop down
+                            int elementsToBeRemoved = parent.Children().Size() - dropDownIndex - 1;
+                            for (int i = 0; i < elementsToBeRemoved; i++)
+                            {
+                                parent.Children().RemoveAtEnd();
+                                keyDropDownControlObjects.erase(keyDropDownControlObjects.end() - 1);
+                            }
+                            parent.UpdateLayout();
+                        }
+                        else
+                        {
+                            // warn and reset the drop down
+                            SetDropDownError(currentDropDown, warningMessage, L"Shortcut cannot have more than one action key");
+                        }
+                    }
+                    // If there an action key is chosen on the first drop down and there are more than one drop down menus
+                    else
+                    {
+                        // warn and reset the drop down
+                        SetDropDownError(currentDropDown, warningMessage, L"Shortcut must start with a modifier key");
+                    }
+                }
+            }
+
+            // Reset the buffer based on the new selected drop down items
+            shortcutRemapBuffer[rowIndex][colIndex].SetKeyCodes(GetKeysFromStackPanel(parent));
+        }
+
+        // If the user searches for a key the selection handler gets invoked however if they click away it reverts back to the previous state. This can result in dangling references to added drop downs which were then reset.
+        // We handle this by removing the drop down if it no longer a child of the parent
+        for (long long i = keyDropDownControlObjects.size() - 1; i >= 0; i--)
+        {
+            uint32_t index;
+            bool found = parent.Children().IndexOf(keyDropDownControlObjects[i]->GetComboBox(), index);
+            if (!found)
+            {
+                keyDropDownControlObjects.erase(keyDropDownControlObjects.begin() + i);
+            }
+        }
+    });
+}
+
 // Function to set the selected index of the drop down
 void KeyDropDownControl::SetSelectedIndex(int32_t index)
 {
diff --git a/src/modules/keyboardmanager/ui/KeyDropDownControl.h b/src/modules/keyboardmanager/ui/KeyDropDownControl.h
index c9cc7a85d069..6984a824472f 100644
--- a/src/modules/keyboardmanager/ui/KeyDropDownControl.h
+++ b/src/modules/keyboardmanager/ui/KeyDropDownControl.h
@@ -28,164 +28,11 @@ class KeyDropDownControl
         SetDefaultProperties(isShortcut);
     }
 
-    // Function to set selection handler for shortcut drop down. Needs to be called after the constructor since the shortcutControl StackPanel is null if called in the constructor
-    void SetSelectionHandler(Grid& table, StackPanel& shortcutControl, StackPanel parent, size_t colIndex, std::vector<std::vector<Shortcut>>& shortcutRemapBuffer, std::vector<std::unique_ptr<KeyDropDownControl>>& keyDropDownControlObjects)
-    {
-        Flyout warningFlyout;
-        TextBlock warningMessage;
-        warningFlyout.Content(warningMessage);
-        dropDown.ContextFlyout().SetAttachedFlyout((FrameworkElement)dropDown, warningFlyout);
-
-        // drop down selection handler
-        dropDown.SelectionChanged([&, table, shortcutControl, colIndex, parent, warningMessage](winrt::Windows::Foundation::IInspectable const& sender, SelectionChangedEventArgs const&) {
-            ComboBox currentDropDown = sender.as<ComboBox>();
-            int selectedKeyIndex = currentDropDown.SelectedIndex();
-            uint32_t dropDownIndex = -1;
-            bool dropDownFound = parent.Children().IndexOf(currentDropDown, dropDownIndex);
-            // Get row index of the single key control
-            uint32_t controlIndex;
-            bool controlIindexFound = table.Children().IndexOf(shortcutControl, controlIndex);
-
-            if (controlIindexFound)
-            {
-                int rowIndex = (controlIndex - 2) / 3;
-                if (selectedKeyIndex != -1 && keyCodeList.size() > selectedKeyIndex && dropDownFound)
-                {
-                    // If only 1 drop down and action key is chosen: Warn that a modifier must be chosen
-                    if (parent.Children().Size() == 1 && !KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]))
-                    {
-                        // warn and reset the drop down
-                        SetDropDownError(currentDropDown, warningMessage, L"Shortcut must start with a modifier key");
-                    }
-                    // If it is the last drop down
-                    else if (dropDownIndex == parent.Children().Size() - 1)
-                    {
-                        // If last drop down and a modifier is selected: add a new drop down (max of 5 drop downs should be enforced)
-                        if (KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]) && parent.Children().Size() < 5)
-                        {
-                            // If it matched any of the previous modifiers then reset that drop down
-                            if (CheckRepeatedModifier(parent, dropDownIndex, selectedKeyIndex, keyCodeList))
-                            {
-                                // warn and reset the drop down
-                                SetDropDownError(currentDropDown, warningMessage, L"Shortcut cannot contain a repeated modifier");
-                            }
-                            // If not, add a new drop down
-                            else
-                            {
-                                AddDropDown(table, shortcutControl, parent, colIndex, shortcutRemapBuffer, keyDropDownControlObjects);
-                            }
-                        }
-                        // If last drop down and a modifier is selected but there are already 5 drop downs: warn the user
-                        else if (KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]) && parent.Children().Size() >= 5)
-                        {
-                            // warn and reset the drop down
-                            SetDropDownError(currentDropDown, warningMessage, L"Shortcut must contain an action key");
-                        }
-                        // If None is selected but it's the last index: warn
-                        else if (keyCodeList[selectedKeyIndex] == 0)
-                        {
-                            // warn and reset the drop down
-                            SetDropDownError(currentDropDown, warningMessage, L"Shortcut must contain an action key");
-                        }
-                        // If none of the above, then the action key will be set
-                    }
-                    // If it is the not the last drop down
-                    else
-                    {
-                        if (KeyboardManagerHelper::IsModifierKey(keyCodeList[selectedKeyIndex]))
-                        {
-                            // If it matched any of the previous modifiers then reset that drop down
-                            if (CheckRepeatedModifier(parent, dropDownIndex, selectedKeyIndex, keyCodeList))
-                            {
-                                // warn and reset the drop down
-                                SetDropDownError(currentDropDown, warningMessage, L"Shortcut cannot contain a repeated modifier");
-                            }
-                            // If not, the modifier key will be set
-                        }
-                        // If None is selected and there are more than 2 drop downs
-                        else if (keyCodeList[selectedKeyIndex] == 0 && parent.Children().Size() > 2)
-                        {
-                            // delete drop down
-                            parent.Children().RemoveAt(dropDownIndex);
-                            // delete drop down control object from the vector so that it can be destructed
-                            keyDropDownControlObjects.erase(keyDropDownControlObjects.begin() + dropDownIndex);
-                            parent.UpdateLayout();
-                        }
-                        else if (keyCodeList[selectedKeyIndex] == 0 && parent.Children().Size() <= 2)
-                        {
-                            // warn and reset the drop down
-                            SetDropDownError(currentDropDown, warningMessage, L"Shortcut must have atleast 2 keys");
-                        }
-                        // If the user tries to set an action key check if all drop down menus after this are empty if it is not the first key
-                        else if (dropDownIndex != 0)
-                        {
-                            bool isClear = true;
-                            for (int i = dropDownIndex + 1; i < (int)parent.Children().Size(); i++)
-                            {
-                                ComboBox currentDropDown = parent.Children().GetAt(i).as<ComboBox>();
-                                if (currentDropDown.SelectedIndex() != -1)
-                                {
-                                    isClear = false;
-                                    break;
-                                }
-                            }
-
-                            if (isClear)
-                            {
-                                // remove all the drop down
-                                int elementsToBeRemoved = parent.Children().Size() - dropDownIndex - 1;
-                                for (int i = 0; i < elementsToBeRemoved; i++)
-                                {
-                                    parent.Children().RemoveAtEnd();
-                                }
-                                parent.UpdateLayout();
-                            }
-                            else
-                            {
-                                // warn and reset the drop down
-                                SetDropDownError(currentDropDown, warningMessage, L"Shortcut cannot have more than one action key");
-                            }
-                        }
-                        // If there an action key is chosen on the first drop down and there are more than one drop down menus
-                        else
-                        {
-                            // warn and reset the drop down
-                            SetDropDownError(currentDropDown, warningMessage, L"Shortcut must start with a modifier key");
-                        }
-                    }
-                }
-
-                // Reset the buffer based on the new selected drop down items
-                shortcutRemapBuffer[rowIndex][colIndex].SetKeyCodes(GetKeysFromStackPanel(parent));
-            }
-        });
-    }
-
     // Function to set selection handler for single key remap drop down. Needs to be called after the constructor since the singleKeyControl StackPanel is null if called in the constructor
-    void SetSelectionHandler(Grid& table, StackPanel& singleKeyControl, size_t colIndex, std::vector<std::vector<DWORD>>& singleKeyRemapBuffer)
-    {
-        dropDown.SelectionChanged([&, table, singleKeyControl, colIndex](winrt::Windows::Foundation::IInspectable const& sender, SelectionChangedEventArgs const& args) {
-            ComboBox currentDropDown = sender.as<ComboBox>();
-            int selectedKeyIndex = currentDropDown.SelectedIndex();
-            // Get row index of the single key control
-            uint32_t controlIndex;
-            bool indexFound = table.Children().IndexOf(singleKeyControl, controlIndex);
-            if (indexFound)
-            {
-                int rowIndex = (controlIndex - 2) / 3;
-                // Check if the element was not found or the index exceeds the known keys
-                if (selectedKeyIndex != -1 && keyCodeList.size() > selectedKeyIndex)
-                {
-                    singleKeyRemapBuffer[rowIndex][colIndex] = keyCodeList[selectedKeyIndex];
-                }
-                else
-                {
-                    // Reset to null if the key is not found
-                    singleKeyRemapBuffer[rowIndex][colIndex] = NULL;
-                }
-            }
-        });
-    }
+    void SetSelectionHandler(Grid& table, StackPanel& singleKeyControl, size_t colIndex, std::vector<std::vector<DWORD>>& singleKeyRemapBuffer);
+
+    // Function to set selection handler for shortcut drop down. Needs to be called after the constructor since the shortcutControl StackPanel is null if called in the constructor
+    void SetSelectionHandler(Grid& table, StackPanel& shortcutControl, StackPanel parent, size_t colIndex, std::vector<std::vector<Shortcut>>& shortcutRemapBuffer, std::vector<std::unique_ptr<KeyDropDownControl>>& keyDropDownControlObjects);
 
     // Function to set the selected index of the drop down
     void SetSelectedIndex(int32_t index);
diff --git a/src/modules/keyboardmanager/ui/ShortcutControl.cpp b/src/modules/keyboardmanager/ui/ShortcutControl.cpp
index 0e5eaea63aaf..6206efbabaff 100644
--- a/src/modules/keyboardmanager/ui/ShortcutControl.cpp
+++ b/src/modules/keyboardmanager/ui/ShortcutControl.cpp
@@ -41,7 +41,7 @@ void ShortcutControl::AddNewShortcutControlRow(Grid& parent, std::vector<std::ve
         UIElementCollection children = parent.Children();
         children.IndexOf(currentButton, index);
         // Change the row index of elements appearing after the current row, as we will delete the row definition
-        for (int i = index + 1; i < children.Size(); i++)
+        for (uint32_t i = index + 1; i < children.Size(); i++)
         {
             int32_t elementRowIndex = parent.GetRow(children.GetAt(i).as<FrameworkElement>());
             parent.SetRow(children.GetAt(i).as<FrameworkElement>(), elementRowIndex - 1);
diff --git a/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp b/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
index c7ab8b0a4ae8..7c94d1f4825d 100644
--- a/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
+++ b/src/modules/keyboardmanager/ui/SingleKeyRemapControl.cpp
@@ -65,7 +65,7 @@ void SingleKeyRemapControl::AddNewControlKeyRemapRow(Grid& parent, std::vector<s
         UIElementCollection children = parent.Children();
         children.IndexOf(currentButton, index);
         // Change the row index of elements appearing after the current row, as we will delete the row definition
-        for (int i = index + 1; i < children.Size(); i++)
+        for (uint32_t i = index + 1; i < children.Size(); i++)
         {
             int32_t elementRowIndex = parent.GetRow(children.GetAt(i).as<FrameworkElement>());
             parent.SetRow(children.GetAt(i).as<FrameworkElement>(), elementRowIndex - 1);