diff options
Diffstat (limited to 'app/widgets/gimpaction-history.c')
| -rw-r--r-- | app/widgets/gimpaction-history.c | 503 |
1 files changed, 503 insertions, 0 deletions
diff --git a/app/widgets/gimpaction-history.c b/app/widgets/gimpaction-history.c new file mode 100644 index 0000000..37cdc03 --- /dev/null +++ b/app/widgets/gimpaction-history.c @@ -0,0 +1,503 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpaction-history.c + * Copyright (C) 2013 Jehan <jehan at girinstud.io> + * + * 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 <string.h> + +#include <gtk/gtk.h> + +#include "libgimpbase/gimpbase.h" +#include "libgimpconfig/gimpconfig.h" +#include "libgimpmath/gimpmath.h" + +#include "widgets-types.h" + +#include "config/gimpguiconfig.h" + +#include "core/gimp.h" + +#include "gimpuimanager.h" +#include "gimpaction.h" +#include "gimpaction-history.h" + + +#define GIMP_ACTION_HISTORY_FILENAME "action-history" + +/* History items are stored in a queue, sorted by frequency (number of times + * the action was activated), from most frequent to least frequent. Each item, + * in addition to the corresponding action name and its index in the queue, + * stores a "delta": the difference in frequency between it, and the next item + * in the queue; note that the frequency itself is not stored anywhere. + * + * To keep items from remaining at the top of the queue for too long, the delta + * is capped above, such the the maximal delta of the first item is MAX_DELTA, + * and the maximal delta of each subsequent item is the maximal delta of the + * previous item, times MAX_DELTA_FALLOFF. + * + * When an action is activated, its frequency grows by 1, meaning that the + * delta of the corresponding item is incremented (if below the maximum), and + * the delta of the previous item is decremented (if above 0). If the delta of + * the previous item is already 0, then, before the above, the current and + * previous items swap frequencies, and the current item is moved up the queue + * until the preceding item's frequency is greater than 0 (or until it reaches + * the front of the queue). + */ +#define MAX_DELTA 5 +#define MAX_DELTA_FALLOFF 0.95 + + +enum +{ + HISTORY_ITEM = 1 +}; + +typedef struct +{ + gchar *action_name; + gint index; + gint delta; +} GimpActionHistoryItem; + +static struct +{ + Gimp *gimp; + GQueue *items; + GHashTable *links; +} history; + + +static GimpActionHistoryItem * gimp_action_history_item_new (const gchar *action_name, + gint index, + gint delta); +static void gimp_action_history_item_free (GimpActionHistoryItem *item); + +static gint gimp_action_history_item_max_delta (gint index); + + +/* public functions */ + +void +gimp_action_history_init (Gimp *gimp) +{ + GimpGuiConfig *config; + GFile *file; + GScanner *scanner; + GTokenType token; + gint delta = 0; + + g_return_if_fail (GIMP_IS_GIMP (gimp)); + + config = GIMP_GUI_CONFIG (gimp->config); + + if (history.gimp != NULL) + { + g_warning ("%s: must be run only once.", G_STRFUNC); + return; + } + + history.gimp = gimp; + history.items = g_queue_new (); + history.links = g_hash_table_new (g_str_hash, g_str_equal); + + file = gimp_directory_file (GIMP_ACTION_HISTORY_FILENAME, NULL); + + if (gimp->be_verbose) + g_print ("Parsing '%s'\n", gimp_file_get_utf8_name (file)); + + scanner = gimp_scanner_new_gfile (file, NULL); + g_object_unref (file); + + if (! scanner) + return; + + g_scanner_scope_add_symbol (scanner, 0, "history-item", + GINT_TO_POINTER (HISTORY_ITEM)); + + token = G_TOKEN_LEFT_PAREN; + + while (g_scanner_peek_next_token (scanner) == token) + { + token = g_scanner_get_next_token (scanner); + + switch (token) + { + case G_TOKEN_LEFT_PAREN: + token = G_TOKEN_SYMBOL; + break; + + case G_TOKEN_SYMBOL: + if (scanner->value.v_symbol == GINT_TO_POINTER (HISTORY_ITEM)) + { + gchar *action_name; + + token = G_TOKEN_STRING; + + if (g_scanner_peek_next_token (scanner) != token) + break; + + if (! gimp_scanner_parse_string (scanner, &action_name)) + break; + + token = G_TOKEN_INT; + + if (g_scanner_peek_next_token (scanner) != token || + ! gimp_scanner_parse_int (scanner, &delta)) + { + g_free (action_name); + break; + } + + if (! gimp_action_history_is_excluded_action (action_name) && + ! g_hash_table_contains (history.links, action_name)) + { + GimpActionHistoryItem *item; + + item = gimp_action_history_item_new ( + action_name, + g_queue_get_length (history.items), + delta); + + g_queue_push_tail (history.items, item); + + g_hash_table_insert (history.links, + item->action_name, + g_queue_peek_tail_link (history.items)); + } + + g_free (action_name); + } + token = G_TOKEN_RIGHT_PAREN; + break; + + case G_TOKEN_RIGHT_PAREN: + token = G_TOKEN_LEFT_PAREN; + + if (g_queue_get_length (history.items) >= config->action_history_size) + goto done; + break; + + default: /* do nothing */ + break; + } + } + + done: + gimp_scanner_destroy (scanner); +} + +void +gimp_action_history_exit (Gimp *gimp) +{ + GimpGuiConfig *config; + GimpActionHistoryItem *item; + GList *actions; + GFile *file; + GimpConfigWriter *writer; + gint i; + + g_return_if_fail (GIMP_IS_GIMP (gimp)); + + config = GIMP_GUI_CONFIG (gimp->config); + + file = gimp_directory_file (GIMP_ACTION_HISTORY_FILENAME, NULL); + + if (gimp->be_verbose) + g_print ("Writing '%s'\n", gimp_file_get_utf8_name (file)); + + writer = gimp_config_writer_new_gfile (file, TRUE, "GIMP action-history", + NULL); + g_object_unref (file); + + for (actions = history.items->head, i = 0; + actions && i < config->action_history_size; + actions = g_list_next (actions), i++) + { + item = actions->data; + + gimp_config_writer_open (writer, "history-item"); + gimp_config_writer_string (writer, item->action_name); + gimp_config_writer_printf (writer, "%d", item->delta); + gimp_config_writer_close (writer); + } + + gimp_config_writer_finish (writer, "end of action-history", NULL); + + gimp_action_history_clear (gimp); + + g_clear_pointer (&history.links, g_hash_table_unref); + g_clear_pointer (&history.items, g_queue_free); + history.gimp = NULL; +} + +void +gimp_action_history_clear (Gimp *gimp) +{ + GimpActionHistoryItem *item; + + g_return_if_fail (GIMP_IS_GIMP (gimp)); + + g_hash_table_remove_all (history.links); + + while ((item = g_queue_pop_head (history.items))) + gimp_action_history_item_free (item); +} + +/* Search all history actions which match "keyword" with function + * match_func(action, keyword). + * + * @return a list of GtkAction*, to free with: + * g_list_free_full (result, (GDestroyNotify) g_object_unref); + */ +GList * +gimp_action_history_search (Gimp *gimp, + GimpActionMatchFunc match_func, + const gchar *keyword) +{ + GimpGuiConfig *config; + GimpUIManager *manager; + GList *actions; + GList *result = NULL; + gint i; + + g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); + g_return_val_if_fail (match_func != NULL, NULL); + + config = GIMP_GUI_CONFIG (gimp->config); + manager = gimp_ui_managers_from_name ("<Image>")->data; + + for (actions = history.items->head, i = 0; + actions && i < config->action_history_size; + actions = g_list_next (actions), i++) + { + GimpActionHistoryItem *item = actions->data; + GimpAction *action; + + action = gimp_ui_manager_find_action (manager, NULL, item->action_name); + if (action == NULL) + continue; + + if (! gimp_action_is_visible (action) || + (! gimp_action_is_sensitive (action) && + ! config->search_show_unavailable)) + continue; + + if (match_func (action, keyword, NULL, gimp)) + result = g_list_prepend (result, g_object_ref (action)); + } + + return g_list_reverse (result); +} + +/* gimp_action_history_is_blacklisted_action: + * + * Returns whether an action should be excluded from both + * history and search results. + */ +gboolean +gimp_action_history_is_blacklisted_action (const gchar *action_name) +{ + if (gimp_action_is_gui_blacklisted (action_name)) + return TRUE; + + return (g_str_has_suffix (action_name, "-set") || + g_str_has_suffix (action_name, "-accel") || + g_str_has_prefix (action_name, "context-") || + g_str_has_prefix (action_name, "filters-recent-") || + g_strcmp0 (action_name, "dialogs-action-search") == 0); +} + +/* gimp_action_history_is_excluded_action: + * + * Returns whether an action should be excluded from history. + * + * Some actions should not be logged in the history, but should + * otherwise appear in the search results, since they correspond + * to different functions at different times, or since their + * label may interfere with more relevant, but less frequent, + * actions. + */ +gboolean +gimp_action_history_is_excluded_action (const gchar *action_name) +{ + if (gimp_action_history_is_blacklisted_action (action_name)) + return TRUE; + + return (g_strcmp0 (action_name, "edit-undo") == 0 || + g_strcmp0 (action_name, "edit-strong-undo") == 0 || + g_strcmp0 (action_name, "edit-redo") == 0 || + g_strcmp0 (action_name, "edit-strong-redo") == 0 || + g_strcmp0 (action_name, "filters-repeat") == 0 || + g_strcmp0 (action_name, "filters-reshow") == 0); +} + +/* Called whenever a GimpAction is activated. + * It allows us to log all used actions. + */ +void +gimp_action_history_action_activated (GimpAction *action) +{ + GimpGuiConfig *config; + const gchar *action_name; + GList *link; + GimpActionHistoryItem *item; + + /* Silently return when called at the wrong time, like when the + * activated action was "quit" and the history is already gone. + */ + if (! history.gimp) + return; + + config = GIMP_GUI_CONFIG (history.gimp->config); + + if (config->action_history_size == 0) + return; + + action_name = gimp_action_get_name (action); + + /* Some specific actions are of no log interest. */ + if (gimp_action_history_is_excluded_action (action_name)) + return; + + g_return_if_fail (action_name != NULL); + + /* Remove excessive items. */ + while (g_queue_get_length (history.items) > config->action_history_size) + { + item = g_queue_pop_tail (history.items); + + g_hash_table_remove (history.links, item->action_name); + + gimp_action_history_item_free (item); + } + + /* Look up the action in the history. */ + link = g_hash_table_lookup (history.links, action_name); + + /* If the action is not in the history, insert it + * at the back of the history queue, possibly + * replacing the last item. + */ + if (! link) + { + if (g_queue_get_length (history.items) == config->action_history_size) + { + item = g_queue_pop_tail (history.items); + + g_hash_table_remove (history.links, item->action_name); + + gimp_action_history_item_free (item); + } + + item = gimp_action_history_item_new ( + action_name, + g_queue_get_length (history.items), + 0); + + g_queue_push_tail (history.items, item); + link = g_queue_peek_tail_link (history.items); + + g_hash_table_insert (history.links, item->action_name, link); + } + else + { + item = link->data; + } + + /* Update the history, according to the logic described + * in the comment at the beginning of the file. + */ + if (item->index > 0) + { + GList *prev_link = g_list_previous (link); + GimpActionHistoryItem *prev_item = prev_link->data; + + if (prev_item->delta == 0) + { + for (; prev_link; prev_link = g_list_previous (prev_link)) + { + prev_item = prev_link->data; + + if (prev_item->delta > 0) + break; + + prev_item->index++; + item->index--; + + prev_item->delta = item->delta; + item->delta = 0; + } + + g_queue_unlink (history.items, link); + + if (prev_link) + { + link->prev = prev_link; + link->next = prev_link->next; + + link->prev->next = link; + link->next->prev = link; + + history.items->length++; + } + else + { + g_queue_push_head_link (history.items, link); + } + } + + if (item->index > 0) + prev_item->delta--; + } + + if (item->delta < gimp_action_history_item_max_delta (item->index)) + item->delta++; +} + + +/* private functions */ + +static GimpActionHistoryItem * +gimp_action_history_item_new (const gchar *action_name, + gint index, + gint delta) +{ + GimpActionHistoryItem *item = g_slice_new (GimpActionHistoryItem); + + item->action_name = g_strdup (action_name); + item->index = index; + item->delta = CLAMP (delta, 0, gimp_action_history_item_max_delta (index)); + + return item; +} + +static void +gimp_action_history_item_free (GimpActionHistoryItem *item) +{ + g_free (item->action_name); + + g_slice_free (GimpActionHistoryItem, item); +} + +static gint +gimp_action_history_item_max_delta (gint index) +{ + return floor (MAX_DELTA * exp (log (MAX_DELTA_FALLOFF) * index)); +} |