Implement remaining event callbacks

Implements:
rig_set_dcd_callback(), rig_set_freq_callback(), rig_set_mode_callback(),
rig_pltune_callback(), rig_set_ptt_callback(), rig_set_spectrum_callback(),
rig_set_vfo_callback()

bindings/python/test_Hamlib_Rig_class.py

@@ -76,6 +76,7 @@ class TestClass:
 'set_conf',
 'set_ctcss_sql',
 'set_ctcss_tone',
+'set_dcd_callback',
 'set_dcs_code',
 'set_dcs_sql',
 'set_ext_func',
@@ -87,12 +88,16 @@ class TestClass:
 'set_level',
 'set_mem',
 'set_mode',
+'set_mode_callback',
 'set_parm',
+'set_pltune_callback',
 'set_powerstat',
 'set_ptt',
+'set_ptt_callback',
 'set_rit',
 'set_rptr_offs',
 'set_rptr_shift',
+'set_spectrum_callback',
 'set_split_freq',
 'set_split_freq_mode',
 'set_split_mode',
@@ -100,6 +105,7 @@ class TestClass:
 'set_trn',
 'set_ts',
 'set_vfo',
+'set_vfo_callback',
 'set_vfo_opt',
 'set_xit',
 'token_lookup',

bindings/python/test_rig.py

@@ -137,6 +137,70 @@ class TestClass:
         assert rig.set_freq(Hamlib.RIG_VFO_CURR, 144210000) is None
         # TODO assert that freq_callback() is called once
 
+        # Mode event callback
+        def mode_callback(vfo, mode, pbwidth, arg):
+            assert (1, 32, 5000, 2345678901) == (vfo, mode, pbwidth, arg)
+
+        # FIXME should use a Hamlib.RIG_PASSBAND_* constant but they aren't available in the bindings
+        RIG_PASSBAND_NOCHANGE = -1
+        assert rig.set_mode_callback(mode_callback, 2345678901) is None
+        assert rig.set_mode(Hamlib.RIG_MODE_FM, 5000) is None
+        # TODO assert that mode_callback() is called once
+        assert rig.set_mode_callback(None) is None
+        assert rig.set_mode(Hamlib.RIG_MODE_FM, 15000) is None
+        # TODO assert that mode_callback() is called once
+
+        # VFO event callback
+        def vfo_callback(vfo, arg):
+            assert (1, 3456789012) == (vfo, arg)
+
+        assert rig.set_vfo(Hamlib.RIG_VFO_B) is None
+        assert rig.set_vfo_callback(vfo_callback, 3456789012) is None
+        assert rig.set_vfo(Hamlib.RIG_VFO_A) is None
+        # TODO assert that vfo_callback() is called once
+        assert rig.set_vfo_callback(None) is None
+        assert rig.set_vfo(Hamlib.RIG_VFO_CURR) is None
+        # TODO assert that vfo_callback() is called once
+
+        # PTT event callback
+        def ptt_callback(vfo, ptt, arg):
+            print("ptt_callback", vfo, ptt, arg)
+            assert (1, 5000, 4567890123) == (vfo, arg)
+
+        assert rig.set_ptt_callback(ptt_callback, 4567890123) is None
+        assert rig.set_ptt(Hamlib.RIG_VFO_CURR, Hamlib.RIG_PTT_ON) is None
+        # TODO assert that ptt_callback() is called once
+        assert rig.set_ptt_callback(None) is None
+        assert rig.set_ptt(Hamlib.RIG_VFO_CURR, Hamlib.RIG_PTT_OFF) is None
+        # TODO assert that ptt_callback() is called once
+
+        # DCD event callback
+        def dcd_callback(vfo, ptt, arg):
+            print("dcd_callback", vfo, dcd, arg)
+            assert (1, 5000, 2345678901) == (vfo, arg)
+
+        assert rig.set_dcd_callback(dcd_callback, 5678901234) is None
+        # TODO simulate dcd events in dummy.c
+        assert rig.set_dcd_callback(None) is None
+
+        # PLtune event callback
+        def pltune_callback(vfo, ptt, arg):
+            print("pltune_callback", vfo, ptt, arg)
+            assert (1, 5000, 2345678901) == (vfo, arg)
+
+        assert rig.set_pltune_callback(pltune_callback, 6789012345) is None
+        # TODO simulate pltune events in dummy.c
+        assert rig.set_pltune_callback(None) is None
+
+        # spectrum event callback
+        def spectrum_callback(vfo, ptt, arg):
+            print("spectrum_callback", vfo, ptt, arg)
+            assert (1, 5000, 2345678901) == (vfo, arg)
+
+        assert rig.set_spectrum_callback(spectrum_callback, 7890123456) is None
+        # TODO simulate spectrum events in dummy.c
+        assert rig.set_spectrum_callback(None) is None
+
 
     @pytest.mark.skipif('config.getoption("model") != Hamlib.RIG_MODEL_DUMMY')
     def test_misc(self, model):

