From 9cfc284b8cbed395b510be85665180cd8124e966 Mon Sep 17 00:00:00 2001
From: Matthias Koefferlein <matthias@klayout.de>
Date: Mon, 6 Mar 2023 23:04:55 +0100
Subject: [PATCH] Synonyms: connect/disconnect for events to get closer to
 PyQt5

---
 src/pya/pya/pyaHelpers.cc       |  2 ++
 src/rba/rba/rbaInternal.cc      |  4 +++
 testdata/python/basic.py        | 47 ++++++++++++++++++++++++++++++++-
 testdata/ruby/basic_testcore.rb | 46 +++++++++++++++++++++++++++++++-
 4 files changed, 97 insertions(+), 2 deletions(-)

diff --git a/src/pya/pya/pyaHelpers.cc b/src/pya/pya/pyaHelpers.cc
index 0c350035a..fc68b7d2d 100644
--- a/src/pya/pya/pyaHelpers.cc
+++ b/src/pya/pya/pyaHelpers.cc
@@ -627,7 +627,9 @@ PYASignal::make_class (PyObject *module)
 
   static PyMethodDef signal_methods[] = {
       {"add", (PyCFunction) &pya_signal_add, METH_VARARGS, "internal signal proxy object: += operator" },
+      {"connect", (PyCFunction) &pya_signal_add, METH_VARARGS, "synonym to 'add' or '+='" },
       {"remove", (PyCFunction) &pya_signal_remove, METH_VARARGS, "internal signal proxy object: -= operator" },
+      {"disconnect", (PyCFunction) &pya_signal_remove, METH_VARARGS, "synonym to 'remove' or '-='" },
       {"set", (PyCFunction) &pya_signal_set, METH_VARARGS, "internal signal proxy object: assignment" },
       {"clear", (PyCFunction) &pya_signal_clear, METH_NOARGS, "internal signal proxy object: clears all receivers" },
       {NULL,  NULL},
diff --git a/src/rba/rba/rbaInternal.cc b/src/rba/rba/rbaInternal.cc
index e751c83c5..6f51b83b2 100644
--- a/src/rba/rba/rbaInternal.cc
+++ b/src/rba/rba/rbaInternal.cc
@@ -811,7 +811,11 @@ SignalHandler::define_class (VALUE module, const char *name)
   rb_define_method (klass, "set", (ruby_func) &SignalHandler::static_assign, 1);
   rb_define_method (klass, "clear", (ruby_func) &SignalHandler::static_clear, 0);
   rb_define_method (klass, "+", (ruby_func) &SignalHandler::static_add, 1);
+  rb_define_method (klass, "add", (ruby_func) &SignalHandler::static_add, 1);
+  rb_define_method (klass, "connect", (ruby_func) &SignalHandler::static_add, 1);
   rb_define_method (klass, "-", (ruby_func) &SignalHandler::static_remove, 1);
+  rb_define_method (klass, "remove", (ruby_func) &SignalHandler::static_remove, 1);
+  rb_define_method (klass, "disconnect", (ruby_func) &SignalHandler::static_remove, 1);
 }
 
 void SignalHandler::call (const gsi::MethodBase *meth, gsi::SerialArgs &args, gsi::SerialArgs &ret) const
diff --git a/testdata/python/basic.py b/testdata/python/basic.py
index 3c64efbb7..5b4ca230b 100644
--- a/testdata/python/basic.py
+++ b/testdata/python/basic.py
@@ -1400,10 +1400,55 @@ class BasicTest(unittest.TestCase):
     def f4():
       n[0] = n[0] + 2
 
+    n[0] = 0
     e.e0(f4)
     e.s1()
-    self.assertEqual( 4, n[0] )
+    self.assertEqual( 2, n[0] )
 
+    # remove event handler -> no events triggered anymore
+    n[0] = 0
+    e.e0 -= f4
+    e.s1()
+    self.assertEqual( 0, n[0] )
+
+    # adding again will re-activate it
+    e.e0 += f4
+    n[0] = 0
+    e.s1()
+    self.assertEqual( 2, n[0] )
+
+    # two events at once
+    def f5():
+      n[0] = n[0] + 10
+    n[0] = 0
+    e.e0 += f5
+    e.s1()
+    self.assertEqual( 12, n[0] )
+
+    # clearing events
+    e.e0.clear()
+    e.s1()
+    n[0] = 0
+    self.assertEqual( 0, n[0] )
+
+    # synonyms: add, connect
+    e.e0.add(f4)
+    e.e0.connect(f5)
+    n[0] = 0
+    e.s1()
+    self.assertEqual( 12, n[0] )
+
+    # synonyms: remove, disconnect
+    e.e0.disconnect(f4)
+    n[0] = 0
+    e.s1()
+    self.assertEqual( 10, n[0] )
+    n[0] = 0
+    e.e0.remove(f5)
+    e.s1()
+    self.assertEqual( 0, n[0] )
+
+    # another signal
     e.s2()
     self.assertEqual( 100, n[1] )
     e.m = 1
diff --git a/testdata/ruby/basic_testcore.rb b/testdata/ruby/basic_testcore.rb
index 87f2f1e4b..b75631c7c 100644
--- a/testdata/ruby/basic_testcore.rb
+++ b/testdata/ruby/basic_testcore.rb
@@ -1325,11 +1325,55 @@ class Basic_TestClass < TestBase
     assert_equal( 2, n0 )
 
     # using lambda
+    n0 = 0
     p = lambda { n0 += 2 }
     e.e0(&p)
     e.s1
-    assert_equal( 4, n0 )
+    assert_equal( 2, n0 )
 
+    # remove event handler -> no events triggered anymore
+    n0 = 0
+    e.e0 -= p
+    e.s1
+    assert_equal( 0, n0 )
+
+    # adding again will re-activate it
+    e.e0 += p
+    n0 = 0
+    e.s1
+    assert_equal( 2, n0 )
+
+    # two events at once
+    pp = lambda { n0 += 10 }
+    n0 = 0
+    e.e0 += pp
+    e.s1
+    assert_equal( 12, n0 )
+
+    # clearing events
+    e.e0.clear
+    e.s1
+    n0 = 0
+    assert_equal( 0, n0 )
+
+    # synonyms: add, connect
+    e.e0.add(p)
+    e.e0.connect(pp)
+    n0 = 0
+    e.s1
+    assert_equal( 12, n0 )
+
+    # synonyms: remove, disconnect
+    e.e0.disconnect(p)
+    n0 = 0
+    e.s1
+    assert_equal( 10, n0 )
+    n0 = 0
+    e.e0.remove(pp)
+    e.s1
+    assert_equal( 0, n0 )
+
+    # another signal
     e.s2
     assert_equal( 100, n1 )
     e.m = 1