From efd52cd1725145dc9c8038477dbe133b23868e99 Mon Sep 17 00:00:00 2001
From: Paul Joannon <hello@pauljoannon.com>
Date: Thu, 18 Jan 2018 18:17:29 +0100
Subject: add a [Signal] attribute to CSharpScripts

---
 modules/mono/csharp_script.cpp                | 50 ++++++++++++++++++++++++++-
 modules/mono/csharp_script.h                  |  5 +++
 modules/mono/glue/cs_files/SignalAttribute.cs | 12 +++++++
 modules/mono/mono_gd/gd_mono_class.cpp        | 28 +++++++++++++++
 modules/mono/mono_gd/gd_mono_class.h          |  6 ++++
 modules/mono/mono_gd/gd_mono_utils.cpp        |  2 ++
 modules/mono/mono_gd/gd_mono_utils.h          |  1 +
 7 files changed, 103 insertions(+), 1 deletion(-)
 create mode 100644 modules/mono/glue/cs_files/SignalAttribute.cs

diff --git a/modules/mono/csharp_script.cpp b/modules/mono/csharp_script.cpp
index 0dc0018224..609cb1c013 100644
--- a/modules/mono/csharp_script.cpp
+++ b/modules/mono/csharp_script.cpp
@@ -721,8 +721,10 @@ void CSharpLanguage::reload_assemblies_if_needed(bool p_soft_reload) {
 	for (Map<Ref<CSharpScript>, Map<ObjectID, List<Pair<StringName, Variant> > > >::Element *E = to_reload.front(); E; E = E->next()) {
 
 		Ref<CSharpScript> scr = E->key();
+		scr->signals_invalidated = true;
 		scr->exports_invalidated = true;
 		scr->reload(p_soft_reload);
+		scr->update_signals();
 		scr->update_exports();
 
 		//restore state if saved
@@ -755,8 +757,10 @@ void CSharpLanguage::reload_assemblies_if_needed(bool p_soft_reload) {
 		//if instance states were saved, set them!
 	}
 
-	if (Engine::get_singleton()->is_editor_hint())
+	if (Engine::get_singleton()->is_editor_hint()) {
 		EditorNode::get_singleton()->get_property_editor()->update_tree();
+		NodeDock::singleton->update_lists();
+	}
 }
 #endif
 
@@ -1545,6 +1549,42 @@ bool CSharpScript::_update_exports() {
 	return false;
 }
 
+bool CSharpScript::_update_signals() {
+#ifdef TOOLS_ENABLED
+	if (!valid)
+		return false;
+
+	bool changed = false;
+
+	if (signals_invalidated) {
+		signals_invalidated = false;
+
+		GDMonoClass *top = script_class;
+
+		_signals.clear();
+		changed = true; // TODO Do a real check for change
+
+		while (top && top != native) {
+			const Vector<GDMonoClass *> &delegates = top->get_all_delegates();
+			for (int i = delegates.size() - 1; i >= 0; i--) {
+				GDMonoClass *delegate = delegates[i];
+
+				if (delegate->has_attribute(CACHED_CLASS(SignalAttribute))) {
+					StringName name = delegate->get_name();
+
+					_signals[name] = Vector<StringName>(); // TODO Retrieve arguments
+				}
+			}
+
+			top = top->get_parent_class();
+		}
+	}
+
+	return changed;
+#endif
+	return false;
+}
+
 #ifdef TOOLS_ENABLED
 bool CSharpScript::_get_member_export(GDMonoClass *p_class, GDMonoClassMember *p_member, PropertyInfo &r_prop_info, bool &r_exported) {
 
@@ -1866,6 +1906,7 @@ ScriptInstance *CSharpScript::instance_create(Object *p_this) {
 		PlaceHolderScriptInstance *si = memnew(PlaceHolderScriptInstance(CSharpLanguage::get_singleton(), Ref<Script>(this), p_this));
 		placeholders.insert(si);
 		_update_exports();
+		_update_signals();
 		return si;
 #else
 		return NULL;
@@ -2035,6 +2076,12 @@ void CSharpScript::update_exports() {
 #endif
 }
 
+void CSharpScript::update_signals() {
+#ifdef TOOLS_ENABLED
+	_update_signals();
+#endif
+}
+
 Ref<Script> CSharpScript::get_base_script() const {
 
 	// TODO search in metadata file once we have it, not important any way?
@@ -2099,6 +2146,7 @@ CSharpScript::CSharpScript() :
 #ifdef TOOLS_ENABLED
 	source_changed_cache = false;
 	exports_invalidated = true;
+	signals_invalidated = true;
 #endif
 
 	_resource_path_changed();
diff --git a/modules/mono/csharp_script.h b/modules/mono/csharp_script.h
index f18e339e18..75ed770739 100644
--- a/modules/mono/csharp_script.h
+++ b/modules/mono/csharp_script.h
@@ -91,6 +91,8 @@ class CSharpScript : public Script {
 	Set<PlaceHolderScriptInstance *> placeholders;
 	bool source_changed_cache;
 	bool exports_invalidated;
+	Map<StringName, Vector<StringName> > _signals;
+	bool signals_invalidated;
 
 	void _update_exports_values(Map<StringName, Variant> &values, List<PropertyInfo> &propnames);
 	virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder);
@@ -104,6 +106,8 @@ class CSharpScript : public Script {
 
 	void _clear();
 
+	bool _update_signals();
+
 	bool _update_exports();
 #ifdef TOOLS_ENABLED
 	bool _get_member_export(GDMonoClass *p_class, GDMonoClassMember *p_member, PropertyInfo &r_prop_info, bool &r_exported);
@@ -139,6 +143,7 @@ public:
 
 	/* TODO */ virtual bool has_script_signal(const StringName &p_signal) const { return false; }
 	/* TODO */ virtual void get_script_signal_list(List<MethodInfo> *r_signals) const {}
+	virtual void update_signals();
 
 	/* TODO */ virtual bool get_property_default_value(const StringName &p_property, Variant &r_value) const;
 	virtual void get_script_property_list(List<PropertyInfo> *p_list) const;
diff --git a/modules/mono/glue/cs_files/SignalAttribute.cs b/modules/mono/glue/cs_files/SignalAttribute.cs
new file mode 100644
index 0000000000..d8a6cabb83
--- /dev/null
+++ b/modules/mono/glue/cs_files/SignalAttribute.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace Godot
+{
+    [AttributeUsage(AttributeTargets.Delegate)]
+    public class SignalAttribute : Attribute
+    {
+        public SignalAttribute()
+        {
+        }
+    }
+}
diff --git a/modules/mono/mono_gd/gd_mono_class.cpp b/modules/mono/mono_gd/gd_mono_class.cpp
index b826352f02..66339d7ae6 100644
--- a/modules/mono/mono_gd/gd_mono_class.cpp
+++ b/modules/mono/mono_gd/gd_mono_class.cpp
@@ -404,6 +404,33 @@ const Vector<GDMonoProperty *> &GDMonoClass::get_all_properties() {
 	return properties_list;
 }
 
+const Vector<GDMonoClass *> &GDMonoClass::get_all_delegates() {
+	if (delegates_fetched)
+		return delegates_list;
+
+	void *iter = NULL;
+	MonoClass *raw_class = NULL;
+	while ((raw_class = mono_class_get_nested_types(mono_class, &iter)) != NULL) {
+		if (mono_class_is_delegate(raw_class)) {
+			StringName name = mono_class_get_name(raw_class);
+
+			Map<StringName, GDMonoClass *>::Element *match = delegates.find(name);
+
+			if (match) {
+				delegates_list.push_back(match->get());
+			} else {
+				GDMonoClass *delegate = memnew(GDMonoClass(mono_class_get_namespace(raw_class), mono_class_get_name(raw_class), raw_class, assembly));
+				delegates.insert(name, delegate);
+				delegates_list.push_back(delegate);
+			}
+		}
+	}
+
+	delegates_fetched = true;
+
+	return delegates_list;
+}
+
 GDMonoClass::GDMonoClass(const StringName &p_namespace, const StringName &p_name, MonoClass *p_class, GDMonoAssembly *p_assembly) {
 
 	namespace_name = p_namespace;
@@ -417,6 +444,7 @@ GDMonoClass::GDMonoClass(const StringName &p_namespace, const StringName &p_name
 	methods_fetched = false;
 	fields_fetched = false;
 	properties_fetched = false;
+	delegates_fetched = false;
 }
 
 GDMonoClass::~GDMonoClass() {
diff --git a/modules/mono/mono_gd/gd_mono_class.h b/modules/mono/mono_gd/gd_mono_class.h
index afccf2fc63..417c138594 100644
--- a/modules/mono/mono_gd/gd_mono_class.h
+++ b/modules/mono/mono_gd/gd_mono_class.h
@@ -90,6 +90,10 @@ class GDMonoClass {
 	Map<StringName, GDMonoProperty *> properties;
 	Vector<GDMonoProperty *> properties_list;
 
+	bool delegates_fetched;
+	Map<StringName, GDMonoClass *> delegates;
+	Vector<GDMonoClass *> delegates_list;
+
 	friend class GDMonoAssembly;
 	GDMonoClass(const StringName &p_namespace, const StringName &p_name, MonoClass *p_class, GDMonoAssembly *p_assembly);
 
@@ -133,6 +137,8 @@ public:
 	GDMonoProperty *get_property(const StringName &p_name);
 	const Vector<GDMonoProperty *> &get_all_properties();
 
+	const Vector<GDMonoClass *> &get_all_delegates();
+
 	~GDMonoClass();
 };
 
diff --git a/modules/mono/mono_gd/gd_mono_utils.cpp b/modules/mono/mono_gd/gd_mono_utils.cpp
index a2f0819a72..42e307cf08 100644
--- a/modules/mono/mono_gd/gd_mono_utils.cpp
+++ b/modules/mono/mono_gd/gd_mono_utils.cpp
@@ -114,6 +114,7 @@ void MonoCache::clear_members() {
 	class_ExportAttribute = NULL;
 	field_ExportAttribute_hint = NULL;
 	field_ExportAttribute_hintString = NULL;
+	class_SignalAttribute = NULL;
 	class_ToolAttribute = NULL;
 	class_RemoteAttribute = NULL;
 	class_SyncAttribute = NULL;
@@ -201,6 +202,7 @@ void update_godot_api_cache() {
 	CACHE_CLASS_AND_CHECK(ExportAttribute, GODOT_API_CLASS(ExportAttribute));
 	CACHE_FIELD_AND_CHECK(ExportAttribute, hint, CACHED_CLASS(ExportAttribute)->get_field("hint"));
 	CACHE_FIELD_AND_CHECK(ExportAttribute, hintString, CACHED_CLASS(ExportAttribute)->get_field("hintString"));
+	CACHE_CLASS_AND_CHECK(SignalAttribute, GODOT_API_CLASS(SignalAttribute));
 	CACHE_CLASS_AND_CHECK(ToolAttribute, GODOT_API_CLASS(ToolAttribute));
 	CACHE_CLASS_AND_CHECK(RemoteAttribute, GODOT_API_CLASS(RemoteAttribute));
 	CACHE_CLASS_AND_CHECK(SyncAttribute, GODOT_API_CLASS(SyncAttribute));
diff --git a/modules/mono/mono_gd/gd_mono_utils.h b/modules/mono/mono_gd/gd_mono_utils.h
index 259da46c31..1a34180d15 100644
--- a/modules/mono/mono_gd/gd_mono_utils.h
+++ b/modules/mono/mono_gd/gd_mono_utils.h
@@ -108,6 +108,7 @@ struct MonoCache {
 	GDMonoClass *class_ExportAttribute;
 	GDMonoField *field_ExportAttribute_hint;
 	GDMonoField *field_ExportAttribute_hintString;
+	GDMonoClass *class_SignalAttribute;
 	GDMonoClass *class_ToolAttribute;
 	GDMonoClass *class_RemoteAttribute;
 	GDMonoClass *class_SyncAttribute;
-- 
cgit v1.2.3


From cfbd7fd21e6630cc513ac3a36849c0f796d142c3 Mon Sep 17 00:00:00 2001
From: Paul Joannon <hello@pauljoannon.com>
Date: Thu, 18 Jan 2018 23:27:43 +0100
Subject: implement signal related methods in csharp_script so signals can be
 used with emit

---
 modules/mono/csharp_script.cpp          | 68 ++++++++++++++++++++++++++++++---
 modules/mono/csharp_script.h            | 12 ++++--
 modules/mono/mono_gd/gd_mono_method.cpp | 14 +++++++
 modules/mono/mono_gd/gd_mono_method.h   |  3 ++
 4 files changed, 89 insertions(+), 8 deletions(-)

diff --git a/modules/mono/csharp_script.cpp b/modules/mono/csharp_script.cpp
index 609cb1c013..fb45136575 100644
--- a/modules/mono/csharp_script.cpp
+++ b/modules/mono/csharp_script.cpp
@@ -1566,13 +1566,13 @@ bool CSharpScript::_update_signals() {
 
 		while (top && top != native) {
 			const Vector<GDMonoClass *> &delegates = top->get_all_delegates();
-			for (int i = delegates.size() - 1; i >= 0; i--) {
-				GDMonoClass *delegate = delegates[i];
+			for (int i = delegates.size() - 1; i >= 0; --i) {
+				Vector<Argument> parameters;
 
-				if (delegate->has_attribute(CACHED_CLASS(SignalAttribute))) {
-					StringName name = delegate->get_name();
+				GDMonoClass *delegate = delegates[i];
 
-					_signals[name] = Vector<StringName>(); // TODO Retrieve arguments
+				if (_get_signal(top, delegate, parameters)) {
+					_signals[delegate->get_name()] = parameters;
 				}
 			}
 
@@ -1585,6 +1585,41 @@ bool CSharpScript::_update_signals() {
 	return false;
 }
 
+bool CSharpScript::_get_signal(GDMonoClass *p_class, GDMonoClass *p_delegate, Vector<Argument> &params) {
+	if (p_delegate->has_attribute(CACHED_CLASS(SignalAttribute))) {
+		MonoType *raw_type = GDMonoClass::get_raw_type(p_delegate);
+
+		if (mono_type_get_type(raw_type) == MONO_TYPE_CLASS) {
+			// Arguments are accessibles as arguments of .Invoke method
+			GDMonoMethod *invoke = p_delegate->get_method("Invoke", -1);
+
+			Vector<StringName> names;
+			Vector<ManagedType> types;
+			invoke->get_parameter_names(names);
+			invoke->get_parameter_types(types);
+
+			if (names.size() == types.size()) {
+				for (int i = 0; i < names.size(); ++i) {
+					Argument arg;
+					arg.name = names[i];
+					arg.type = GDMonoMarshal::managed_to_variant_type(types[i]);
+
+					if (arg.type == Variant::NIL) {
+						ERR_PRINTS("Unknown type of signal parameter: " + arg.name + " in " + p_class->get_full_name());
+						return false;
+					}
+
+					params.push_back(arg);
+				}
+
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
 #ifdef TOOLS_ENABLED
 bool CSharpScript::_get_member_export(GDMonoClass *p_class, GDMonoClassMember *p_member, PropertyInfo &r_prop_info, bool &r_exported) {
 
@@ -1913,6 +1948,8 @@ ScriptInstance *CSharpScript::instance_create(Object *p_this) {
 #endif
 	}
 
+	update_signals();
+
 	if (native) {
 		String native_name = native->get_name();
 		if (!ClassDB::is_parent_class(p_this->get_class_name(), native_name)) {
@@ -2076,6 +2113,27 @@ void CSharpScript::update_exports() {
 #endif
 }
 
+bool CSharpScript::has_script_signal(const StringName &p_signal) const {
+	if (_signals.has(p_signal))
+		return true;
+
+	return false;
+}
+
+void CSharpScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
+	for (const Map<StringName, Vector<Argument> >::Element *E = _signals.front(); E; E = E->next()) {
+		MethodInfo mi;
+
+		mi.name = E->key();
+		for (int i = 0; i < E->get().size(); i++) {
+			PropertyInfo arg;
+			arg.name = E->get()[i].name;
+			mi.arguments.push_back(arg);
+		}
+		r_signals->push_back(mi);
+	}
+}
+
 void CSharpScript::update_signals() {
 #ifdef TOOLS_ENABLED
 	_update_signals();
diff --git a/modules/mono/csharp_script.h b/modules/mono/csharp_script.h
index 75ed770739..ffb1d2e0f4 100644
--- a/modules/mono/csharp_script.h
+++ b/modules/mono/csharp_script.h
@@ -85,13 +85,18 @@ class CSharpScript : public Script {
 
 	SelfList<CSharpScript> script_list;
 
+	struct Argument {
+		String name;
+		Variant::Type type;
+	};
+
 #ifdef TOOLS_ENABLED
 	List<PropertyInfo> exported_members_cache; // members_cache
 	Map<StringName, Variant> exported_members_defval_cache; // member_default_values_cache
 	Set<PlaceHolderScriptInstance *> placeholders;
 	bool source_changed_cache;
 	bool exports_invalidated;
-	Map<StringName, Vector<StringName> > _signals;
+	Map<StringName, Vector<Argument> > _signals;
 	bool signals_invalidated;
 
 	void _update_exports_values(Map<StringName, Variant> &values, List<PropertyInfo> &propnames);
@@ -107,6 +112,7 @@ class CSharpScript : public Script {
 	void _clear();
 
 	bool _update_signals();
+	bool _get_signal(GDMonoClass *p_class, GDMonoClass *p_delegate, Vector<Argument> &params);
 
 	bool _update_exports();
 #ifdef TOOLS_ENABLED
@@ -141,8 +147,8 @@ public:
 
 	virtual Error reload(bool p_keep_state = false);
 
-	/* TODO */ virtual bool has_script_signal(const StringName &p_signal) const { return false; }
-	/* TODO */ virtual void get_script_signal_list(List<MethodInfo> *r_signals) const {}
+	virtual bool has_script_signal(const StringName &p_signal) const;
+	virtual void get_script_signal_list(List<MethodInfo> *r_signals) const;
 	virtual void update_signals();
 
 	/* TODO */ virtual bool get_property_default_value(const StringName &p_property, Variant &r_value) const;
diff --git a/modules/mono/mono_gd/gd_mono_method.cpp b/modules/mono/mono_gd/gd_mono_method.cpp
index 1f8e9a1926..df0985f6ac 100644
--- a/modules/mono/mono_gd/gd_mono_method.cpp
+++ b/modules/mono/mono_gd/gd_mono_method.cpp
@@ -229,6 +229,20 @@ String GDMonoMethod::get_signature_desc(bool p_namespaces) const {
 	return res;
 }
 
+void GDMonoMethod::get_parameter_names(Vector<StringName> &names) const {
+	const char *_names[params_count];
+	mono_method_get_param_names(mono_method, _names);
+	for (int i = 0; i < params_count; ++i) {
+		names.push_back(StringName(_names[i]));
+	}
+}
+
+void GDMonoMethod::get_parameter_types(Vector<ManagedType> &types) const {
+	for (int i = 0; i < param_types.size(); ++i) {
+		types.push_back(param_types[i]);
+	}
+}
+
 GDMonoMethod::GDMonoMethod(StringName p_name, MonoMethod *p_method) {
 	name = p_name;
 
diff --git a/modules/mono/mono_gd/gd_mono_method.h b/modules/mono/mono_gd/gd_mono_method.h
index 14df8dcfb4..a173af83f4 100644
--- a/modules/mono/mono_gd/gd_mono_method.h
+++ b/modules/mono/mono_gd/gd_mono_method.h
@@ -80,6 +80,9 @@ public:
 	String get_ret_type_full_name() const;
 	String get_signature_desc(bool p_namespaces = false) const;
 
+	void get_parameter_names(Vector<StringName> &names) const;
+	void get_parameter_types(Vector<ManagedType> &types) const;
+
 	GDMonoMethod(StringName p_name, MonoMethod *p_method);
 	~GDMonoMethod();
 };
-- 
cgit v1.2.3