Add secondary modifier support.

include/eepp/window/keycodes.hpp

@@ -702,10 +702,16 @@ class EE_API KeyMod {
   public:
 	static Uint32 getDefaultModifier();
 
+	/** @return A platform-appropriate secondary modifier that does not overlap the default one. */
+	static Uint32 getDefaultSecondaryModifier();
+
 	static void setDefaultModifier( const Uint32& mod );
+	static void setDefaultSecondaryModifier( const Uint32& mod );
 
 	static std::string getDefaultModifierString();
 
+	static std::string getDefaultSecondaryModifierString();
+
 	static bool isKeyMod( std::string key );
 
 	static Uint32 getKeyMod( std::string key );
@@ -716,6 +722,7 @@ class EE_API KeyMod {
 
   private:
 	static Uint32 defaultModifier;
+	static Uint32 defaultSecondaryModifier;
 };
 
 /** @enum MouseButton Mouse buttons */
@@ -734,7 +741,7 @@ enum MouseButton {
 	EE_BUTTON_WHEELRIGHT = 31
 };
 
-#define EE_BUTTON_MASK( X ) ( 1 << ( (X)-1 ) )
+#define EE_BUTTON_MASK( X ) ( 1 << ( ( X ) - 1 ) )
 
 /** @enum MouseButtonsMask Mouse buttons mask, to check the current state of every button. */
 enum MouseButtonMask {

src/eepp/ui/keyboardshortcut.cpp

@@ -13,10 +13,11 @@ KeyBindings::Shortcut KeyBindings::sanitizeShortcut( const KeyBindings::Shortcut
 		sanitized.mod |= KEYMOD_SHIFT;
 	if ( shortcut.mod & KEYMOD_META )
 		sanitized.mod |= KEYMOD_META;
-	if ( shortcut.mod & KEYMOD_LALT )
+	const Uint32 alt = shortcut.mod & KEYMOD_ALT;
+	if ( alt == KEYMOD_ALT )
 		sanitized.mod |= KEYMOD_LALT;
-	if ( shortcut.mod & KEYMOD_RALT )
+	else
-		sanitized.mod |= KEYMOD_RALT;
+		sanitized.mod |= alt;
 	return sanitized;
 }
 
@@ -149,6 +150,7 @@ std::string KeyBindings::getCommandFromKeyBind( const KeyBindings::Shortcut& key
 
 std::string KeyBindings::keybindFormat( std::string str ) {
 	if ( !str.empty() ) {
+		String::replace( str, "mod2", KeyMod::getDefaultSecondaryModifierString() );
 		String::replace( str, "mod", KeyMod::getDefaultModifierString() );
 		str[0] = std::toupper( str[0] );
 		size_t found = str.find_first_of( '+' );
@@ -185,20 +187,24 @@ const std::map<std::string, Uint64>& KeyBindings::getKeybindings() const {
 
 std::string KeyBindings::fromShortcut( const Window::Input* input, KeyBindings::Shortcut shortcut,
 									   bool format ) {
+	shortcut = sanitizeShortcut( shortcut );
 	std::vector<std::string> mods;
 	std::string keyname( String::toLower( input->getKeyName( shortcut.key ) ) );
 	const auto& MOD_MAP = KeyMod::getModMap();
 	if ( shortcut.mod & MOD_MAP.at( "mod" ) )
 		mods.emplace_back( "mod" );
-	if ( ( shortcut.mod & KEYMOD_CTRL ) && KEYMOD_CTRL != MOD_MAP.at( "mod" ) )
+	if ( shortcut.mod & MOD_MAP.at( "mod2" ) )
+		mods.emplace_back( "mod2" );
+	const Uint32 abstractMods = MOD_MAP.at( "mod" ) | MOD_MAP.at( "mod2" );
+	if ( ( shortcut.mod & KEYMOD_CTRL ) && !( KEYMOD_CTRL & abstractMods ) )
 		mods.emplace_back( "ctrl" );
-	if ( ( shortcut.mod & KEYMOD_SHIFT ) && KEYMOD_SHIFT != MOD_MAP.at( "mod" ) )
+	if ( ( shortcut.mod & KEYMOD_SHIFT ) && !( KEYMOD_SHIFT & abstractMods ) )
 		mods.emplace_back( "shift" );
-	if ( ( shortcut.mod & KEYMOD_LALT ) && KEYMOD_LALT != MOD_MAP.at( "mod" ) )
+	if ( ( shortcut.mod & KEYMOD_LALT ) && !( KEYMOD_LALT & abstractMods ) )
 		mods.emplace_back( "alt" );
-	if ( ( shortcut.mod & KEYMOD_RALT ) && KEYMOD_RALT != MOD_MAP.at( "mod" ) )
+	if ( ( shortcut.mod & KEYMOD_RALT ) && !( KEYMOD_RALT & abstractMods ) )
 		mods.emplace_back( "altgr" );
-	if ( ( shortcut.mod & KEYMOD_META ) && KEYMOD_META != MOD_MAP.at( "mod" ) )
+	if ( ( shortcut.mod & KEYMOD_META ) && !( KEYMOD_META & abstractMods ) )
 		mods.emplace_back( "meta" );
 	if ( mods.empty() )
 		return format ? keybindFormat( keyname ) : keyname;

src/eepp/ui/mouseshortcut.cpp

@@ -247,6 +247,7 @@ std::string MouseBindings::getCommandFromMousebind( const MouseBindings::Shortcu
 
 std::string MouseBindings::mousebindFormat( std::string str ) {
 	if ( !str.empty() ) {
+		String::replace( str, "mod2", KeyMod::getDefaultSecondaryModifierString() );
 		String::replace( str, "mod", KeyMod::getDefaultModifierString() );
 		str[0] = std::toupper( str[0] );
 		size_t found = str.find_first_of( '+' );
@@ -284,21 +285,25 @@ MouseBindings::getMousebindings() const {
 }
 
 std::string MouseBindings::fromShortcut( MouseBindings::Shortcut shortcut, bool format ) {
+	shortcut = sanitizeShortcut( shortcut );
 	std::vector<std::string> mods;
 	std::string actionname( mouseActionToString( shortcut.action ) );
 	std::string keyname( String::toLower( getMouseButtonsName( shortcut.key ) ) );
 	const auto& MOD_MAP = KeyMod::getModMap();
 	if ( shortcut.mod & MOD_MAP.at( "mod" ) )
 		mods.emplace_back( "mod" );
-	if ( ( shortcut.mod & KEYMOD_CTRL ) && KEYMOD_CTRL != MOD_MAP.at( "mod" ) )
+	if ( shortcut.mod & MOD_MAP.at( "mod2" ) )
+		mods.emplace_back( "mod2" );
+	const Uint32 abstractMods = MOD_MAP.at( "mod" ) | MOD_MAP.at( "mod2" );
+	if ( ( shortcut.mod & KEYMOD_CTRL ) && !( KEYMOD_CTRL & abstractMods ) )
 		mods.emplace_back( "ctrl" );
-	if ( ( shortcut.mod & KEYMOD_SHIFT ) && KEYMOD_SHIFT != MOD_MAP.at( "mod" ) )
+	if ( ( shortcut.mod & KEYMOD_SHIFT ) && !( KEYMOD_SHIFT & abstractMods ) )
 		mods.emplace_back( "shift" );
-	if ( ( shortcut.mod & KEYMOD_LALT ) && KEYMOD_LALT != MOD_MAP.at( "mod" ) )
+	if ( ( shortcut.mod & KEYMOD_LALT ) && !( KEYMOD_LALT & abstractMods ) )
 		mods.emplace_back( "alt" );
-	if ( ( shortcut.mod & KEYMOD_RALT ) && KEYMOD_RALT != MOD_MAP.at( "mod" ) )
+	if ( ( shortcut.mod & KEYMOD_RALT ) && !( KEYMOD_RALT & abstractMods ) )
 		mods.emplace_back( "altgr" );
-	if ( ( shortcut.mod & KEYMOD_META ) && KEYMOD_META != MOD_MAP.at( "mod" ) )
+	if ( ( shortcut.mod & KEYMOD_META ) && !( KEYMOD_META & abstractMods ) )
 		mods.emplace_back( "meta" );
 	if ( mods.empty() )
 		return format ? mousebindFormat( keyname ) : keyname;

src/eepp/ui/tools/uicodeeditorsplitter.cpp

@@ -36,15 +36,19 @@ UICodeEditorSplitter::getLocalDefaultKeybindings() {
 		{ { KEY_W, KeyMod::getDefaultModifier() }, "close-tab" },
 		{ { KEY_TAB, DefaultSwitchToTabModifier }, "next-tab" },
 		{ { KEY_TAB, DefaultSwitchToTabModifier | KEYMOD_SHIFT }, "previous-tab" },
-		{ { KEY_J, KEYMOD_LALT | KEYMOD_SHIFT }, "split-left" },
+		{ { KEY_J, KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT }, "split-left" },
-		{ { KEY_L, KEYMOD_LALT | KEYMOD_SHIFT }, "split-right" },
+		{ { KEY_L, KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT }, "split-right" },
-		{ { KEY_I, KEYMOD_LALT | KEYMOD_SHIFT }, "split-top" },
+		{ { KEY_I, KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT }, "split-top" },
-		{ { KEY_K, KEYMOD_LALT | KEYMOD_SHIFT }, "split-bottom" },
+		{ { KEY_K, KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT }, "split-bottom" },
-		{ { KEY_S, KEYMOD_LALT | KEYMOD_SHIFT }, "split-swap" },
+		{ { KEY_S, KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT }, "split-swap" },
-		{ { KEY_J, KeyMod::getDefaultModifier() | KEYMOD_LALT }, "switch-to-previous-split" },
+		{ { KEY_J, KeyMod::getDefaultModifier() | KeyMod::getDefaultSecondaryModifier() },
-		{ { KEY_L, KeyMod::getDefaultModifier() | KEYMOD_LALT }, "switch-to-next-split" },
+		  "switch-to-previous-split" },
-		{ { KEY_N, KeyMod::getDefaultModifier() | KEYMOD_LALT }, "switch-to-previous-colorscheme" },
+		{ { KEY_L, KeyMod::getDefaultModifier() | KeyMod::getDefaultSecondaryModifier() },
-		{ { KEY_M, KeyMod::getDefaultModifier() | KEYMOD_LALT }, "switch-to-next-colorscheme" },
+		  "switch-to-next-split" },
+		{ { KEY_N, KeyMod::getDefaultModifier() | KeyMod::getDefaultSecondaryModifier() },
+		  "switch-to-previous-colorscheme" },
+		{ { KEY_M, KeyMod::getDefaultModifier() | KeyMod::getDefaultSecondaryModifier() },
+		  "switch-to-next-colorscheme" },
 		{ { KEY_1, DefaultSwitchToTabModifier }, "switch-to-tab-1" },
 		{ { KEY_2, DefaultSwitchToTabModifier }, "switch-to-tab-2" },
 		{ { KEY_3, DefaultSwitchToTabModifier }, "switch-to-tab-3" },
@@ -55,8 +59,8 @@ UICodeEditorSplitter::getLocalDefaultKeybindings() {
 		{ { KEY_8, DefaultSwitchToTabModifier }, "switch-to-tab-8" },
 		{ { KEY_9, DefaultSwitchToTabModifier }, "switch-to-tab-9" },
 		{ { KEY_0, DefaultSwitchToTabModifier }, "switch-to-last-tab" },
-		{ { KEY_LEFT, KEYMOD_LALT }, "editor-go-back" },
+		{ { KEY_LEFT, KeyMod::getDefaultSecondaryModifier() }, "editor-go-back" },
-		{ { KEY_RIGHT, KEYMOD_LALT }, "editor-go-forward" },
+		{ { KEY_RIGHT, KeyMod::getDefaultSecondaryModifier() }, "editor-go-forward" },
 	};
 }
 

src/eepp/ui/uicodeeditor.cpp

@@ -114,13 +114,15 @@ const std::map<KeyBindings::Shortcut, std::string> UICodeEditor::getDefaultKeybi
 		{ { KEY_0, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "font-size-reset" },
 		{ { KEY_KP_DIVIDE, KeyMod::getDefaultModifier() }, "toggle-line-comments" },
 		{ { KEY_KP_DIVIDE, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "toggle-block-comments" },
-		{ { KEY_UP, KEYMOD_CTRL | KEYMOD_LALT | KEYMOD_SHIFT }, "selection-to-upper" },
+		{ { KEY_UP, KEYMOD_CTRL | KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT },
-		{ { KEY_DOWN, KEYMOD_CTRL | KEYMOD_LALT | KEYMOD_SHIFT }, "selection-to-lower" },
+		  "selection-to-upper" },
+		{ { KEY_DOWN, KEYMOD_CTRL | KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT },
+		  "selection-to-lower" },
 		{ { KEY_F, KeyMod::getDefaultModifier() }, "find-replace" },
 		{ { KEY_D, KeyMod::getDefaultModifier() }, "select-word" },
 		{ { KEY_D, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "select-all-words" },
-		{ { KEY_UP, KEYMOD_LALT }, "add-cursor-above" },
+		{ { KEY_UP, KeyMod::getDefaultSecondaryModifier() }, "add-cursor-above" },
-		{ { KEY_DOWN, KEYMOD_LALT }, "add-cursor-below" },
+		{ { KEY_DOWN, KeyMod::getDefaultSecondaryModifier() }, "add-cursor-below" },
 		{ { KEY_ESCAPE }, "reset-cursor" },
 		{ { KEY_U, KeyMod::getDefaultModifier() }, "cursor-undo" },
 		{ { KEY_A, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "select-all-matches" },
@@ -131,7 +133,8 @@ const std::map<KeyBindings::Shortcut, std::string> UICodeEditor::getDefaultKeybi
 const MouseBindings::ShortcutMap UICodeEditor::getDefaultMousebindings() {
 	return { { { MouseAction::Down, EE_BUTTON_LMASK, KeyMod::getDefaultModifier() },
 			   "add-cursor-at-mouse-position" },
-			 { { MouseAction::Down, EE_BUTTON_LMASK, KEYMOD_SHIFT | KEYMOD_LALT },
+			 { { MouseAction::Down, EE_BUTTON_LMASK,
+				 KEYMOD_SHIFT | KeyMod::getDefaultSecondaryModifier() },
 			   "add-cursors-from-current-to-mouse-position" } };
 }
 

src/eepp/window/keycodes.cpp

@@ -3,39 +3,83 @@
 namespace EE { namespace Window {
 
 Uint32 KeyMod::defaultModifier = KEYMOD_DEFAULT_MODIFIER;
+Uint32 KeyMod::defaultSecondaryModifier =
+	KEYMOD_DEFAULT_MODIFIER & KEYMOD_ALT ? KEYMOD_CTRL : KEYMOD_LALT;
 
-static std::map<std::string, Uint32> MOD_MAP = { { "lshift", KEYMOD_SHIFT },
+static std::map<std::string, Uint32> MOD_MAP = {
-												 { "rshift", KEYMOD_SHIFT },
+	{ "lshift", KEYMOD_SHIFT },
-												 { "left shift", KEYMOD_SHIFT },
+	{ "rshift", KEYMOD_SHIFT },
-												 { "right shift", KEYMOD_SHIFT },
+	{ "left shift", KEYMOD_SHIFT },
-												 { "shift", KEYMOD_SHIFT },
+	{ "right shift", KEYMOD_SHIFT },
-												 { "lctrl", KEYMOD_CTRL },
+	{ "shift", KEYMOD_SHIFT },
-												 { "rctrl", KEYMOD_CTRL },
+	{ "lctrl", KEYMOD_CTRL },
-												 { "left ctrl", KEYMOD_CTRL },
+	{ "rctrl", KEYMOD_CTRL },
-												 { "right ctrl", KEYMOD_CTRL },
+	{ "left ctrl", KEYMOD_CTRL },
-												 { "ctrl", KEYMOD_CTRL },
+	{ "right ctrl", KEYMOD_CTRL },
-												 { "lalt", KEYMOD_ALT },
+	{ "ctrl", KEYMOD_CTRL },
-												 { "ralt", KEYMOD_RALT },
+	{ "lalt", KEYMOD_LALT },
-												 { "left alt", KEYMOD_LALT },
+	{ "ralt", KEYMOD_RALT },
-												 { "right alt", KEYMOD_RALT },
+	{ "left alt", KEYMOD_LALT },
-												 { "altgr", KEYMOD_RALT },
+	{ "right alt", KEYMOD_RALT },
-												 { "alt", KEYMOD_LALT },
+	{ "altgr", KEYMOD_RALT },
-												 { "lmeta", KEYMOD_META },
+	{ "alt", KEYMOD_LALT },
-												 { "lmeta", KEYMOD_META },
+	{ "lmeta", KEYMOD_META },
-												 { "left meta", KEYMOD_META },
+	{ "lmeta", KEYMOD_META },
-												 { "right meta", KEYMOD_META },
+	{ "left meta", KEYMOD_META },
-												 { "meta", KEYMOD_META },
+	{ "right meta", KEYMOD_META },
-												 { "mod", KeyMod::getDefaultModifier() },
+	{ "meta", KEYMOD_META },
-												 { "modifier", KeyMod::getDefaultModifier() } };
+	{ "mod", KeyMod::getDefaultModifier() },
+	{ "modifier", KeyMod::getDefaultModifier() },
+	{ "mod2", KeyMod::getDefaultSecondaryModifier() },
+	{ "modifier2", KeyMod::getDefaultSecondaryModifier() } };
 
 Uint32 KeyMod::getDefaultModifier() {
 	return defaultModifier;
 }
 
+Uint32 KeyMod::getDefaultSecondaryModifier() {
+	return defaultSecondaryModifier;
+}
+
 void KeyMod::setDefaultModifier( const Uint32& mod ) {
 	defaultModifier = mod;
 	MOD_MAP["mod"] = mod;
 	MOD_MAP["modifier"] = mod;
+	if ( defaultSecondaryModifier & mod ) {
+		Uint32 secondary = mod & KEYMOD_ALT ? KEYMOD_CTRL : KEYMOD_LALT;
+		if ( secondary & mod ) {
+			constexpr Uint32 candidates[] = { KEYMOD_CTRL, KEYMOD_LALT, KEYMOD_META, KEYMOD_SHIFT };
+			for ( const Uint32 candidate : candidates ) {
+				if ( !( candidate & mod ) ) {
+					secondary = candidate;
+					break;
+				}
+			}
+		}
+		setDefaultSecondaryModifier( secondary );
+	}
+}
+
+void KeyMod::setDefaultSecondaryModifier( const Uint32& mod ) {
+	defaultSecondaryModifier = mod;
+	MOD_MAP["mod2"] = mod;
+	MOD_MAP["modifier2"] = mod;
+}
+
+std::string KeyMod::getDefaultSecondaryModifierString() {
+	switch ( getDefaultSecondaryModifier() ) {
+		case KEYMOD_SHIFT:
+			return "shift";
+		case KEYMOD_LALT:
+			return "alt";
+		case KEYMOD_RALT:
+			return "altgr";
+		case KEYMOD_META:
+			return "meta";
+		case KEYMOD_CTRL:
+		default:
+			return "ctrl";
+	}
 }
 
 std::string KeyMod::getDefaultModifierString() {
@@ -59,7 +103,7 @@ Uint32 KeyMod::getKeyMod( std::string key ) {
 	auto it = MOD_MAP.find( key );
 	if ( ( it != MOD_MAP.end() ) )
 		return it->second;
-	return 0;
+	return KEYMOD_NONE;
 }
 
 const std::map<std::string, Uint32>& KeyMod::getModMap() {

src/tests/unit_tests/keyboardshortcut_tests.cpp

@@ -0,0 +1,59 @@
+#include "utest.h"
+#include <eepp/ui/keyboardshortcut.hpp>
+#include <eepp/ui/mouseshortcut.hpp>
+#include <eepp/ui/uiapplication.hpp>
+#include <eepp/ui/uiscenenode.hpp>
+
+using namespace EE;
+using namespace EE::UI;
+using namespace EE::Window;
+
+UTEST( KeyboardShortcut, AggregateAltUsesPrimaryAltAndKeepsAltGrDistinct ) {
+	UIApplication app( WindowSettings{ 320, 240, "eepp - keyboard shortcut tests" } );
+	auto& bindings = app.getUI()->getKeyBindings();
+
+	bindings.addKeybind( { KEY_1, KEYMOD_ALT }, "primary-alt" );
+	EXPECT_EQ( static_cast<Uint32>( KEYMOD_LALT ),
+			   bindings.getShortcutFromCommand( "primary-alt" ).mod );
+	EXPECT_TRUE( bindings.getCommandFromKeyBind( { KEY_1, KEYMOD_LALT } ) == "primary-alt" );
+	EXPECT_TRUE( bindings.getCommandFromKeyBind( { KEY_1, KEYMOD_RALT } ).empty() );
+	EXPECT_TRUE( bindings.getShortcutString( { KEY_1, KEYMOD_ALT }, true ) == "Alt+1" );
+
+	bindings.addKeybind( { KEY_2, KEYMOD_RALT }, "altgr" );
+	EXPECT_TRUE( bindings.getCommandFromKeyBind( { KEY_2, KEYMOD_RALT } ) == "altgr" );
+	EXPECT_TRUE( bindings.getCommandFromKeyBind( { KEY_2, KEYMOD_LALT } ).empty() );
+	EXPECT_EQ( static_cast<Uint32>( KEYMOD_LALT ), bindings.getShortcutFromString( "lalt+1" ).mod );
+}
+
+UTEST( KeyboardShortcut, DefaultSecondaryModifierIsSerializableAndDoesNotOverlapDefault ) {
+	UIApplication app( WindowSettings{ 320, 240, "eepp - keyboard shortcut tests" } );
+	auto& bindings = app.getUI()->getKeyBindings();
+	const Uint32 defaultModifier = KeyMod::getDefaultModifier();
+	const Uint32 secondaryModifier = KeyMod::getDefaultSecondaryModifier();
+	EXPECT_EQ( 0u, defaultModifier & secondaryModifier );
+	EXPECT_EQ( static_cast<Uint32>( defaultModifier & KEYMOD_ALT ? KEYMOD_CTRL : KEYMOD_LALT ),
+			   secondaryModifier );
+	EXPECT_EQ( secondaryModifier, KeyMod::getModMap().at( "mod2" ) );
+	EXPECT_EQ( secondaryModifier, KeyMod::getModMap().at( "modifier2" ) );
+	EXPECT_EQ( secondaryModifier, bindings.getShortcutFromString( "mod2+1" ).mod );
+	EXPECT_TRUE( bindings.getShortcutString( { KEY_1, secondaryModifier } ) == "mod2+1" );
+	EXPECT_TRUE( bindings.getShortcutString( { KEY_1, secondaryModifier }, true ) ==
+				 KeyBindings::keybindFormat( KeyMod::getDefaultSecondaryModifierString() + "+1" ) );
+	EXPECT_TRUE(
+		MouseBindings::mousebindFormat( "mod2+mouseleft" ) ==
+		KeyBindings::keybindFormat( KeyMod::getDefaultSecondaryModifierString() + "+mouseleft" ) );
+
+	KeyMod::setDefaultSecondaryModifier( KEYMOD_META );
+	EXPECT_EQ( static_cast<Uint32>( KEYMOD_META ), KeyMod::getDefaultSecondaryModifier() );
+	EXPECT_EQ( static_cast<Uint32>( KEYMOD_META ), KeyMod::getModMap().at( "mod2" ) );
+	EXPECT_EQ( static_cast<Uint32>( KEYMOD_META ), KeyMod::getModMap().at( "modifier2" ) );
+	KeyMod::setDefaultSecondaryModifier( secondaryModifier );
+
+	KeyMod::setDefaultSecondaryModifier( KEYMOD_LALT );
+	KeyMod::setDefaultModifier( KEYMOD_LALT );
+	EXPECT_EQ( static_cast<Uint32>( KEYMOD_CTRL ), KeyMod::getDefaultSecondaryModifier() );
+	EXPECT_EQ( 0u, KeyMod::getDefaultModifier() & KeyMod::getDefaultSecondaryModifier() );
+	EXPECT_EQ( KeyMod::getDefaultSecondaryModifier(), KeyMod::getModMap().at( "mod2" ) );
+	KeyMod::setDefaultModifier( defaultModifier );
+	KeyMod::setDefaultSecondaryModifier( secondaryModifier );
+}

src/tools/ecode/ecode.cpp

@@ -1454,6 +1454,24 @@ void App::loadKeybindings() {
 		ini.setValue( "modifier", "mod", defMod );
 		ini.writeFile();
 	}
+	Uint32 defModKeyCode = KeyMod::getKeyMod( defMod );
+	if ( KEYMOD_NONE != defModKeyCode )
+		KeyMod::setDefaultModifier( defModKeyCode );
+
+	std::string defMod2 = ini.getValue( "modifier", "mod2", "" );
+	if ( defMod2.empty() ) {
+		defMod2 = KeyMod::getDefaultSecondaryModifierString();
+		ini.setValue( "modifier", "mod2", defMod2 );
+		ini.writeFile();
+	}
+	Uint32 defMod2KeyCode = KeyMod::getKeyMod( defMod2 );
+	if ( KEYMOD_NONE != defMod2KeyCode && !( defMod2KeyCode & KeyMod::getDefaultModifier() ) ) {
+		KeyMod::setDefaultSecondaryModifier( defMod2KeyCode );
+	} else {
+		defMod2 = KeyMod::getDefaultSecondaryModifierString();
+		ini.setValue( "modifier", "mod2", defMod2 );
+		ini.writeFile();
+	}
 
 	bool forceRebind = false;
 	auto version = ini.getValueU( "version", "version", 0 );
@@ -1463,10 +1481,6 @@ void App::loadKeybindings() {
 		forceRebind = true;
 	}
 
-	Uint32 defModKeyCode = KeyMod::getKeyMod( defMod );
-	if ( KEYMOD_NONE != defModKeyCode )
-		KeyMod::setDefaultModifier( defModKeyCode );
-
 	KeybindingsHelper::updateKeybindings( ini, "editor", mWindow->getInput(), mKeybindings,
 										  mKeybindingsInvert, getDefaultKeybindings(), forceRebind,
 										  getMigrateKeybindings(), mConfig.iniState );
@@ -2106,13 +2120,14 @@ std::map<KeyBindings::Shortcut, std::string> App::getDefaultKeybindings() {
 #if EE_PLATFORM == EE_PLATFORM_MACOS
 static Uint32 DefaultSwitchToStatusPanelModifier = KeyMod::getDefaultModifier();
 #else
-static Uint32 DefaultSwitchToStatusPanelModifier = KEYMOD_LALT;
+static Uint32 DefaultSwitchToStatusPanelModifier = KeyMod::getDefaultSecondaryModifier();
 #endif
 
 std::map<KeyBindings::Shortcut, std::string> App::getLocalKeybindings() {
 	return {
 		{ { KEY_PRINTSCREEN, KEYMOD_NONE }, "take-screenshot" },
-		{ { KEY_RETURN, KEYMOD_LALT | KEYMOD_LCTRL }, "fullscreen-toggle" },
+		{ { KEY_RETURN, KeyMod::getDefaultSecondaryModifier() | KeyMod::getDefaultModifier() },
+		  "fullscreen-toggle" },
 		{ { KEY_F3, KEYMOD_NONE }, "repeat-find" },
 		{ { KEY_F3, KEYMOD_SHIFT }, "find-prev" },
 		{ { KEY_F12, KEYMOD_NONE }, "console-toggle" },
@@ -2134,18 +2149,24 @@ std::map<KeyBindings::Shortcut, std::string> App::getLocalKeybindings() {
 		{ { KEY_M, KeyMod::getDefaultModifier() }, "menu-toggle" },
 #endif
 		{ { KEY_S, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "save-all" },
-		{ { KEY_F9, KEYMOD_LALT }, "switch-side-panel" },
+		{ { KEY_F9, KeyMod::getDefaultSecondaryModifier() }, "switch-side-panel" },
-		{ { KEY_J, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
+		{ { KEY_J,
+			KeyMod::getDefaultModifier() | KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT },
 		  "terminal-split-left" },
-		{ { KEY_L, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
+		{ { KEY_L,
+			KeyMod::getDefaultModifier() | KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT },
 		  "terminal-split-right" },
-		{ { KEY_I, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
+		{ { KEY_I,
+			KeyMod::getDefaultModifier() | KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT },
 		  "terminal-split-top" },
-		{ { KEY_K, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
+		{ { KEY_K,
+			KeyMod::getDefaultModifier() | KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT },
 		  "terminal-split-bottom" },
-		{ { KEY_S, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
+		{ { KEY_S,
+			KeyMod::getDefaultModifier() | KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT },
 		  "terminal-split-swap" },
-		{ { KEY_T, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
+		{ { KEY_T,
+			KeyMod::getDefaultModifier() | KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT },
 		  "reopen-closed-tab" },
 		{ { KEY_1, DefaultSwitchToStatusPanelModifier }, "toggle-status-locate-bar" },
 		{ { KEY_2, DefaultSwitchToStatusPanelModifier }, "toggle-status-global-search-bar" },
@@ -2155,10 +2176,10 @@ std::map<KeyBindings::Shortcut, std::string> App::getLocalKeybindings() {
 		{ { KEY_B, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "project-build-start-cancel" },
 		{ { KEY_C, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "project-build-cancel" },
 		{ { KEY_R, KeyMod::getDefaultModifier() }, "project-build-and-run" },
-		{ { KEY_O, KEYMOD_LALT | KEYMOD_SHIFT }, "show-open-documents" },
+		{ { KEY_O, KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT }, "show-open-documents" },
 		{ { KEY_K, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "open-workspace-symbol-search" },
 		{ { KEY_P, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "open-document-symbol-search" },
-		{ { KEY_N, KEYMOD_SHIFT | KEYMOD_LALT }, "create-new-window" },
+		{ { KEY_N, KEYMOD_SHIFT | KeyMod::getDefaultSecondaryModifier() }, "create-new-window" },
 	};
 }
 

src/tools/ecode/plugins/lsp/lspclientplugin.cpp

@@ -679,7 +679,8 @@ bool LSPClientPlugin::onMouseClick( UICodeEditor* editor, const Vector2i& pos,
 
 	Input* input = editor->getInput();
 	Uint32 mod = input->getSanitizedModState();
-	if ( mod != ( KEYMOD_LALT | KeyMod::getDefaultModifier() ) || ( flags & EE_BUTTON_LMASK ) == 0 )
+	if ( mod != ( KeyMod::getDefaultSecondaryModifier() | KeyMod::getDefaultModifier() ) ||
+		 ( flags & EE_BUTTON_LMASK ) == 0 )
 		return false;
 
 	auto docPos = editor->resolveScreenPosition( pos.asFloat() );

src/tools/ecode/terminalmanager.cpp

@@ -134,9 +134,11 @@ void TerminalManager::loadTerminalColorSchemes() {
 std::map<KeyBindings::Shortcut, std::string> TerminalManager::getTerminalKeybindings() {
 	return {
 		{ { KEY_T, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "create-new-terminal" },
-		{ { KEY_E, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
+		{ { KEY_E,
+			KeyMod::getDefaultModifier() | KeyMod::getDefaultSecondaryModifier() | KEYMOD_SHIFT },
 		  UITerminal::getExclusiveModeToggleCommandName() },
-		{ { KEY_S, KEYMOD_LALT | KeyMod::getDefaultModifier() }, "terminal-rename" },
+		{ { KEY_S, KeyMod::getDefaultSecondaryModifier() | KeyMod::getDefaultModifier() },
+		  "terminal-rename" },
 	};
 }
 

src/tools/eeiv/eeiv.cpp

@@ -362,9 +362,10 @@ void App::registerKeyBindings() {
 		if ( key == KEY_ESCAPE || key == KEY_Q ) {
 			saveConfig();
 			getWindow()->close();
-		} else if ( key == KEY_TAB && keyEvent->getMod() & KEYMOD_ALT )
+		} else if ( key == KEY_TAB && keyEvent->getMod() & KeyMod::getDefaultSecondaryModifier() )
 			getWindow()->minimize();
-		else if ( key == KEY_F || ( key == KEY_RETURN && keyEvent->getMod() & KEYMOD_ALT ) )
+		else if ( key == KEY_F || ( key == KEY_RETURN &&
+									keyEvent->getMod() & KeyMod::getDefaultSecondaryModifier() ) )
 			getWindow()->toggleFullscreen();
 		else if ( key == KEY_F12 )
 			getWindow()->takeScreenshot();