# Module GtkSignal

    module GtkSignal: sig .. end

Signals

    type id

    type 'a marshaller = 'a -> Gobject.Closure.argv -> unit

    type ('a, 'b) t = {

`` | `name : `string`;`
`` | `classe : `'a`;`
`` | `marshaller : `'b marshaller`;`

}

When writing marshallers, beware that the list omits the 0th argument of argv, which is the referent object

    type query = {

`` | `id : `int`;`
`` | `signal_name : `string`;`
`` | `itype : `string`;`
`` | `flags : `int`;`
`` | `return : `string`;`
`` | `params : `string array`;`

}

    val stop_emit : unit -> unit

Call `stop_emit ()` in a callback to prohibit further handling of the current signal invocation, by calling `emit_stop_by_name`. Be careful about where you use it, since the concept of current signal may be tricky.

    val connect : sgn:('a, 'b) t ->
           callback:'b -> ?after:bool -> 'a Gobject.obj -> id

You may use `stop_emit` inside the callback

    val connect_property : prop:('a, 'b) Gobject.property ->
           callback:('b -> unit) -> 'a Gobject.obj -> id

Connect to the "notify::foo" signal associated with a property. These are emitted each time the property "foo" is set (including when it is set to the same value).

    val user_handler : (exn -> unit) Stdlib.ref

A hook to allow changing the behaviour of exceptions in callbacks The default behaviour of printing the exception and ignoring it is obtained when `user_handler` is set to `Pervasives.raise`

    val safe_call : ?where:string -> ('a -> unit) -> 'a -> unit

Safe wrapper for function calls. Tries to handle exceptions with user_handler, and reports an error otherwise.

    val signal_new : string -> Gobject.g_type -> Gobject.signal_type list -> unit

    val list_ids : Gobject.g_type -> int array

    val query : int -> query

    val connect_by_name : 'a Gobject.obj ->
           name:string -> callback:Gobject.g_closure -> after:bool -> id

    val disconnect : 'a Gobject.obj -> id -> unit

    val emit_stop_by_name : 'a Gobject.obj -> name:string -> unit

Unsafe: use `stop_emit` instead.

    val handler_block : 'a Gobject.obj -> id -> unit

    val handler_unblock : 'a Gobject.obj -> id -> unit

##### Marshallers

Some marshaller functions, to build signals

    val marshal_unit : (unit -> unit) marshaller

    val marshal_int : (int -> unit) marshaller

    val marshal_string : (string -> unit) marshaller

    val marshal1 : 'a Gobject.data_conv -> string -> ('a -> unit) marshaller

    val marshal2 : 'a Gobject.data_conv ->
           'b Gobject.data_conv -> string -> ('a -> 'b -> unit) marshaller

    val marshal3 : 'a Gobject.data_conv ->
           'b Gobject.data_conv ->
           'c Gobject.data_conv ->
           string -> ('a -> 'b -> 'c -> unit) marshaller

    val marshal4 : 'a Gobject.data_conv ->
           'b Gobject.data_conv ->
           'c Gobject.data_conv ->
           'd Gobject.data_conv ->
           string -> ('a -> 'b -> 'c -> 'd -> unit) marshaller

    val marshal5 : 'a Gobject.data_conv ->
           'b Gobject.data_conv ->
           'c Gobject.data_conv ->
           'd Gobject.data_conv ->
           'e Gobject.data_conv ->
           string -> ('a -> 'b -> 'c -> 'd -> 'e -> unit) marshaller

    val marshal6 : 'a Gobject.data_conv ->
           'b Gobject.data_conv ->
           'c Gobject.data_conv ->
           'd Gobject.data_conv ->
           'e Gobject.data_conv ->
           'f Gobject.data_conv ->
           string -> ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> unit) marshaller

    val marshal0_ret : ret:'a Gobject.data_conv -> (unit -> 'a) marshaller

    val marshal1_ret : ret:'a Gobject.data_conv ->
           'b Gobject.data_conv -> string -> ('b -> 'a) marshaller

    val marshal2_ret : ret:'a Gobject.data_conv ->
           'b Gobject.data_conv ->
           'c Gobject.data_conv -> string -> ('b -> 'c -> 'a) marshaller

    val marshal3_ret : ret:'a Gobject.data_conv ->
           'b Gobject.data_conv ->
           'c Gobject.data_conv ->
           'd Gobject.data_conv -> string -> ('b -> 'c -> 'd -> 'a) marshaller

    val marshal4_ret : ret:'a Gobject.data_conv ->
           'b Gobject.data_conv ->
           'c Gobject.data_conv ->
           'd Gobject.data_conv ->
           'e Gobject.data_conv ->
           string -> ('b -> 'c -> 'd -> 'e -> 'a) marshaller

##### Emitter functions

    val emit : 'a Gobject.obj ->
           sgn:('a, 'b) t ->
           emitter:(cont:('c Gobject.data_set array -> 'd) -> 'b) ->
           conv:(Gobject.g_value -> 'd) -> 'b

    val emit_unit : 'a Gobject.obj -> sgn:('a, unit -> unit) t -> unit

    val emit_int : 'a Gobject.obj -> sgn:('a, int -> unit) t -> int -> unit

##### Default handler override

    val override_class_closure : ('a, 'b) t -> Gobject.g_type -> Gobject.g_closure -> unit

    val chain_from_overridden : Gobject.Closure.argv -> unit