glib/
signal.rs

1// Copyright 2015, The Gtk-rs Project Developers.
2// See the COPYRIGHT file at the top-level directory of this distribution.
3// Licensed under the MIT license, see the LICENSE file or <http://opensource.org/licenses/MIT>
4
5//! `IMPL` Low level signal support.
6
7use glib_sys::{gboolean, gpointer};
8use gobject_sys::{self, GCallback};
9use libc::{c_char, c_ulong, c_void};
10use object::ObjectType;
11use std::mem;
12use translate::{from_glib, FromGlib, ToGlib, ToGlibPtr};
13
14/// The id of a signal that is returned by `connect`.
15#[derive(Debug, Eq, PartialEq)]
16pub struct SignalHandlerId(c_ulong);
17
18impl ToGlib for SignalHandlerId {
19    type GlibType = c_ulong;
20
21    #[inline]
22    fn to_glib(&self) -> c_ulong {
23        self.0
24    }
25}
26
27impl FromGlib<c_ulong> for SignalHandlerId {
28    #[inline]
29    fn from_glib(val: c_ulong) -> SignalHandlerId {
30        assert_ne!(val, 0);
31        SignalHandlerId(val)
32    }
33}
34
35/// Whether to propagate the signal to the default handler.
36///
37/// Don't inhibit default handlers without a reason, they're usually helpful.
38#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
39pub struct Inhibit(pub bool);
40
41#[doc(hidden)]
42impl ToGlib for Inhibit {
43    type GlibType = gboolean;
44
45    #[inline]
46    fn to_glib(&self) -> gboolean {
47        self.0.to_glib()
48    }
49}
50
51pub unsafe fn connect_raw<F>(
52    receiver: *mut gobject_sys::GObject,
53    signal_name: *const c_char,
54    trampoline: GCallback,
55    closure: *mut F,
56) -> SignalHandlerId {
57    unsafe extern "C" fn destroy_closure<F>(ptr: *mut c_void, _: *mut gobject_sys::GClosure) {
58        // destroy
59        Box::<F>::from_raw(ptr as *mut _);
60    }
61    assert_eq!(mem::size_of::<*mut F>(), mem::size_of::<gpointer>());
62    assert!(trampoline.is_some());
63    let handle = gobject_sys::g_signal_connect_data(
64        receiver,
65        signal_name,
66        trampoline,
67        closure as *mut _,
68        Some(destroy_closure::<F>),
69        0,
70    );
71    assert!(handle > 0);
72    from_glib(handle)
73}
74
75pub fn signal_handler_block<T: ObjectType>(instance: &T, handler_id: &SignalHandlerId) {
76    unsafe {
77        gobject_sys::g_signal_handler_block(
78            instance.as_object_ref().to_glib_none().0,
79            handler_id.to_glib(),
80        );
81    }
82}
83
84pub fn signal_handler_unblock<T: ObjectType>(instance: &T, handler_id: &SignalHandlerId) {
85    unsafe {
86        gobject_sys::g_signal_handler_unblock(
87            instance.as_object_ref().to_glib_none().0,
88            handler_id.to_glib(),
89        );
90    }
91}
92
93#[allow(clippy::needless_pass_by_value)]
94pub fn signal_handler_disconnect<T: ObjectType>(instance: &T, handler_id: SignalHandlerId) {
95    unsafe {
96        gobject_sys::g_signal_handler_disconnect(
97            instance.as_object_ref().to_glib_none().0,
98            handler_id.to_glib(),
99        );
100    }
101}
102
103pub fn signal_stop_emission_by_name<T: ObjectType>(instance: &T, signal_name: &str) {
104    unsafe {
105        gobject_sys::g_signal_stop_emission_by_name(
106            instance.as_object_ref().to_glib_none().0,
107            signal_name.to_glib_none().0,
108        );
109    }
110}