void
gtk_type_set_varargs_type (GtkType foreign_type,
GtkType varargs_type)
{
g_return_if_fail (foreign_type == GTK_FUNDAMENTAL_TYPE (foreign_type));
g_return_if_fail (foreign_type > GTK_TYPE_FUNDAMENTAL_LAST);
if (!((varargs_type >= GTK_TYPE_STRUCTURED_FIRST &&
varargs_type <= GTK_TYPE_STRUCTURED_LAST) ||
(varargs_type >= GTK_TYPE_FLAT_FIRST &&
varargs_type <= GTK_TYPE_FLAT_LAST) ||
varargs_type == GTK_TYPE_NONE))
{
g_warning ("invalid varargs type `%s' for fundamental type `%s'",
gtk_type_name (varargs_type),
gtk_type_name (foreign_type));
return;
}
if (gtk_type_get_varargs_type (foreign_type))
{
g_warning ("varargs type is already registered for fundamental type `%s'",
gtk_type_name (foreign_type));
return;
}
n_vararg_types++;
vararg_types = g_realloc (vararg_types, sizeof (GtkTypeVarargType) * n_vararg_types);
vararg_types[n_vararg_types - 1].foreign_type = foreign_type;
vararg_types[n_vararg_types - 1].varargs_type = varargs_type;
}
GtkEnumValue*
gtk_type_enum_find_value (GtkType enum_type,
const gchar *value_name)
{
g_return_val_if_fail (value_name != NULL, NULL);
if (GTK_FUNDAMENTAL_TYPE (enum_type) == GTK_TYPE_ENUM ||
GTK_FUNDAMENTAL_TYPE (enum_type) == GTK_TYPE_FLAGS)
{
GtkEnumValue *vals;
vals = gtk_type_enum_get_values (enum_type);
if (vals)
while (vals->value_name)
{
if (strcmp (vals->value_name, value_name) == 0 ||
strcmp (vals->value_nick, value_name) == 0)
return vals;
vals++;
}
}
else
g_warning ("gtk_type_enum_find_value(): type `%s' is not derived from `GtkEnum' or `GtkFlags'",
gtk_type_name (enum_type));
return NULL;
}
long SvDefFlagsHash (GtkType type, SV *name) {
long val = 0;
GtkFlagValue * vals;
int i;
vals = gtk_type_flags_get_values(type);
if (!vals) {
warn("Invalid type for flags: %s", gtk_type_name(type));
return SvIV(name);
}
if (SvROK(name) && (SvTYPE(SvRV(name)) == SVt_PVAV)) {
AV * r = (AV*)SvRV(name);
for(i=0;i<=av_len(r);i++)
val |= SvEFValueLookup(vals, SvPV(*av_fetch(r, i, 0), PL_na), type);
} else if (SvROK(name) && (SvTYPE(SvRV(name)) == SVt_PVHV)) {
HV * r = (HV*)SvRV(name);
HE * he;
I32 len;
hv_iterinit(r);
while ((he=hv_iternext(r))) {
val |= SvEFValueLookup(vals, hv_iterkey(he, &len), type);
}
} else
val |= SvEFValueLookup(vals, SvPV(name, PL_na), type);
return val;
}
SV * newSVDefEnumHash (GtkType type, long value) {
GtkEnumValue * vals;
SV * result;
vals = gtk_type_enum_get_values(type);
if (!vals) {
warn("Invalid type for enum: %s", gtk_type_name(type));
return newSViv(value);
}
while (vals && vals->value_nick) {
if (vals->value == value) {
result = newSVpv(vals->value_nick, 0);
if (!pgtk_use_minus) {
char *s = SvPV(result, PL_na);
while (*s) {
if (*s == '-') *s = '_';
s++;
}
}
return result;
}
vals++;
}
/* Gtk/Gdk may get something wrong here, it's better to return undef
* croak("Invalid value %d for %s", value, gtk_type_name(type));*/
return newSVsv(&PL_sv_undef);
}
SV * newSVDefFlagsHash (GtkType type, long value) {
GtkFlagValue * vals;
SV * result;
char *s, *p;
vals = gtk_type_flags_get_values(type);
if (!vals) {
warn("Invalid type for flags: %s", gtk_type_name(type));
return newSViv(value);
}
if (!pgtk_use_array) {
HV * h = newHV();
result = newRV((SV*)h);
SvREFCNT_dec(h);
while(vals && vals->value_nick) {
if ((value & vals->value) == vals->value) {
if (pgtk_use_minus)
hv_store(h, vals->value_nick, strlen(vals->value_nick), newSViv(1), 0);
else {
p = s = g_strdup(vals->value_nick);
while (*s) {
if (*s == '-') *s = '_';
s++;
}
hv_store(h, p, strlen(p), newSViv(1), 0);
g_free(p);
}
value &= ~vals->value;
}
vals++;
}
} else {
AV * a = newAV();
result = newRV((SV*)a);
SvREFCNT_dec(a);
while(vals && vals->value_nick) {
if ((value & vals->value) == vals->value) {
if (pgtk_use_minus)
av_push(a, newSVpv(vals->value_nick, 0));
else {
p = s = g_strdup(vals->value_nick);
while (*s) {
if (*s == '-') *s = '_';
s++;
}
av_push(a, newSVpv(p, 0));
g_free(p);
}
value &= ~vals->value;
}
vals++;
}
}
/* check for unhandled bits in value ... */
return result;
}
long SvDefEnumHash (GtkType type, SV *name) {
long val = 0;
GtkEnumValue * vals;
vals = gtk_type_enum_get_values(type);
if (!vals) {
warn("Invalid type for enum: %s", gtk_type_name(type));
return SvIV(name);
}
return SvEFValueLookup(vals, SvPV(name, PL_na), type);
}
static inline gchar*
gtk_type_descriptive_name (GtkType type)
{
gchar *name;
name = gtk_type_name (type);
if (!name)
name = "(unknown)";
return name;
}
GtkEnumValue*
gtk_type_enum_get_values (GtkType enum_type)
{
if (GTK_FUNDAMENTAL_TYPE (enum_type) == GTK_TYPE_ENUM ||
GTK_FUNDAMENTAL_TYPE (enum_type) == GTK_TYPE_FLAGS)
{
GtkTypeNode *node;
LOOKUP_TYPE_NODE (node, enum_type);
if (node)
return (GtkEnumValue*) node->type_info.reserved_1;
}
g_warning ("gtk_type_enum_get_values(): type `%s' is not derived from `GtkEnum' or `GtkFlags'",
gtk_type_name (enum_type));
return NULL;
}
long SvEFValueLookup (GtkEnumValue * vals, char* name, GtkType type) {
GtkEnumValue *v;
dTHR;
if (!name)
croak("Need a value in lookup");
if (*name == '-')
name++;
v = vals;
while (v && v->value_nick) {
if (hystrEQ(name, v->value_nick))
return v->value;
v++;
}
{
SV * r;
char * endc=NULL;
long val;
/* last chanche: integer value... */
val = strtol(name, &endc, 0);
if (*name && endc && *endc == '\0')
return val;
v = vals;
r = sv_newmortal();
sv_catpv(r, "invalid ");
sv_catpv(r, gtk_type_name(type));
sv_catpv(r, " value ");
sv_catpv(r, name);
sv_catpv(r, ", expecting: ");
while (v && v->value_nick) {
sv_catpv(r, v->value_nick);
if (++v)
sv_catpv(r, ", ");
}
croak(SvPV(r, PL_na));
return 0;
}
}
static void
sp_knot_holder_debug (GtkObject *object, gpointer data)
{
g_print ("sp-knot-holder-debug: [type=%s] [data=%s]\n", gtk_type_name (GTK_OBJECT_TYPE(object)), (const gchar *)data);
}
/* String the names the type of the widget */
gchar *c_gtk_type_name (GtkWidget *op) {
return (gtk_type_name (GTK_OBJECT_TYPE (op)));
}
void ui_menu_create(GtkWidget *w, GtkAccelGroup *accel, const char *menu_name, ui_menu_entry_t *list)
{
static int level = 0;
unsigned int i, j;
ui_menu_cb_obj *obj = NULL;
level++;
#ifdef DEBUG_MENUS
printf("allocate new: %s\t(%p)\t%s\n",
gtk_type_name(GTK_WIDGET_TYPE(w)), w,
menu_name);
#endif
for (i = j = 0; list[i].string; i++) {
GtkWidget *new_item = NULL;
int do_right_justify = 0;
char name[256];
sprintf(name, "MenuItem%d", j); /* ugly... */
switch (*list[i].string)
{
case '-': /* line */
new_item = gtk_menu_item_new();
break;
case '*': /* toggle */
{
/* Add this item to the list of calls to perform to update the
menu status. */
char *label = make_menu_label(&list[i]);
if (list[i].callback)
{
checkmark_t *cmt;
new_item = gtk_check_menu_item_new_with_label(label + 1);
cmt = (checkmark_t *)lib_malloc(sizeof(checkmark_t));
cmt->name = lib_stralloc(list[i].string+1);
cmt->w = new_item;
cmt->cb = list[i].callback;
cmt->obj.value = (void*) list[i].callback_data;
cmt->obj.status = CB_NORMAL;
cmt->handlerid =
g_signal_connect(G_OBJECT(new_item),"activate",
G_CALLBACK(list[i].callback),
(gpointer) &(cmt->obj));
g_signal_connect(G_OBJECT(new_item), "destroy",
G_CALLBACK(delete_checkmark_cb),
(gpointer) cmt);
checkmark_list = g_list_prepend(checkmark_list, cmt);
obj = &cmt->obj;
}
else
new_item = gtk_menu_item_new_with_label(label + 1);
j++;
lib_free(label);
break;
}
case 0:
break;
default:
{
char *item, *itemp;
item = itemp = make_menu_label(&list[i]);
if (strncmp(item, "RJ", 2) == 0)
{
do_right_justify = 1;
item += 2;
}
new_item = gtk_menu_item_new_with_label(item);
if (list[i].callback) {
obj = (ui_menu_cb_obj*)lib_malloc(sizeof(ui_menu_cb_obj));
obj->value = (void*) list[i].callback_data;
g_signal_connect(G_OBJECT(new_item),"activate",
G_CALLBACK(list[i].callback),
(gpointer) obj);
}
lib_free(itemp);
j++;
}
}
if (new_item)
{
gtk_menu_shell_append(GTK_MENU_SHELL(w), new_item);
gtk_widget_show(new_item);
if (do_right_justify)
gtk_menu_item_set_right_justified(GTK_MENU_ITEM(new_item), TRUE);
#ifdef DEBUG_MENUS
printf("allocate new: %s\t(%p)\t%s\n",
gtk_type_name(GTK_WIDGET_TYPE(new_item)), new_item,
list[i].string);
#endif
}
if (list[i].sub_menu)
{
GtkWidget *sub;
if (new_item && *list[i].string != '-')
{
sub = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(new_item),sub);
}
else
{
sub = w;
}
ui_menu_create(sub, accel, list[i].string,
list[i].sub_menu);
}
else
{ /* no submenu */
if (accel && list[i].hotkey_keysym != KEYSYM_NONE
&& list[i].callback != NULL && new_item != NULL)
add_accelerator(new_item,
accel, list[i].hotkey_keysym,
list[i].hotkey_modifier);
}
}
level--;
}
static void
gv_tool_real_activate(GvTool *tool, GvViewArea *view)
{
GvToolClass *klass;
if (tool->view)
{
g_warning("gv_tool_activate(): tool %s is already active on a view",
gtk_type_name(GTK_OBJECT_TYPE(tool)));
return;
}
tool->view = view;
gtk_object_ref(GTK_OBJECT(view));
klass = (GvToolClass*)gtk_type_class(GTK_OBJECT_TYPE(tool));
/* This could be done through an indirect function call which
emits a tool signal. Probably better but more overhead... */
if (klass->draw)
{
gtk_signal_connect_object(GTK_OBJECT(view), "gldraw",
GTK_SIGNAL_FUNC(klass->draw),
GTK_OBJECT(tool));
}
if (klass->button_press)
{
gtk_signal_connect_object(GTK_OBJECT(view), "button-press-event",
GTK_SIGNAL_FUNC(klass->button_press),
GTK_OBJECT(tool));
}
if (klass->button_release)
{
gtk_signal_connect_object(GTK_OBJECT(view), "button-release-event",
GTK_SIGNAL_FUNC(klass->button_release),
GTK_OBJECT(tool));
}
if (klass->motion_notify)
{
gtk_signal_connect_object(GTK_OBJECT(view), "motion-notify-event",
GTK_SIGNAL_FUNC(klass->motion_notify),
GTK_OBJECT(tool));
}
if (klass->key_press)
{
gtk_signal_connect_object(GTK_OBJECT(view), "key-press-event",
GTK_SIGNAL_FUNC(klass->key_press),
GTK_OBJECT(tool));
}
if (klass->enter_notify)
{
gtk_signal_connect_object(GTK_OBJECT(view), "enter-notify-event",
GTK_SIGNAL_FUNC(klass->enter_notify),
GTK_OBJECT(tool));
}
if (klass->leave_notify)
{
gtk_signal_connect_object(GTK_OBJECT(view), "leave-notify-event",
GTK_SIGNAL_FUNC(klass->leave_notify),
GTK_OBJECT(tool));
}
/* Install cursor for this tool */
if (GTK_WIDGET_REALIZED(GTK_WIDGET(view)))
{
gdk_window_set_cursor(GTK_WIDGET(view)->window, tool->cursor);
}
}