bindings/rig.swg

@@ -65,7 +65,7 @@ typedef struct Rig {
 		PyObject *ptt_arg;        /*!< PTT change argument */
 		PyObject *dcd_event;      /*!< DCD change event */
 		PyObject *dcd_arg;        /*!< DCD change argument */
-		PyObject *pltune;         /*!< Pipeline tuning module freq/mode/width callback */
+		PyObject *pltune_event;   /*!< Pipeline tuning module freq/mode/width callback NOTE: the C struct doesn't have the _event suffix*/
 		PyObject *pltune_arg;     /*!< Pipeline tuning argument */
 		PyObject *spectrum_event; /*!< Spectrum line reception event */
 		PyObject *spectrum_arg;   /*!< Spectrum line reception argument */
@@ -95,6 +95,105 @@ int *rig_freq_cb_python(RIG *rig, vfo_t vfo, freq_t freq, rig_ptr_t arg)
 
     return RIG_OK;
 }
+
+int *rig_mode_cb_python(RIG *rig, vfo_t vfo, rmode_t rmode, pbwidth_t pbwidth, rig_ptr_t arg)
+{
+    Rig *self = arg;
+    PyObject *python_arguments;
+
+    python_arguments = PyTuple_Pack(4,
+                                    PyLong_FromLong(vfo),
+                                    PyLong_FromLong(rmode),
+                                    PyLong_FromLong(pbwidth),
+                                    self->python_callbacks.mode_arg
+                                    );
+
+    PyObject_CallObject(self->python_callbacks.mode_event, python_arguments);
+
+    Py_XDECREF(python_arguments);
+
+    return RIG_OK;
+}
+
+int *rig_vfo_cb_python(RIG *rig, vfo_t vfo, rig_ptr_t arg)
+{
+    Rig *self = arg;
+    PyObject *python_arguments;
+
+    python_arguments = PyTuple_Pack(1,
+                                    self->python_callbacks.vfo_arg
+                                    );
+
+    PyObject_CallObject(self->python_callbacks.vfo_event, python_arguments);
+
+    Py_XDECREF(python_arguments);
+
+    return RIG_OK;
+}
+
+int *rig_ptt_cb_python(RIG *rig, vfo_t vfo, ptt_t ptt, rig_ptr_t arg)
+{
+    Rig *self = arg;
+    PyObject *python_arguments;
+
+    python_arguments = PyTuple_Pack(1,
+                                    self->python_callbacks.ptt_arg
+                                    );
+
+    PyObject_CallObject(self->python_callbacks.ptt_event, python_arguments);
+
+    Py_XDECREF(python_arguments);
+
+    return RIG_OK;
+}
+
+int *rig_dcd_cb_python(RIG *rig, vfo_t vfo, dcd_t, rig_ptr_t arg)
+{
+    Rig *self = arg;
+    PyObject *python_arguments;
+
+    python_arguments = PyTuple_Pack(1,
+                                    self->python_callbacks.dcd_arg
+                                    );
+
+    PyObject_CallObject(self->python_callbacks.dcd_event, python_arguments);
+
+    Py_XDECREF(python_arguments);
+
+    return RIG_OK;
+}
+
+int *rig_pltune_cb_python(RIG *rig, vfo_t vfo, freq_t *freq, rmode_t *rmode, pbwidth_t *pbwidth, rig_ptr_t arg)
+{
+    Rig *self = arg;
+    PyObject *python_arguments;
+
+    python_arguments = PyTuple_Pack(1,
+                                    self->python_callbacks.pltune_arg
+                                    );
+
+    PyObject_CallObject(self->python_callbacks.pltune_event, python_arguments);
+
+    Py_XDECREF(python_arguments);
+
+    return RIG_OK;
+}
+
+int *rig_spectrum_cb_python(RIG *rig, struct rig_spectrum_line *rig_spectrum_line, rig_ptr_t arg)
+{
+    Rig *self = arg;
+    PyObject *python_arguments;
+
+    python_arguments = PyTuple_Pack(1,
+                                    self->python_callbacks.spectrum_arg
+                                    );
+
+    PyObject_CallObject(self->python_callbacks.spectrum_event, python_arguments);
+
+    Py_XDECREF(python_arguments);
+
+    return RIG_OK;
+}
 #endif
 %}
 
