From e42129241681dde7adae7d20697e7b421682fbb4 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 18:23:22 +0200 Subject: Adding upstream version 2.10.22. Signed-off-by: Daniel Baumann --- plug-ins/imagemap/imap_command.c | 384 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 384 insertions(+) create mode 100644 plug-ins/imagemap/imap_command.c (limited to 'plug-ins/imagemap/imap_command.c') diff --git a/plug-ins/imagemap/imap_command.c b/plug-ins/imagemap/imap_command.c new file mode 100644 index 0000000..ae81c1f --- /dev/null +++ b/plug-ins/imagemap/imap_command.c @@ -0,0 +1,384 @@ +/* + * This is a plug-in for GIMP. + * + * Generates clickable image maps. + * + * Copyright (C) 1998-1999 Maurits Rijk lpeek.mrijk@consunet.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 . + * + */ + +#include "config.h" + +#include + +#include + +#include "imap_command.h" + +#define INFINITE_UNDO_LEVELS -1 + +static void command_destruct(Command_t *command); + +static CommandList_t _command_list = {NULL, DEFAULT_UNDO_LEVELS}; +static CommandList_t *_current_command_list = &_command_list; + +static void +command_list_callback_add(CommandListCallback_t *list, + CommandListCallbackFunc_t func, gpointer data) +{ + CommandListCB_t *cb = g_new(CommandListCB_t, 1); + cb->func = func; + cb->data = data; + list->list = g_list_append(list->list, cb); +} + +static void +command_list_callback_call(CommandListCallback_t *list, Command_t *command) +{ + GList *p; + for (p = list->list; p; p = p->next) { + CommandListCB_t *cb = (CommandListCB_t*) p->data; + cb->func(command, cb->data); + } +} + +CommandList_t* +command_list_new(gint undo_levels) +{ + CommandList_t *list = g_new(CommandList_t, 1); + list->parent = NULL; + list->undo_levels = undo_levels; + list->list = NULL; + list->undo = NULL; + list->redo = NULL; + list->update_cb.list = NULL; + return list; +} + +static void +command_list_clear(CommandList_t *list) +{ + GList *p; + for (p = list->list; p; p = p->next) + command_destruct((Command_t*) p->data); + g_list_free(list->list); + list->list = NULL; + list->undo = NULL; + list->redo = NULL; + command_list_callback_call(&list->update_cb, NULL); +} + +void +command_list_destruct(CommandList_t *list) +{ + command_list_clear(list); + g_free(list); +} + +void +command_list_remove_all(void) +{ + command_list_clear(&_command_list); +} + +static void +_command_list_add(CommandList_t *list, Command_t *command) +{ + GList *p, *q; + + /* Remove rest */ + for (p = list->redo; p; p = q) { + Command_t *curr = (Command_t*) p->data; + q = p->next; + command_destruct(curr); + list->list = g_list_remove_link(list->list, p); + } + if (g_list_length(list->list) == list->undo_levels) { + GList *first = g_list_first(list->list); + Command_t *curr = (Command_t*) first->data; + command_destruct(curr); + list->list = g_list_remove_link(list->list, first); + } + list->list = g_list_append(list->list, (gpointer) command); + list->undo = g_list_last(list->list); + list->redo = NULL; + + command_list_callback_call(&list->update_cb, command); +} + +void +command_list_add(Command_t *command) +{ + _command_list_add(_current_command_list, command); +} + +/* Fix me! */ +void +subcommand_list_add(CommandList_t *list, Command_t *command) +{ + _command_list_add(list, command); +} + +static CommandClass_t parent_command_class = { + NULL, /* parent_command_destruct */ + NULL, /* parent_command_execute */ + NULL, /* parent_command_undo */ + NULL /* parent_command_redo */ +}; + +static Command_t* +command_list_start(CommandList_t *list, const gchar *name) +{ + Command_t *command = g_new(Command_t, 1); + command_init(command, name, &parent_command_class); + command->sub_commands = command_list_new(INFINITE_UNDO_LEVELS); + + command_list_add(command); + command->sub_commands->parent = _current_command_list; + _current_command_list = command->sub_commands; + + return command; +} + +static void +command_list_end(CommandList_t *list) +{ + _current_command_list = list->parent; +} + +Command_t* +subcommand_start(const gchar *name) +{ + return command_list_start(_current_command_list, name); +} + +void +subcommand_end(void) +{ + command_list_end(_current_command_list); +} + +static void +_command_list_set_undo_level(CommandList_t *list, gint level) +{ + gint diff = g_list_length(list->list) - level; + if (diff > 0) { + GList *p, *q; + /* first remove data at the front */ + for (p = list->list; diff && p != list->undo; p = q, diff--) { + Command_t *curr = (Command_t*) p->data; + q = p->next; + command_destruct(curr); + list->list = g_list_remove_link(list->list, p); + } + + /* If still to long start removing redo levels at the end */ + for (p = g_list_last(list->list); diff && p != list->undo; p = q, + diff--) { + Command_t *curr = (Command_t*) p->data; + q = p->prev; + command_destruct(curr); + list->list = g_list_remove_link(list->list, p); + } + command_list_callback_call(&list->update_cb, + (Command_t*) list->undo->data); + } + list->undo_levels = level; +} + +void +command_list_set_undo_level(gint level) +{ + _command_list_set_undo_level(&_command_list, level); +} + +Command_t* +command_list_get_redo_command(void) +{ + return (_command_list.redo) ? (Command_t*) _command_list.redo->data : NULL; +} + +void +command_list_add_update_cb(CommandListCallbackFunc_t func, gpointer data) +{ + command_list_callback_add(&_command_list.update_cb, func, data); +} + +static void +command_destruct(Command_t *command) +{ + if (command->sub_commands) + command_list_destruct(command->sub_commands); + if (command->class->destruct) + command->class->destruct(command); +} + +static void +command_list_execute(CommandList_t *list) +{ + GList *p; + for (p = list->list; p; p = p->next) { + Command_t *command = (Command_t*) p->data; + if (command->sub_commands) + command_list_execute(command->sub_commands); + if (command->class->execute) + (void) command->class->execute(command); + } +} + +void +command_execute(Command_t *command) +{ + if (command->locked) { + command->locked = FALSE; + } else { + if (command->sub_commands) + command_list_execute(command->sub_commands); + if (command->class->execute) { + CmdExecuteValue_t value = command->class->execute(command); + if (value == CMD_APPEND) + command_list_add(command); + else if (value == CMD_DESTRUCT) + command_destruct(command); + } + } +} + +void +command_redo(Command_t *command) +{ + if (command->sub_commands) + command_list_redo_all(command->sub_commands); + if (command->class->redo) + command->class->redo(command); + else if (command->class->execute) + (void) command->class->execute(command); +} + +void +command_undo(Command_t *command) +{ + if (command->sub_commands) + command_list_undo_all(command->sub_commands); + if (command->class->undo) + command->class->undo(command); +} + +void +command_set_name(Command_t *command, const gchar *name) +{ + command->name = name; + command_list_callback_call(&_command_list.update_cb, command); +} + +void +command_list_undo(CommandList_t *list) +{ + Command_t *command = (Command_t*) list->undo->data; + command_undo(command); + + list->redo = list->undo; + list->undo = list->undo->prev; + if (list->undo) + command = (Command_t*) list->undo->data; + else + command = NULL; + command_list_callback_call(&list->update_cb, command); +} + +void +command_list_undo_all(CommandList_t *list) +{ + while (list->undo) + command_list_undo(list); +} + +void +last_command_undo(void) +{ + command_list_undo(&_command_list); +} + +void +command_list_redo(CommandList_t *list) +{ + Command_t *command = (Command_t*) list->redo->data; + command_redo(command); + + list->undo = list->redo; + list->redo = list->redo->next; + command_list_callback_call(&list->update_cb, command); +} + +void +command_list_redo_all(CommandList_t *list) +{ + while (list->redo) + command_list_redo(list); +} + +void +last_command_redo(void) +{ + command_list_redo(&_command_list); +} + +Command_t* +command_init(Command_t *command, const gchar *name, CommandClass_t *class) +{ + command->sub_commands = NULL; + command->name = name; + command->class = class; + command->locked = FALSE; + return command; +} + +void +command_add_subcommand(Command_t *command, Command_t *sub_command) +{ + if (!command->sub_commands) + command->sub_commands = command_list_new(INFINITE_UNDO_LEVELS); + subcommand_list_add(command->sub_commands, sub_command); +} + +static CmdExecuteValue_t basic_command_execute(Command_t *command); + +static CommandClass_t basic_command_class = { + NULL, /* basic_command_destruct */ + basic_command_execute, + NULL, + NULL /* basic_command_redo */ +}; + +typedef struct { + Command_t parent; + void (*func)(void); +} BasicCommand_t; + +Command_t* +command_new(void (*func)(void)) +{ + BasicCommand_t *command = g_new(BasicCommand_t, 1); + command->func = func; + return command_init(&command->parent, "Unknown", &basic_command_class); +} + +static CmdExecuteValue_t +basic_command_execute(Command_t *command) +{ + ((BasicCommand_t*) command)->func(); + return CMD_DESTRUCT; +} -- cgit v1.2.3