Connect keyboard events to Lua

Author: JoelOtter

src/core/src/scripting/scripting_api.cpp

@@ -71,5 +71,27 @@ Error ScriptingAPI::mountGrowlScripts(API& api) {
 		return err;
 	}
 
+	auto input_keyboard_event_res = createClass("InputKeyboardEvent", false);
+	if (!input_keyboard_event_res) {
+		return std::move(input_keyboard_event_res.error());
+	}
+	auto& input_keyboard_event_cls = *input_keyboard_event_res;
+
+	if (auto err =
+			input_keyboard_event_cls->addConstructor<const InputKeyboardEvent*>(
+				[](ClassSelf* self, void* ctx,
+				   const std::vector<ScriptingParam>& args)
+					-> Result<ScriptingParam> {
+					auto event = static_cast<const InputKeyboardEvent*>(
+						std::get<const void*>(args.at(0)));
+					self->setField("type", (int)event->type);
+					self->setField("key", (int)event->key);
+					return ScriptingParam();
+				},
+				nullptr);
+		err) {
+		return err;
+	}
+
 	return nullptr;
 }

src/scene/include/growl/scene/node.h

@@ -52,6 +52,8 @@ class Node : public InputProcessor {
 	// Input
 	virtual bool onMouseEvent(const InputMouseEvent& event) override;
 	bool onMouseEventRaw(const InputMouseEvent& event);
+	virtual bool onKeyboardEvent(const InputKeyboardEvent& event) override;
+	bool onKeyboardEventRaw(const InputKeyboardEvent& event);
 
 private:
 	API* api;

src/scene/src/node.cpp

@@ -177,3 +177,39 @@ bool Node::onMouseEvent(const InputMouseEvent& event) {
 bool Node::onMouseEventRaw(const InputMouseEvent& event) {
 	return InputProcessor::onMouseEvent(event);
 }
+
+bool Node::onKeyboardEvent(const InputKeyboardEvent& event) {
+	if (!bound_script_obj) {
+		return onKeyboardEventRaw(event);
+	}
+
+	std::vector<ScriptingParam> ctor_args;
+	ctor_args.push_back(&event);
+	auto ctor_result =
+		api->scripting().executeConstructor<const InputKeyboardEvent*>(
+			"InputKeyboardEvent", ctor_args);
+	if (!ctor_result) {
+		api->system().log(
+			LogLevel::Warn, "Node::onKeyboardEvent",
+			"Failed to execute constructor: {}",
+			ctor_result.error()->message());
+		return false;
+	}
+
+	std::vector<ScriptingParam> v;
+	v.push_back(std::move(ctor_result.get()));
+	auto exec_res =
+		api->scripting().executeMethod<bool, std::unique_ptr<ScriptingRef>>(
+			bound_script_obj.get(), "onKeyboardEvent", v);
+	if (!exec_res) {
+		api->system().log(
+			LogLevel::Warn, "Node::onKeyboardEvent",
+			"Failed to execute method: {}", exec_res.error()->message());
+		return false;
+	}
+	return std::get<bool>(*exec_res);
+}
+
+bool Node::onKeyboardEventRaw(const InputKeyboardEvent& event) {
+	return InputProcessor::onKeyboardEvent(event);
+}

src/scene/src/scene.cpp

@@ -268,5 +268,37 @@ Error Growl::initSceneGraph(API& api) {
 		return err;
 	}
 
+	if (auto err = node_cls->addMethod<bool, std::unique_ptr<ScriptingRef>>(
+			"onKeyboardEvent",
+			[](ClassSelf* self, void* ctx,
+			   const std::vector<ScriptingParam>& args)
+				-> Result<ScriptingParam> {
+				ScriptingAPI* scripting = static_cast<ScriptingAPI*>(ctx);
+				Node* n =
+					static_cast<Node*>(const_cast<void*>(std::get<const void*>(
+						self->getField("__ptr", ScriptingType::Ptr))));
+				auto& script_event =
+					std::get<std::unique_ptr<ScriptingRef>>(args.at(0));
+				InputKeyboardEvent event;
+				if (auto res = scripting->getField(
+						script_event.get(), "type", ScriptingType::Int);
+					!res) {
+					return std::move(res.error());
+				} else {
+					event.type = KeyEventType(std::get<int>(res.get()));
+				}
+				if (auto res = scripting->getField(
+						script_event.get(), "key", ScriptingType::Int);
+					!res) {
+					return std::move(res.error());
+				} else {
+					event.key = Key(std::get<int>(res.get()));
+				}
+				return ScriptingParam(n->onKeyboardEventRaw(event));
+			},
+			&(api.scripting()))) {
+		return err;
+	}
+
 	return nullptr;
 }