void gdk_superwin_destroy(GtkObject *object) { GdkSuperWin *superwin = NULL; g_return_if_fail(object != NULL); g_return_if_fail(GTK_IS_OBJECT(object)); g_return_if_fail(GTK_OBJECT_CONSTRUCTED(object)); g_return_if_fail(GDK_IS_SUPERWIN(object)); superwin = GDK_SUPERWIN(object); gdk_window_remove_filter(superwin->shell_window, gdk_superwin_shell_filter, superwin); gdk_window_remove_filter(superwin->bin_window, gdk_superwin_bin_filter, superwin); gdk_window_destroy(superwin->bin_window); gdk_window_destroy(superwin->shell_window); if (superwin->translate_queue) { GSList *tmp_list = superwin->translate_queue; while (tmp_list) { g_free(tmp_list->data); tmp_list = tmp_list->next; } g_slist_free(superwin->translate_queue); } }
int clip_GTK_SIGNALEMIT(ClipMachine *cm) { C_widget *cwid = _fetch_cw_arg(cm); SignalTable *sig_table = NULL; int ret=0; CHECKCWID(cwid,GTK_IS_OBJECT); CHECKARG2(2,CHARACTER_t,NUMERIC_t); if (_clip_parinfo(cm,2) == CHARACTER_t) sig_table = _sig_table_by_name(cwid, _clip_parc(cm,2)); else sig_table = _sig_table_by_id(cwid, _clip_parni(cm,2)); if (sig_table && sig_table->emitsigfunction) { if (cwid && cwid->widget && GTK_IS_OBJECT(cwid->widget)) ret = sig_table->emitsigfunction(cwid,sig_table->signame); //int sigfound = gtk_signal_lookup(signame, GTK_WIDGET_TYPE(cwid->widget)); } _clip_retl(cm,sig_table && sig_table->sigfunction); return ret; err: return 1; }
void gtk_signal_emit_stop_by_name (GtkObject *object, const gchar *name) { g_return_if_fail (GTK_IS_OBJECT (object)); g_signal_stop_emission (object, g_signal_lookup (name, G_OBJECT_TYPE (object)), 0); }
void gtk_signal_emitv_by_name (GtkObject *object, const gchar *name, GtkArg *args) { g_return_if_fail (GTK_IS_OBJECT (object)); gtk_signal_emitv (object, g_signal_lookup (name, GTK_OBJECT_TYPE (object)), args); }
/** * seahorse_context_destroy: * @sctx: #SeahorseContext to destroy * * Emits the destroy signal for @sctx. **/ void seahorse_context_destroy (SeahorseContext *sctx) { g_return_if_fail (GTK_IS_OBJECT (sctx)); gtk_object_destroy (GTK_OBJECT (sctx)); if (sctx == app_context) app_context = NULL; }
AtkObject* gail_object_new (GObject *obj) { gpointer object; AtkObject *atk_object; g_return_val_if_fail (GTK_IS_OBJECT (obj), NULL); object = g_object_new (GAIL_TYPE_OBJECT, NULL); atk_object = ATK_OBJECT (object); atk_object_initialize (atk_object, obj); return atk_object; }
void gtk_signal_connect_object_while_alive (GtkObject *object, const gchar *name, GtkSignalFunc func, GtkObject *alive_object) { g_return_if_fail (GTK_IS_OBJECT (object)); g_signal_connect_closure_by_id (object, g_signal_lookup (name, G_OBJECT_TYPE (object)), 0, g_cclosure_new_object_swap (func, G_OBJECT (alive_object)), FALSE); }
void gtk_signal_emit (GtkObject *object, guint signal_id, ...) { va_list var_args; g_return_if_fail (GTK_IS_OBJECT (object)); va_start (var_args, signal_id); g_signal_emit_valist (G_OBJECT (object), signal_id, 0, var_args); va_end (var_args); }
void clean_exit(const char *msg, ...) { va_list args; if ((msg != NULL) && !(GTK_IS_OBJECT(msg))) { va_start(args, msg); fprintf(stderr, PACKAGE ": "); vfprintf(stderr, msg, args); va_end(args); fflush(stderr); } gtk_exit(0); }
void gtk_signal_emitv (GtkObject *object, guint signal_id, GtkArg *args) { GSignalQuery query; GValue params[SIGNAL_MAX_PARAMS + 1] = { { 0, }, }; GValue rvalue = { 0, }; guint i; g_return_if_fail (GTK_IS_OBJECT (object)); g_signal_query (signal_id, &query); g_return_if_fail (query.signal_id != 0); g_return_if_fail (g_type_is_a (GTK_OBJECT_TYPE (object), query.itype)); g_return_if_fail (query.n_params < SIGNAL_MAX_PARAMS); if (query.n_params > 0) g_return_if_fail (args != NULL); g_value_init (params + 0, GTK_OBJECT_TYPE (object)); g_value_set_object (params + 0, G_OBJECT (object)); for (i = 0; i < query.n_params; i++) { GValue *value = params + 1 + i; GtkArg *arg = args + i; g_value_init (value, arg->type & ~G_SIGNAL_TYPE_STATIC_SCOPE); if (!gtk_arg_static_to_value (arg, value)) { g_warning ("%s: failed to convert arg type `%s' to value type `%s'", G_STRLOC, g_type_name (arg->type & ~G_SIGNAL_TYPE_STATIC_SCOPE), g_type_name (G_VALUE_TYPE (value))); return; } } if (query.return_type != G_TYPE_NONE) g_value_init (&rvalue, query.return_type); g_signal_emitv (params, signal_id, 0, &rvalue); if (query.return_type != G_TYPE_NONE) { gtk_argloc_set_from_value (args + query.n_params, &rvalue, TRUE); g_value_unset (&rvalue); } for (i = 0; i < query.n_params; i++) g_value_unset (params + 1 + i); g_value_unset (params + 0); }
void gtk_signal_emit_by_name (GtkObject *object, const gchar *name, ...) { GSignalQuery query; va_list var_args; g_return_if_fail (GTK_IS_OBJECT (object)); g_return_if_fail (name != NULL); g_signal_query (g_signal_lookup (name, GTK_OBJECT_TYPE (object)), &query); g_return_if_fail (query.signal_id != 0); va_start (var_args, name); g_signal_emit_valist (G_OBJECT (object), query.signal_id, 0, var_args); va_end (var_args); }
void gtk_signal_connect_while_alive (GtkObject *object, const gchar *name, GtkSignalFunc func, gpointer func_data, GtkObject *alive_object) { GClosure *closure; g_return_if_fail (GTK_IS_OBJECT (object)); closure = g_cclosure_new (func, func_data, NULL); g_object_watch_closure (G_OBJECT (alive_object), closure); g_signal_connect_closure_by_id (object, g_signal_lookup (name, G_OBJECT_TYPE (object)), 0, closure, FALSE); }
gulong gtk_signal_connect_full (GtkObject *object, const gchar *name, GtkSignalFunc func, GtkCallbackMarshal unsupported, gpointer data, GtkDestroyNotify destroy_func, gint object_signal, gint after) { g_return_val_if_fail (GTK_IS_OBJECT (object), 0); g_return_val_if_fail (unsupported == NULL, 0); return g_signal_connect_closure_by_id (object, g_signal_lookup (name, G_OBJECT_TYPE (object)), 0, (object_signal ? g_cclosure_new_swap : g_cclosure_new) (func, data, (GClosureNotify) destroy_func), after); }
void gtk_signal_compat_matched (GtkObject *object, GtkSignalFunc func, gpointer data, GSignalMatchType match, guint action) { guint n_handlers; g_return_if_fail (GTK_IS_OBJECT (object)); switch (action) { case 0: n_handlers = g_signal_handlers_disconnect_matched (object, match, 0, 0, NULL, (gpointer) func, data); break; case 1: n_handlers = g_signal_handlers_block_matched (object, match, 0, 0, NULL, (gpointer) func, data); break; case 2: n_handlers = g_signal_handlers_unblock_matched (object, match, 0, 0, NULL, (gpointer) func, data); break; default: n_handlers = 0; break; } if (!n_handlers) g_warning ("unable to find signal handler for object(%s:%p) with func(%p) and data(%p)", G_OBJECT_TYPE_NAME (object), object, func, data); }
static void object_new(lua_State* L, gpointer ptr, gboolean constructor) { lua_pushliteral(L, "lgobObjectNew"); lua_rawget(L, LUA_REGISTRYINDEX); lua_pushlightuserdata(L, ptr); #if GLIB_MINOR_VERSION >= 10 lua_pushboolean(L, constructor); #else g_object_ref(ptr); if( GTK_IS_OBJECT(ptr) && GTK_OBJECT_FLOATING(ptr) ) { lua_pushboolean(L, FALSE); gtk_object_sink(ptr); } else { lua_pushboolean(L, constructor); } #endif lua_call(L, 2, 1); }
/* Trigger destruction of object in case the mainloop at level main_level is quit. */ int clip_GTK_QUITADDDESTROY(ClipMachine * cm) { guint main_level = INT_OPTION(cm,1,gtk_main_level()); C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2)); C_object *cobj; CHECKOPT(1,NUMERIC_t); CHECKARG2(2,MAP_t,NUMERIC_t); if (cwid->objtype == GTK_OBJ_WIDGET) { CHECKCWID(cwid, GTK_IS_OBJECT); gtk_quit_add_destroy(main_level, GTK_OBJECT(cwid->widget)); } if (cwid->objtype == GTK_OBJ_OBJECT) { cobj = (C_object*)cwid; CHECKCOBJ(cobj, GTK_IS_OBJECT(cobj->object)); gtk_quit_add_destroy(main_level, GTK_OBJECT(cobj->object)); } return 0; err: return 1; }
static int _object_signal_connect(ClipMachine *cm, gboolean after) { C_object *cobj = _fetch_co_arg(cm); SignalTable *sig_table = NULL; int ret=-1; CHECKCOBJ(cobj,GTK_IS_OBJECT(cobj->object)); CHECKARG2(2,CHARACTER_t,NUMERIC_t); CHECKARG2(3,PCODE_t,CCODE_t); if (_clip_parinfo(cm,2) == CHARACTER_t) { sig_table = _sig_table_by_name(cobj->type, _clip_parc(cm,2)); } else sig_table = _sig_table_by_id(cobj->type, _clip_parni(cm,2)); if (sig_table && sig_table->sigfunction) { GtkSignalFunc sfunc = sig_table->sigfunction; gchar *signame = sig_table->signame; long sid = sig_table->sigid; int sigfound = g_signal_lookup(signame, GTK_OBJECT_TYPE(cobj->object)); int extra_sigfound = _extra_signal_lookup(signame, GTK_OBJECT_TYPE(cobj->object)); C_signal *cs = 0; //printf ("object %s signame %s \n", cobj->type_name, signame); if (sigfound || extra_sigfound || sid < 1000) /* sid<1000 - event */ { if (!cobj->siglist) { cobj->siglist = NEW(C_signal); cs = cobj->siglist; } else { for (cs = cobj->siglist; cs && cs->next; cs = cs->next); cs->next = NEW(C_signal); cs = cs->next; } cs->co = cobj; cs->signame = sig_table->signame; cs->sigid = sig_table->sigid; _clip_mclone(cm, &cs->cfunc, _clip_spar(cm,3)); } if (sigfound) { if (after) { ret = g_signal_connect_after(GTK_OBJECT(cobj->object), signame,GSF(sfunc),cs); } else { ret = g_signal_connect(GTK_OBJECT(cobj->object), signame,GSF(sfunc),cs); } } } _clip_retni(cm,ret); return 0; err: _clip_retni(cm,ret); return 1; }