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;
}
