lua: Add function for ConCommands, use for hotkeys

Author: anone-zone

scripts/00-gamescope/common/util.lua

@@ -17,3 +17,7 @@ end
 function debug(text)
     gamescope.log(gamescope.log_priority.debug, text)
 end
+
+function command(args)
+    gamescope.command(args)
+end

scripts/00-gamescope/input/hotkeys.lua

@@ -2,47 +2,65 @@ gamescope.config.input.hotkeys = {
     {
         -- XKB_KEY_Super_L + XKB_KEY_f
         keys = { 65515, 102 },
-        command = { "fullscreen" }
+        func = function()
+            command({ "fullscreen" })
+        end
     },
     {
         -- XKB_KEY_Super_L + XKB_KEY_n
         keys = { 65515, 110 },
-        command = { "upscale_filter", "nearest" }
+        func = function()
+            command({ "upscale_filter", "nearest" })
+        end
     },
     {
         -- XKB_KEY_Super_L + XKB_KEY_b
         keys = { 65515, 98 },
-        command = { "upscale_filter", "linear" }
+        func = function()
+            command({ "upscale_filter", "linear" })
+        end
     },
     {
         -- XKB_KEY_Super_L + XKB_KEY_u
         keys = { 65515, 117 },
-        command = { "upscale_filter", "fsr" }
+        func = function()
+            command({ "upscale_filter", "fsr" })
+        end
     },
     {
         -- XKB_KEY_Super_L + XKB_KEY_y
         keys = { 65515, 121 },
-        command = { "upscale_filter", "nis" }
+        func = function()
+            command({ "upscale_filter", "nis" })
+        end
     },
     {
         -- XKB_KEY_Super_L + XKB_KEY_i
         keys = { 65515, 105 },
-        command = { "upscale_filter_sharpness", "up" }
+        func = function()
+            command({ "upscale_filter_sharpness", "up" })
+        end
     },
     {
         -- XKB_KEY_Super_L + XKB_KEY_o
         keys = { 65515, 111 },
-        command = { "upscale_filter_sharpness", "down" }
+        func = function()
+            command({ "upscale_filter_sharpness", "down" })
+        end
     },
     {
         -- XKB_KEY_Super_L + XKB_KEY_s
         keys = { 65515, 115 },
-        command = { "screenshot" }
+        func = function()
+            command({ "screenshot" })
+        end
     },
     {
         -- XKB_KEY_Super_L + XKB_KEY_g
         keys = { 65515, 103 },
-        command = { "keyboard_grab" }
+        func = function()
+            command({ "keyboard_grab" })
+        end
     },
 }
 

src/Script/Script.cpp

@@ -112,6 +112,20 @@ namespace gamescope
         );
         m_Gamescope.Base["log"] = []( LogPriority ePriority, std::string_view svText ) { s_ScriptLog.log( ePriority, svText ); };
 
+        m_Gamescope.Base["command"] = []( std::vector<std::string_view> svArgs )
+        {
+            if ( !gamescope::ConCommand::Exec( std::span<std::string_view>{ svArgs } ) )
+            {
+                std::string sDebug = "";
+                for ( std::string_view sv : svArgs )
+                {
+                    sDebug += sv;
+                    sDebug += " ";
+                }
+                s_ScriptMgrLog.warnf( "Failed to exec command: %s\n", sDebug.c_str() );
+            }
+        };
+
         m_Gamescope.Convars.Base = m_State.create_table();
         m_Gamescope.Base.set( "convars", m_Gamescope.Convars.Base );
 
@@ -299,9 +313,9 @@ namespace gamescope
         return oOutDisplay;
     }
 
-    std::vector<std::pair<std::vector<uint32_t>, std::vector<std::string>>> GamescopeScript_t::Config_t::GetHotkeys( CScriptScopedLock &script )
+    std::vector<std::pair<std::vector<uint32_t>, sol::function>> GamescopeScript_t::Config_t::GetHotkeys( CScriptScopedLock &script )
     {
-        std::vector<std::pair<std::vector<uint32_t>, std::vector<std::string>>> hotkeys;
+        std::vector<std::pair<std::vector<uint32_t>, sol::function>> hotkeys;
 
         sol::optional<std::vector<sol::optional<sol::table>>> ovotHotkeys = Input["hotkeys"];
         if ( !ovotHotkeys )
@@ -319,12 +333,12 @@ namespace gamescope
                 continue;
             std::vector<uint32_t> vKeys = *ovKeys;
 
-            sol::optional<std::vector<std::string>> osCommand = tHotkey["command"];
-            if ( !osCommand )
+            sol::optional<sol::function> oFunc = tHotkey["func"];
+            if ( !oFunc )
                 continue;
-            std::vector<std::string> sCommand = *osCommand;
+            sol::function func = *oFunc;
 
-            hotkeys.push_back( std::make_pair( vKeys, sCommand ) );
+            hotkeys.push_back( std::make_pair( vKeys, func ) );
         }
 
         return hotkeys;

src/Script/Script.h

@@ -34,7 +34,7 @@ namespace gamescope
 
             std::optional<std::pair<std::string_view, sol::table>> LookupDisplay( CScriptScopedLock &script, std::string_view psvVendor, uint16_t uProduct, std::string_view psvModel, std::string_view psvDataString );
 
-            std::vector<std::pair<std::vector<uint32_t>, std::vector<std::string>>> GetHotkeys( CScriptScopedLock &script );
+            std::vector<std::pair<std::vector<uint32_t>, sol::function>> GetHotkeys( CScriptScopedLock &script );
         } Config;
     };
 

