gimp/plug-ins/imagemap/imap_object.c

1088 lines
25 KiB
C

/*
* This is a plug-in for GIMP.
*
* Generates clickable image maps.
*
* Copyright (C) 1998-2005 Maurits Rijk m.rijk@chello.nl
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#include "config.h"
#include <gtk/gtk.h>
#include "imap_commands.h"
#include "imap_default_dialog.h"
#include "imap_grid.h"
#include "imap_main.h"
#include "imap_object.h"
#include "imap_string.h"
typedef struct {
ObjectListCallbackFunc_t func;
gpointer data;
} ObjectListCB_t;
static ObjectList_t *_paste_buffer;
static gpointer
object_list_callback_add(ObjectListCallback_t *list,
ObjectListCallbackFunc_t func, gpointer data)
{
ObjectListCB_t *cb = g_new(ObjectListCB_t, 1);
cb->func = func;
cb->data = data;
list->list = g_list_append(list->list, cb);
return cb;
}
static void
object_list_callback_remove(ObjectListCallback_t *list, gpointer id)
{
list->list = g_list_remove(list->list, id);
}
static void
object_list_callback_call(ObjectListCallback_t *list, Object_t *obj)
{
GList *p;
for (p = list->list; p; p = p->next) {
ObjectListCB_t *cb = (ObjectListCB_t*) p->data;
cb->func(obj, cb->data);
}
}
gpointer
object_list_add_changed_cb(ObjectList_t *list, ObjectListCallbackFunc_t func,
gpointer data)
{
return object_list_callback_add(&list->changed_cb, func, data);
}
gpointer
object_list_add_update_cb(ObjectList_t *list, ObjectListCallbackFunc_t func,
gpointer data)
{
return object_list_callback_add(&list->update_cb, func, data);
}
gpointer
object_list_add_add_cb(ObjectList_t *list, ObjectListCallbackFunc_t func,
gpointer data)
{
return object_list_callback_add(&list->add_cb, func, data);
}
gpointer
object_list_add_remove_cb(ObjectList_t *list, ObjectListCallbackFunc_t func,
gpointer data)
{
return object_list_callback_add(&list->remove_cb, func, data);
}
gpointer
object_list_add_select_cb(ObjectList_t *list, ObjectListCallbackFunc_t func,
gpointer data)
{
return object_list_callback_add(&list->select_cb, func, data);
}
gpointer
object_list_add_move_cb(ObjectList_t *list, ObjectListCallbackFunc_t func,
gpointer data)
{
return object_list_callback_add(&list->move_cb, func, data);
}
gpointer
object_list_add_geometry_cb(ObjectList_t *list, ObjectListCallbackFunc_t func,
gpointer data)
{
return object_list_callback_add(&list->geometry_cb, func, data);
}
gpointer
paste_buffer_add_add_cb(ObjectListCallbackFunc_t func, gpointer data)
{
if (!_paste_buffer)
_paste_buffer = make_object_list();
return object_list_callback_add(&_paste_buffer->add_cb, func, data);
}
gpointer
paste_buffer_add_remove_cb(ObjectListCallbackFunc_t func, gpointer data)
{
if (!_paste_buffer)
_paste_buffer = make_object_list();
return object_list_callback_add(&_paste_buffer->remove_cb, func, data);
}
void
object_list_remove_add_cb(ObjectList_t *list, gpointer id)
{
object_list_callback_remove(&list->add_cb, id);
}
void
object_list_remove_select_cb(ObjectList_t *list, gpointer id)
{
object_list_callback_remove(&list->select_cb, id);
}
void
object_list_remove_remove_cb(ObjectList_t *list, gpointer id)
{
object_list_callback_remove(&list->remove_cb, id);
}
void
object_list_remove_move_cb(ObjectList_t *list, gpointer id)
{
object_list_callback_remove(&list->move_cb, id);
}
void
object_list_remove_geometry_cb(ObjectList_t *list, gpointer id)
{
object_list_callback_remove(&list->geometry_cb, id);
}
Object_t*
object_init(Object_t *obj, ObjectClass_t *class)
{
obj->class = class;
obj->refcount = 1;
obj->selected = FALSE;
obj->locked = FALSE;
obj->url = g_strdup ("");
obj->target = g_strdup ("");
obj->comment = g_strdup ("");
obj->accesskey = g_strdup ("");
obj->tabindex = g_strdup ("");
obj->mouse_over = g_strdup ("");
obj->mouse_out = g_strdup ("");
obj->focus = g_strdup ("");
obj->blur = g_strdup ("");
obj->click = g_strdup ("");
return obj;
}
static void
object_destruct(Object_t *obj)
{
if (obj->class->destruct)
obj->class->destruct(obj);
g_free (obj->url);
g_free (obj->target);
g_free (obj->comment);
g_free (obj->accesskey);
g_free (obj->tabindex);
g_free (obj->mouse_over);
g_free (obj->mouse_out);
g_free (obj->focus);
g_free (obj->blur);
g_free (obj->click);
g_free (obj);
}
Object_t*
object_ref(Object_t *obj)
{
obj->refcount++;
return obj;
}
void
object_unref(Object_t *obj)
{
if (!--obj->refcount)
object_destruct(obj);
}
Object_t*
object_clone (Object_t *obj)
{
Object_t *clone = obj->class->clone (obj);
clone->class = obj->class;
clone->refcount = 1;
clone->selected = obj->selected;
clone->locked = FALSE;
clone->url = g_strdup (obj->url);
clone->target = g_strdup (obj->target);
clone->comment = g_strdup (obj->comment);
clone->accesskey = g_strdup (obj->accesskey);
clone->tabindex = g_strdup (obj->tabindex);
clone->mouse_over = g_strdup (obj->mouse_over);
clone->mouse_out = g_strdup (obj->mouse_out);
clone->focus = g_strdup (obj->focus);
clone->blur = g_strdup (obj->blur);
clone->click = g_strdup (obj->click);
return clone;
}
static Object_t*
object_copy (Object_t *src, Object_t *des)
{
des->class = src->class;
des->selected = src->selected;
des->locked = FALSE;
g_strreplace (&des->url, src->url);
g_strreplace (&des->target, src->target);
g_strreplace (&des->comment, src->comment);
g_strreplace (&des->accesskey, src->accesskey);
g_strreplace (&des->tabindex, src->tabindex);
g_strreplace (&des->mouse_over, src->mouse_over);
g_strreplace (&des->mouse_out, src->mouse_out);
g_strreplace (&des->focus, src->focus);
g_strreplace (&des->blur, src->blur);
g_strreplace (&des->click, src->click);
return des;
}
Object_t*
object_assign(Object_t *obj, Object_t *des)
{
obj->class->assign(obj, des);
return object_copy(obj, des);
}
void
object_draw(Object_t *obj, cairo_t *cr)
{
PreferencesData_t *preferences = get_preferences();
ColorSelData_t *colors = &preferences->colors;
GdkRGBA *fg, *bg;
gdouble dash = 4.;
if (obj->selected & 4) {
fg = &colors->interactive_fg;
bg = &colors->interactive_bg;
obj->selected &= ~4;
} else if (obj->selected) {
fg = &colors->selected_fg;
bg = &colors->selected_bg;
} else {
fg = &colors->normal_fg;
bg = &colors->normal_bg;
}
cairo_save (cr);
gdk_cairo_set_source_rgba (cr, bg);
obj->class->draw(obj, cr);
gdk_cairo_set_source_rgba (cr, fg);
cairo_set_dash (cr, &dash, 1, 0.);
obj->class->draw(obj, cr);
if (obj->selected && preferences->show_area_handle)
obj->class->draw_sashes(obj, cr);
cairo_restore (cr);
}
void
object_edit(Object_t *obj, gboolean add)
{
if (!obj->class->info_dialog)
obj->class->info_dialog = create_edit_area_info_dialog(obj);
edit_area_info_dialog_show(obj->class->info_dialog, obj, add);
}
void
object_select(Object_t *obj)
{
obj->selected = TRUE;
object_list_callback_call(&obj->list->select_cb, obj);
object_emit_geometry_signal(obj);
}
void
object_unselect(Object_t *obj)
{
obj->selected = FALSE;
object_list_callback_call(&obj->list->select_cb, obj);
object_emit_geometry_signal(obj);
}
void
object_move(Object_t *obj, gint dx, gint dy)
{
obj->class->move(obj, dx, dy);
object_emit_geometry_signal(obj);
}
void
object_move_sash(Object_t *obj, gint dx, gint dy)
{
gint x, y, width, height;
MoveSashFunc_t sash_func;
obj->class->get_dimensions(obj, &x, &y, &width, &height);
if (dx == 0)
x += (width / 2);
else
x += width;
if (dy == 0)
y += (height / 2);
else
y += height;
sash_func = obj->class->near_sash(obj, x, y);
if (sash_func) {
sash_func(obj, dx, dy);
object_emit_geometry_signal(obj);
}
}
void
object_remove(Object_t *obj)
{
object_list_remove(obj->list, obj);
object_emit_geometry_signal(obj);
}
void
object_lock(Object_t *obj)
{
obj->locked = TRUE;
}
void
object_unlock(Object_t *obj)
{
obj->locked = FALSE;
}
void
object_set_url(Object_t *obj, const gchar *url)
{
g_strreplace (&obj->url, url);
}
void
object_set_target(Object_t *obj, const gchar *target)
{
g_strreplace (&obj->target, target);
}
void
object_set_comment(Object_t *obj, const gchar *comment)
{
g_strreplace (&obj->comment, comment);
}
void
object_set_accesskey (Object_t *obj,
const gchar *accesskey)
{
g_strreplace (&obj->accesskey, accesskey);
}
void
object_set_tabindex (Object_t *obj,
const gchar *tabindex)
{
g_strreplace (&obj->tabindex, tabindex);
}
void
object_set_mouse_over(Object_t *obj, const gchar *mouse_over)
{
g_strreplace (&obj->mouse_over, mouse_over);
}
void
object_set_mouse_out(Object_t *obj, const gchar *mouse_out)
{
g_strreplace (&obj->mouse_out, mouse_out);
}
void
object_set_focus(Object_t *obj, const gchar *focus)
{
g_strreplace (&obj->focus, focus);
}
void
object_set_blur (Object_t *obj,
const gchar *blur)
{
g_strreplace (&obj->blur, blur);
}
void
object_set_click (Object_t *obj,
const gchar *click)
{
g_strreplace (&obj->click, click);
}
gint
object_get_position_in_list(Object_t *obj)
{
return g_list_index(obj->list->list, (gpointer) obj);
}
void
object_emit_changed_signal(Object_t *obj)
{
object_list_callback_call(&obj->list->changed_cb, obj);
}
void
object_emit_geometry_signal(Object_t *obj)
{
object_list_callback_call(&obj->list->geometry_cb, obj);
}
void
object_emit_update_signal(Object_t *obj)
{
object_list_callback_call(&obj->list->update_cb, obj);
}
void
do_object_locked_dialog(void)
{
static DefaultDialog_t *dialog;
if (!dialog) {
dialog = make_default_dialog("Object locked");
default_dialog_hide_cancel_button(dialog);
default_dialog_hide_apply_button(dialog);
default_dialog_set_label(
dialog,
"\n You cannot delete the selected object \n"
"since it is currently being edited.\n");
}
default_dialog_show(dialog);
}
static Object_t*
object_factory_create_object(ObjectFactory_t *factory, gint x, gint y)
{
return factory->obj = factory->create_object(x, y);
}
static gboolean
button_motion(GtkWidget *widget, GdkEventMotion *event,
ObjectFactory_t *factory)
{
gint x = get_real_coord((gint) event->x);
gint y = get_real_coord((gint) event->y);
round_to_grid(&x, &y);
factory->set_xy(factory->obj, event->state, x, y);
preview_redraw ();
return FALSE;
}
gboolean
object_on_button_press(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
static ObjectFactory_t *factory;
PreferencesData_t *preferences = get_preferences();
gint x = get_real_coord((gint) event->x);
gint y = get_real_coord((gint) event->y);
static Object_t *obj;
if (event->type == GDK_2BUTTON_PRESS)
return FALSE;
round_to_grid(&x, &y);
if (obj) {
if (event->button == 1) {
if (!factory->finish || factory->finish(obj, x, y)) {
g_signal_handlers_disconnect_by_func(widget,
button_motion,
factory);
if (object_is_valid(obj)) {
Command_t *command = create_command_new(get_shapes(), obj);
command_execute(command);
if (preferences->prompt_for_area_info)
object_edit(obj, FALSE);
} else {
object_unref(obj);
}
preview_unset_tmp_obj (obj);
preview_redraw ();
obj = NULL;
main_clear_dimension();
}
} else if (event->button == 3) {
if (!factory->cancel || factory->cancel(event, obj)) {
g_signal_handlers_disconnect_by_func(widget,
button_motion,
factory);
object_unref(obj);
preview_unset_tmp_obj (obj);
preview_redraw ();
obj = NULL;
main_clear_dimension();
}
return TRUE;
}
} else {
if (event->button == 1) {
factory = ((ObjectFactory_t*(*)(guint)) data)(event->state);
obj = object_factory_create_object(factory, x, y);
preview_set_tmp_obj (obj);
g_signal_connect(widget, "motion-notify-event",
G_CALLBACK(button_motion), factory);
}
}
return FALSE;
}
ObjectList_t*
make_object_list(void)
{
return g_new0 (ObjectList_t, 1);
}
void
object_list_destruct(ObjectList_t *list)
{
object_list_remove_all(list);
g_free(list->list);
}
ObjectList_t*
object_list_append_list(ObjectList_t *des, ObjectList_t *src)
{
GList *p;
if (!src)
return des;
for (p = src->list; p; p = p->next)
object_list_append(des, object_clone((Object_t*) p->data));
object_list_set_changed(des, TRUE);
return des;
}
ObjectList_t*
object_list_copy(ObjectList_t *des, ObjectList_t *src)
{
if (des)
object_list_remove_all(des);
else
des = make_object_list();
return object_list_append_list(des, src);
}
void
object_list_append(ObjectList_t *list, Object_t *object)
{
object->list = list;
list->list = g_list_append(list->list, (gpointer) object);
object_list_set_changed(list, TRUE);
object_list_callback_call(&list->add_cb, object);
}
void
object_list_prepend(ObjectList_t *list, Object_t *object)
{
object->list = list;
list->list = g_list_prepend(list->list, (gpointer) object);
object_list_set_changed(list, TRUE);
object_list_callback_call(&list->add_cb, object);
}
void
object_list_insert(ObjectList_t *list, gint position, Object_t *object)
{
object->list = list;
list->list = g_list_insert(list->list, (gpointer) object, position);
object_list_set_changed(list, TRUE);
object_list_callback_call(&list->add_cb, object);
}
void
object_list_remove(ObjectList_t *list, Object_t *object)
{
list->list = g_list_remove(list->list, (gpointer) object);
object_list_set_changed(list, TRUE);
object_list_callback_call(&list->remove_cb, object);
object_unref(object);
}
void
object_list_remove_link(ObjectList_t *list, GList *link)
{
list->list = g_list_remove_link(list->list, link);
object_list_set_changed(list, TRUE);
object_list_callback_call(&list->remove_cb, (Object_t*) link->data);
}
void
object_list_update(ObjectList_t *list, Object_t *object)
{
object_list_callback_call(&list->update_cb, object);
}
void
object_list_draw(ObjectList_t *list, cairo_t *cr)
{
GList *p;
for (p = list->list; p; p = p->next)
object_draw((Object_t*) p->data, cr);
}
void
object_list_draw_selected(ObjectList_t *list, cairo_t *cr)
{
GList *p;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
if (obj->selected)
object_draw(obj, cr);
}
}
Object_t*
object_list_find(ObjectList_t *list, gint x, gint y)
{
Object_t *found = NULL;
GList *p;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
if (obj->class->point_is_on(obj, x, y))
found = obj;
}
return found;
}
Object_t*
object_list_near_sash(ObjectList_t *list, gint x, gint y,
MoveSashFunc_t *sash_func)
{
Object_t *found = NULL;
GList *p;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
if (obj->selected) {
MoveSashFunc_t func = obj->class->near_sash(obj, x, y);
if (func) {
found = obj;
*sash_func = func;
}
}
}
return found;
}
void
object_list_remove_all(ObjectList_t *list)
{
GList *p;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
object_list_callback_call(&list->remove_cb, obj);
object_unref(obj);
}
g_list_free(list->list);
list->list = NULL;
object_list_set_changed(list, TRUE);
}
void
clear_paste_buffer(void)
{
if (_paste_buffer)
object_list_remove_all(_paste_buffer);
else
_paste_buffer = make_object_list();
}
ObjectList_t*
get_paste_buffer(void)
{
return _paste_buffer;
}
gint
object_list_cut(ObjectList_t *list)
{
GList *p, *q;
gint count = 0;
clear_paste_buffer();
for (p = list->list; p; p = q) {
Object_t *obj = (Object_t*) p->data;
q = p->next;
if (obj->selected) {
if (obj->locked) {
do_object_locked_dialog();
} else {
object_list_append(_paste_buffer, obj);
object_list_remove_link(list, p);
count++;
}
}
}
object_list_set_changed(list, (count) ? TRUE : FALSE);
return count;
}
void
object_list_copy_to_paste_buffer(ObjectList_t *list)
{
GList *p;
clear_paste_buffer();
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
if (obj->selected)
object_list_append(_paste_buffer, object_clone(obj));
}
}
void
object_list_paste(ObjectList_t *list)
{
object_list_append_list(list, _paste_buffer);
}
void
object_list_delete_selected(ObjectList_t *list)
{
GList *p, *q;
for (p = list->list; p; p = q) {
Object_t *obj = (Object_t*) p->data;
q = p->next;
if (obj->selected) {
if (obj->locked) {
do_object_locked_dialog();
} else {
object_list_remove_link(list, p);
object_unref(obj);
}
}
}
}
void
object_list_edit_selected(ObjectList_t *list)
{
GList *p;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
if (obj->selected) {
object_edit(obj, TRUE);
break;
}
}
}
gint
object_list_select_all(ObjectList_t *list)
{
GList *p;
gint count = 0;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
if (!obj->selected) {
object_select(obj);
count++;
}
}
return count;
}
void
object_list_select_next(ObjectList_t *list)
{
GList *p;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
if (obj->selected) {
object_unselect(obj);
p = (p->next) ? p->next : list->list;
object_select((Object_t*) p->data);
for (p = p->next; p; p = p->next) {
obj = (Object_t*) p->data;
if (obj->selected)
object_unselect(obj);
}
break;
}
}
}
void object_list_select_prev(ObjectList_t *list)
{
GList *p;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
if (obj->selected) {
GList *q = (p->prev) ? p->prev : g_list_last(list->list);
for (; p; p = p->next) {
obj = (Object_t*) p->data;
if (obj->selected)
object_unselect(obj);
}
object_select((Object_t*) q->data);
break;
}
}
}
gint
object_list_select_region(ObjectList_t *list, gint x, gint y, gint width,
gint height)
{
GList *p;
gint count = 0;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
gint obj_x, obj_y, obj_width, obj_height;
object_get_dimensions(obj, &obj_x, &obj_y, &obj_width, &obj_height);
if (obj_x >= x && obj_x + obj_width <= x + width &&
obj_y >= y && obj_y + obj_height <= y + height) {
object_select(obj);
count++;
}
}
return count;
}
gint
object_list_deselect_all(ObjectList_t *list, Object_t *exception)
{
GList *p;
gint count = 0;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
if (obj->selected && obj != exception) {
object_unselect(obj);
count++;
}
}
return count;
}
gint
object_list_nr_selected(ObjectList_t *list)
{
GList *p;
gint count = 0;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
if (obj->selected)
count++;
}
return count;
}
void
object_list_resize(ObjectList_t *list, gint percentage_x, gint percentage_y)
{
GList *p;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
object_resize(obj, percentage_x, percentage_y);
}
}
static void
object_list_swap_prev(ObjectList_t *list, GList *p)
{
gpointer swap = p->data;
p->data = p->prev->data;
p->prev->data = swap;
object_list_callback_call(&list->move_cb, (Object_t*) p->data);
object_list_callback_call(&list->move_cb, (Object_t*) p->prev->data);
}
static void
object_list_swap_next(ObjectList_t *list, GList *p)
{
gpointer swap = p->data;
p->data = p->next->data;
p->next->data = swap;
object_list_callback_call(&list->move_cb, (Object_t*) p->data);
object_list_callback_call(&list->move_cb, (Object_t*) p->next->data);
}
void
object_list_move_selected(ObjectList_t *list, gint dx, gint dy)
{
GList *p;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
if (obj->selected)
object_move(obj, dx, dy);
}
}
void
object_list_move_up(ObjectList_t *list, Object_t *obj)
{
GList *p = g_list_find(list->list, (gpointer) obj);
object_list_swap_prev(list, p);
}
void
object_list_move_down(ObjectList_t *list, Object_t *obj)
{
GList *p = g_list_find(list->list, (gpointer) obj);
object_list_swap_next(list, p);
}
void
object_list_move_selected_up(ObjectList_t *list)
{
GList *p;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
if (obj->selected && p->prev)
object_list_swap_prev(list, p);
}
}
void
object_list_move_selected_down(ObjectList_t *list)
{
GList *p;
for (p = g_list_last(list->list); p; p = p->prev) {
Object_t *obj = (Object_t*) p->data;
if (obj->selected && p->next)
object_list_swap_next(list, p);
}
}
void
object_list_move_to_front(ObjectList_t *list)
{
GList *p, *q;
guint length = g_list_length(list->list);
for (p = list->list; length; p = q, length--) {
Object_t *obj = (Object_t*) p->data;
q = p->next;
if (obj->selected) {
object_list_remove_link(list, p);
object_list_append(list, obj);
}
}
}
void
object_list_send_to_back(ObjectList_t *list)
{
GList *p, *q;
guint length = g_list_length(list->list);
for (p = list->list; length; p = q, length--) {
Object_t *obj = (Object_t*) p->data;
q = p->next;
if (obj->selected) {
object_list_remove_link(list, p);
object_list_prepend(list, obj);
}
}
}
void
object_list_move_sash_selected(ObjectList_t *list, gint dx, gint dy)
{
GList *p;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
if (obj->selected)
object_move_sash(obj, dx, dy);
}
}
static void
write_xml_attrib(const gchar *attrib, const gchar *value,
const gchar *default_text, gpointer param,
OutputFunc_t output)
{
if (*value) {
gchar *escaped_value = g_markup_escape_text(value, -1);
output(param, " %s=\"%s\"", attrib, escaped_value);
g_free(escaped_value);
} else if (*default_text) {
output(param, " %s", default_text);
}
}
void
object_list_write_csim (ObjectList_t *list,
gpointer param,
OutputFunc_t output)
{
GList *p;
for (p = list->list; p; p = p->next)
{
Object_t *obj = (Object_t*) p->data;
output (param, "<area shape=");
obj->class->write_csim (obj, param, output);
write_xml_attrib ("alt", obj->comment, "", param, output);
write_xml_attrib ("target", obj->target, "", param, output);
write_xml_attrib ("accesskey", obj->accesskey, "", param, output);
write_xml_attrib ("tabindex", obj->tabindex, "", param, output);
write_xml_attrib ("onmouseover", obj->mouse_over, "", param, output);
write_xml_attrib ("onmouseout", obj->mouse_out, "", param, output);
write_xml_attrib ("onfocus", obj->focus, "", param, output);
write_xml_attrib ("onblur", obj->blur, "", param, output);
write_xml_attrib ("onclick", obj->click, "", param, output);
write_xml_attrib ("href", obj->url, " nohref=\"nohref\"", param, output);
output (param," />\n");
}
}
void
object_list_write_cern(ObjectList_t *list, gpointer param, OutputFunc_t output)
{
GList *p;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
obj->class->write_cern(obj, param, output);
output(param, " %s\n", obj->url);
}
}
void
object_list_write_ncsa(ObjectList_t *list, gpointer param, OutputFunc_t output)
{
GList *p;
for (p = list->list; p; p = p->next) {
Object_t *obj = (Object_t*) p->data;
if (*obj->comment)
output(param, "# %s\n", obj->comment);
obj->class->write_ncsa(obj, param, output);
output(param, "\n");
}
}