forked from AuroraMiddleware/gtk
33447a3856
Mon Dec 7 03:08:39 1998 Tim Janik <timj@gtk.org>
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c: reverted marius change to expose the type systems
internal type info data to the user. if such functionality is required
we should provide wrapped accessors, ala gtk_signal_query().
* gtk/gtksignal.c (gtk_signal_connect_by_type): reverted marius change,
since it destroys the possibility to implement automatic marshaller
lookups some day, and it also disables third party code's ability to
connect to any signal. also the GtkTypeInfo structures are dynamically
allocated memory portions, so only the type system is really allowed
to access that stuff.
Mon Dec 7 01:32:18 1998 Tim Janik <timj@gtk.org>
* gtk/gtkfilesel.c (gtk_file_selection_key_press): always intercept the
Tab key on the entry. the focus shouldn't get lost even if completion
is attempted from an empty entry, since an empty entry string does
indeed have a valid completion meaning (complete all).
(gtk_file_selection_init): cast the gchar array parameter in calls to
gtk_clist_new_with_titles() to quit compiler warnings.
(check_dir): the no_stat_dirs struct must not be const, since we do
indeed modify its contents.
* gtk/testgtk.c (event_watcher): adapted prototype to fit new emission
hook semantics.
* gtk/gtksignal.h:
* gtk/gtksignal.c:
changed emission allocation, so we don't use a doubly linked list
but link ourselfs (singly linked).
changed emission hooks, they get the emision parameters passed as
well now and are emitted during the actuall signal emission (after
the RUN_FIRST class method, but prior to RUN_FIRST handlers).
the existing restrictions do still apply to signal emission hooks,
i.e. an emission may not be stopped or restarted from an emission hook.
due to possibly huge perfomance impacts, frequent use of emision hooks
is also not recommended.
(gtk_signal_next_and_invalidate): added an
assertments which explicits what the code assumes anyways: a
maximum amount of 65535 signals.
* gtk/gtkcontainer.h: deprecated gtk_container_foreach_interp(),
gtk_container_foreach_full() should be used instead.
* gtk/gtkmain.h:
deprecated gtk_timeout_add_interp and gtk_idle_add_interp, since
we provide _full variants.
* gtk/gtksignal.h: deprecated gtk_signal_connect_interp(), we provide
gtk_signal_connect_full() for long enough now.
202 lines
7.0 KiB
C
202 lines
7.0 KiB
C
/* GTK - The GIMP Toolkit
|
|
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
#ifndef __GTK_SIGNAL_H__
|
|
#define __GTK_SIGNAL_H__
|
|
|
|
|
|
#include <gdk/gdk.h>
|
|
#include <gtk/gtkenums.h>
|
|
#include <gtk/gtkobject.h>
|
|
#include <gtk/gtkmarshal.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif /* __cplusplus */
|
|
|
|
|
|
#define GTK_SIGNAL_OFFSET(struct, field) (GTK_STRUCT_OFFSET (struct, field))
|
|
|
|
|
|
typedef void (*GtkSignalMarshal) (GtkObject *object,
|
|
gpointer data,
|
|
guint nparams,
|
|
GtkArg *args,
|
|
GtkType *arg_types,
|
|
GtkType return_type);
|
|
typedef void (*GtkSignalDestroy) (gpointer data);
|
|
typedef gboolean (*GtkEmissionHook) (GtkObject *object,
|
|
guint signal_id,
|
|
guint n_params,
|
|
GtkArg *params,
|
|
gpointer data);
|
|
|
|
|
|
typedef struct _GtkSignalQuery GtkSignalQuery;
|
|
|
|
struct _GtkSignalQuery
|
|
{
|
|
GtkType object_type;
|
|
guint signal_id;
|
|
const gchar *signal_name;
|
|
guint is_user_signal : 1;
|
|
GtkSignalRunType signal_flags;
|
|
GtkType return_val;
|
|
guint nparams;
|
|
const GtkType *params;
|
|
};
|
|
|
|
void gtk_signal_init (void);
|
|
guint gtk_signal_new (const gchar *name,
|
|
GtkSignalRunType signal_flags,
|
|
GtkType object_type,
|
|
guint function_offset,
|
|
GtkSignalMarshaller marshaller,
|
|
GtkType return_val,
|
|
guint nparams,
|
|
...);
|
|
guint gtk_signal_newv (const gchar *name,
|
|
GtkSignalRunType signal_flags,
|
|
GtkType object_type,
|
|
guint function_offset,
|
|
GtkSignalMarshaller marshaller,
|
|
GtkType return_val,
|
|
guint nparams,
|
|
GtkType *params);
|
|
guint gtk_signal_lookup (const gchar *name,
|
|
GtkType object_type);
|
|
gchar* gtk_signal_name (guint signal_id);
|
|
void gtk_signal_emit (GtkObject *object,
|
|
guint signal_id,
|
|
...);
|
|
void gtk_signal_emit_by_name (GtkObject *object,
|
|
const gchar *name,
|
|
...);
|
|
void gtk_signal_emitv (GtkObject *object,
|
|
guint signal_id,
|
|
GtkArg *params);
|
|
void gtk_signal_emitv_by_name (GtkObject *object,
|
|
const gchar *name,
|
|
GtkArg *params);
|
|
guint gtk_signal_n_emissions (GtkObject *object,
|
|
guint signal_id);
|
|
guint gtk_signal_n_emissions_by_name (GtkObject *object,
|
|
const gchar *name);
|
|
void gtk_signal_emit_stop (GtkObject *object,
|
|
guint signal_id);
|
|
void gtk_signal_emit_stop_by_name (GtkObject *object,
|
|
const gchar *name);
|
|
guint gtk_signal_connect (GtkObject *object,
|
|
const gchar *name,
|
|
GtkSignalFunc func,
|
|
gpointer func_data);
|
|
guint gtk_signal_connect_after (GtkObject *object,
|
|
const gchar *name,
|
|
GtkSignalFunc func,
|
|
gpointer func_data);
|
|
guint gtk_signal_connect_object (GtkObject *object,
|
|
const gchar *name,
|
|
GtkSignalFunc func,
|
|
GtkObject *slot_object);
|
|
guint gtk_signal_connect_object_after (GtkObject *object,
|
|
const gchar *name,
|
|
GtkSignalFunc func,
|
|
GtkObject *slot_object);
|
|
guint gtk_signal_connect_full (GtkObject *object,
|
|
const gchar *name,
|
|
GtkSignalFunc func,
|
|
GtkCallbackMarshal marshal,
|
|
gpointer data,
|
|
GtkDestroyNotify destroy_func,
|
|
gint object_signal,
|
|
gint after);
|
|
|
|
void gtk_signal_connect_object_while_alive (GtkObject *object,
|
|
const gchar *signal,
|
|
GtkSignalFunc func,
|
|
GtkObject *alive_object);
|
|
void gtk_signal_connect_while_alive (GtkObject *object,
|
|
const gchar *signal,
|
|
GtkSignalFunc func,
|
|
gpointer func_data,
|
|
GtkObject *alive_object);
|
|
|
|
void gtk_signal_disconnect (GtkObject *object,
|
|
guint handler_id);
|
|
void gtk_signal_disconnect_by_func (GtkObject *object,
|
|
GtkSignalFunc func,
|
|
gpointer data);
|
|
void gtk_signal_disconnect_by_data (GtkObject *object,
|
|
gpointer data);
|
|
void gtk_signal_handler_block (GtkObject *object,
|
|
guint handler_id);
|
|
void gtk_signal_handler_block_by_func (GtkObject *object,
|
|
GtkSignalFunc func,
|
|
gpointer data);
|
|
void gtk_signal_handler_block_by_data (GtkObject *object,
|
|
gpointer data);
|
|
void gtk_signal_handler_unblock (GtkObject *object,
|
|
guint handler_id);
|
|
void gtk_signal_handler_unblock_by_func (GtkObject *object,
|
|
GtkSignalFunc func,
|
|
gpointer data);
|
|
void gtk_signal_handler_unblock_by_data (GtkObject *object,
|
|
gpointer data);
|
|
guint gtk_signal_handler_pending (GtkObject *object,
|
|
guint signal_id,
|
|
gboolean may_be_blocked);
|
|
guint gtk_signal_handler_pending_by_func (GtkObject *object,
|
|
guint signal_id,
|
|
gboolean may_be_blocked,
|
|
GtkSignalFunc func,
|
|
gpointer data);
|
|
void gtk_signal_handlers_destroy (GtkObject *object);
|
|
guint gtk_signal_add_emission_hook (guint signal_id,
|
|
GtkEmissionHook hook_func,
|
|
gpointer data);
|
|
guint gtk_signal_add_emission_hook_full (guint signal_id,
|
|
GtkEmissionHook hook_func,
|
|
gpointer data,
|
|
GDestroyNotify destroy);
|
|
void gtk_signal_remove_emission_hook (guint signal_id,
|
|
guint hook_id);
|
|
|
|
void gtk_signal_set_funcs (GtkSignalMarshal marshal_func,
|
|
GtkSignalDestroy destroy_func);
|
|
|
|
/* Report internal information about a signal. The caller has the
|
|
* responsibility to invoke a supsequent g_free (returned_data); but
|
|
* must not modify data pointed to by the members of GtkSignalQuery
|
|
*/
|
|
GtkSignalQuery* gtk_signal_query (guint signal_id);
|
|
|
|
/* deprecated */
|
|
guint gtk_signal_connect_interp (GtkObject *object,
|
|
const gchar *name,
|
|
GtkCallbackMarshal func,
|
|
gpointer data,
|
|
GtkDestroyNotify destroy_func,
|
|
gint after);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* __cplusplus */
|
|
|
|
|
|
#endif /* __GTK_SIGNAL_H__ */
|