@@ -374,6 +473,7 @@ int *rig_freq_cb_python(RIG *rig, vfo_t vfo, freq_t freq, rig_ptr_t arg)
 		r->state = &r->rig->state;
 		r->do_exception = 0;	/* default is disabled */
 		r->error_status = RIG_OK;
+
 		return r;
 	}
 	~Rig () {
@@ -525,6 +625,12 @@ int *rig_freq_cb_python(RIG *rig, vfo_t vfo, freq_t freq, rig_ptr_t arg)
 	// Handling of event callbacks
 #ifdef SWIGPYTHON
 	RIG_SET_CALLBACK(freq)
+	RIG_SET_CALLBACK(mode)
+	RIG_SET_CALLBACK(vfo)
+	RIG_SET_CALLBACK(ptt)
+	RIG_SET_CALLBACK(dcd)
+	RIG_SET_CALLBACK(pltune)
+	RIG_SET_CALLBACK(spectrum)
 #endif
 
 	int mem_count(void) {

rigs/dummy/dummy.c

@@ -638,6 +638,12 @@ static int dummy_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     case RIG_VFO_C: priv->vfo_c.width = width; break;
     }
 
+    if (rig->callbacks.mode_event)
+    {
+        rig_debug(RIG_DEBUG_TRACE, "%s callbacks.mode_event(%p, %p)\n", __func__, rig->callbacks.mode_event, rig->callbacks.mode_arg);
+        rig->callbacks.mode_event(rig, vfo, mode, width, rig->callbacks.mode_arg);
+    }
+
     RETURNFUNC(RIG_OK);
 }
 
@@ -737,6 +743,12 @@ static int dummy_set_vfo(RIG *rig, vfo_t vfo)
         RETURNFUNC(-RIG_EINVAL);
     }
 
+    if (rig->callbacks.vfo_event)
+    {
+        rig_debug(RIG_DEBUG_TRACE, "%s callbacks.vfo_event(%p, %p)\n", __func__, rig->callbacks.vfo_event, rig->callbacks.vfo_arg);
+        rig->callbacks.vfo_event(rig, vfo, rig->callbacks.vfo_arg);
+    }
+
     priv->last_vfo = priv->curr_vfo;
     priv->curr_vfo = vfo;
     STATE(rig)->current_vfo = vfo;
@@ -762,6 +774,12 @@ static int dummy_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
     struct dummy_priv_data *priv = (struct dummy_priv_data *)STATE(rig)->priv;
 
     ENTERFUNC;
+    if (rig->callbacks.ptt_event)
+    {
+        rig_debug(RIG_DEBUG_TRACE, "%s callbacks.ptt_event(%p, %p)\n", __func__, rig->callbacks.ptt_event, rig->callbacks.ptt_arg);
+        rig->callbacks.ptt_event(rig, vfo, ptt, rig->callbacks.ptt_arg);
+    }
+
     priv->ptt = ptt;
 
     RETURNFUNC(RIG_OK);