src/hotkey.cpp

@@ -1,9 +1,10 @@
+#if HAVE_SCRIPTING
+
 #include <linux/input-event-codes.h>
 
 #include <span>
 
 #include "hotkey.h"
-#include "convar.h"
 
 // TODO: Consolidate
 #define WAYLAND_NULL() []<typename... Args> ( void *pData, Args... args ) { }
@@ -16,20 +17,15 @@ namespace gamescope
 	class CHotkeyBinding
     {
     public:
-        bool Init( gamescope_action_binding_manager *pManager, std::span<uint32_t> pKeySyms, std::vector<std::string> args )
+        bool Init( gamescope_action_binding_manager *pManager, std::span<uint32_t> pKeySyms, sol::function func )
         {
             Shutdown();
 
             m_pBinding = gamescope_action_binding_manager_create_action_binding( pManager );
             if ( !m_pBinding )
                 return false;
 
-            m_args = args;
-            for ( std::string_view sv : args )
-            {
-                m_sDescription += sv;
-                m_sDescription += " ";
-            }
+            m_func = func;
 
             wl_array array;
             wl_array_init(&array);
@@ -41,7 +37,7 @@ namespace gamescope
 
             gamescope_action_binding_add_listener( m_pBinding, &s_BindingListener, (void *)this );
             gamescope_action_binding_add_keyboard_trigger( m_pBinding, &array );
-            gamescope_action_binding_set_description( m_pBinding, m_sDescription.c_str() );
+            gamescope_action_binding_set_description( m_pBinding, "TODO: for debugging" );
             gamescope_action_binding_arm( m_pBinding, 0 );
 
             return true;
@@ -58,23 +54,12 @@ namespace gamescope
 
         void Wayland_Triggered( gamescope_action_binding *pBinding, uint32_t uSequence, uint32_t uTriggerFlags, uint32_t uTimeLo, uint32_t uTimeHi )
         {
-            // eugh
-            std::vector<std::string_view> vec;
-            for ( std::string_view sv : m_args )
-            {
-                vec.push_back( sv );
-            }
-
-            if ( !gamescope::ConCommand::Exec( std::span<std::string_view>{ vec } ) )
-            {
-                fprintf( stderr, "Failed to exec: %s\n", m_sDescription.c_str() );
-            }
+            m_func();
         }
 
     private:
         gamescope_action_binding *m_pBinding = nullptr;
-		std::vector<std::string> m_args;
-        std::string m_sDescription;
+		sol::function m_func;
 
         static const gamescope_action_binding_listener s_BindingListener;
     };
@@ -119,10 +104,10 @@ namespace gamescope
 		return true;
 	}
 
-	bool HotkeyHandler::Bind( std::vector<uint32_t> pKeySyms, std::vector<std::string> args )
+	bool HotkeyHandler::Bind( std::vector<uint32_t> pKeySyms, sol::function func )
 	{
 		std::shared_ptr<CHotkeyBinding> binding = std::make_shared<CHotkeyBinding>();
-        auto success = binding->Init( m_pActionBindingManager, pKeySyms, args );
+        auto success = binding->Init( m_pActionBindingManager, pKeySyms, func );
         if ( success )
         {
             m_bindings.push_back(binding);
@@ -145,3 +130,5 @@ namespace gamescope
         .global_remove = WAYLAND_NULL(),
     };
 }
+
+#endif // HAVE_SCRIPTING

src/hotkey.h

@@ -1,12 +1,15 @@
+#if HAVE_SCRIPTING
+
 #pragma once
 
 #include <cstdint>
 #include <memory>
 #include <vector>
-#include <string>
 
 #include <gamescope-action-binding-client-protocol.h>
 
+#include <sol/sol.hpp>
+
 namespace gamescope
 {
 	class CHotkeyBinding;
@@ -18,7 +21,7 @@ namespace gamescope
 		~HotkeyHandler() {}
 
 		bool Init();
-		bool Bind( std::vector<uint32_t> pKeySyms, std::vector<std::string> args );
+		bool Bind( std::vector<uint32_t> pKeySyms, sol::function func );
 		void Dispatch() { wl_display_dispatch(m_pDisplay); }
 
 	private:
@@ -32,3 +35,5 @@ namespace gamescope
 
 	extern HotkeyHandler g_hotkeyHandler;
 }
+
+#endif // HAVE_SCRIPTING

src/main.cpp

@@ -1058,13 +1058,13 @@ static void hotkeyThreadRun()
 {
 	wlserver.bWaylandServerRunning.wait( false );
 
+#if HAVE_SCRIPTING
 	if ( !gamescope::g_hotkeyHandler.Init() )
 	{
 		fprintf( stderr, "Failed to initialize hotkeys\n" );
 		return;
 	}
 
-#if HAVE_SCRIPTING
 	{
 		gamescope::CScriptScopedLock script;
 		auto hotkeys = script.Manager().Gamescope().Config.GetHotkeys( script );
@@ -1073,12 +1073,12 @@ static void hotkeyThreadRun()
 			gamescope::g_hotkeyHandler.Bind( hot.first, hot.second );
 		}
 	}
-#endif
 
 	while ( wlserver.bWaylandServerRunning )
 	{
 		gamescope::g_hotkeyHandler.Dispatch();
 	}
+#endif
 }
 
 gamescope::ConCommand cc_upscale_filter( "upscale_filter", "Set upscale filter method. Values: nearest, linear, fsr, nis",