src/images_menus.c

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public License
   4  * as published by the Free Software Foundation; either version 2
   5  * of the License, or (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  15  *
  16  * See the COPYING file for license information.
  17  *
  18  * Guillaume Chazarain <guichaz@yahoo.fr>
  19  */
  20
  21 /************************************
  22  * The Images and Directories menus *
  23  ************************************/
  24
  25 #include <string.h>             /* strlen() */
  26
  27 #include "gliv.h"
  28 #include "images_menus.h"
  29 #include "options.h"
  30 #include "menus.h"
  31 #include "messages.h"
  32 #include "next_image.h"
  33 #include "mnemonics.h"
  34 #include "files_list.h"
  35 #include "loading.h"
  36 #include "thumbnails.h"
  37 #include "callbacks.h"
  38 #include "tree.h"
  39 #include "timestamp.h"
  40
  41 extern options_struct *options;
  42
  43 /* The progress indicator. */
  44 static GtkMenuItem *rebuilding_entry;
  45
  46 /* The menu entry to cancel the rebuilding. */
  47 static GtkMenuItem *cancel_menu_item;
  48
  49 /*** Functions for both menus. ***/
  50
  51 /* Called at menu creation time. */
  52 void set_rebuilding_entry(GtkMenuItem * item)
  53 {
  54     rebuilding_entry = item;
  55 }
  56
  57 /* Refresh the percent indicator. */
  58 static void set_menu_indicator(gchar * name, gint percent)
  59 {
  60     static gchar *rebuilding = NULL;
  61
  62     if (name == NULL)
  63         set_menu_label(rebuilding_entry, "", FALSE);
  64     else {
  65         gchar *label;
  66
  67         if (rebuilding == NULL)
  68             /* First time. */
  69             rebuilding = _("Rebuilding:");
  70
  71         label = g_strdup_printf("%s %s (%d%%)", rebuilding, name, percent);
  72         set_menu_label(rebuilding_entry, label, FALSE);
  73
  74         g_free(label);
  75     }
  76 }
  77
  78 /* Update the percent indicator. */
  79 static void set_progress(gchar * menu, gint * percent, gint number)
  80 {
  81     gint length;
  82
  83     length = get_list_length();
  84
  85     if ((*percent + 1) * length <= 100 * number) {
  86         *percent = (100 * number) / length;
  87         set_menu_indicator(menu, *percent);
  88     }
  89 }
  90
  91 /* We don't want to perform the signal lookup for each file. */
  92 static void connect_activate(GtkMenuItem * instance, const gchar * filename)
  93 {
  94     static guint signal_id = 0;
  95     GClosure *closure;
  96
  97     if (signal_id == 0)
  98         /* First time. */
  99         signal_id = g_signal_lookup("activate", G_TYPE_FROM_INSTANCE(instance));
 100
 101     closure = g_cclosure_new_swap(G_CALLBACK(menu_load),
 102                                   (gpointer) filename, NULL);
 103
 104     g_signal_connect_closure_by_id(instance, signal_id, 0, closure, FALSE);
 105 }
 106
 107 typedef enum {
 108     MENU_FILE,                  /* From both menus. */
 109     MENU_DIR,                   /* From the Images menu. */
 110     MENU_SUBMENU                /* From the Directories menu. */
 111 } menu_type;
 112
 113 /* Add also a mnemonic and a thumbnail. */
 114 static GtkMenuItem *new_menu_item(tree_item * item, menu_type type)
 115 {
 116     const gchar *name;
 117     GtkMenuItem *menu_item;
 118     GtkImage *thumbnail = NULL;
 119
 120     if (options->thumbnails && type == MENU_FILE && fill_thumbnail(item))
 121         thumbnail = GTK_IMAGE(gtk_image_new_from_pixbuf(item->thumb));
 122     else
 123         /* Simulate the do_threaded() effect of fill_thumbnail(). */
 124         process_events();
 125
 126     if (type == MENU_DIR)
 127         name = item->path;
 128     else
 129         name = item->name;
 130
 131     if (options->mnemonics && type != MENU_DIR) {
 132         name = add_mnemonic(name);
 133
 134         if (thumbnail)
 135             menu_item =
 136                 GTK_MENU_ITEM(gtk_image_menu_item_new_with_mnemonic(name));
 137         else
 138             menu_item = GTK_MENU_ITEM(gtk_menu_item_new_with_mnemonic(name));
 139
 140     } else {
 141         if (thumbnail)
 142             menu_item = GTK_MENU_ITEM(gtk_image_menu_item_new_with_label(name));
 143         else
 144             menu_item = GTK_MENU_ITEM(gtk_menu_item_new_with_label(name));
 145     }
 146
 147     if (thumbnail)
 148         gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),
 149                                       GTK_WIDGET(thumbnail));
 150
 151     switch (type) {
 152     case MENU_FILE:
 153         connect_activate(menu_item, item->path);
 154         break;
 155
 156     case MENU_DIR:
 157         gtk_widget_set_sensitive(GTK_WIDGET(menu_item), FALSE);
 158         break;
 159
 160     case MENU_SUBMENU:
 161         break;
 162     }
 163
 164     return menu_item;
 165 }
 166
 167 /*
 168  * We first insert in the head of a list, and then we insert every elements
 169  * from that list in the menu head.  This way we build the menu in O(n) and
 170  * the mnemonics are created in normal order.
 171  */
 172 static void insert_list_into_menu(GtkMenuShell * menu, GSList * list, gint pos)
 173 {
 174     GSList *ptr;
 175
 176     for (ptr = list; ptr != NULL; ptr = ptr->next)
 177         gtk_menu_shell_insert(menu, GTK_WIDGET(ptr->data), pos);
 178
 179     g_slist_free(list);
 180 }
 181
 182 /*** Directories menu. ***/
 183
 184 static void add_file_from_tree(GSList ** list, tree_item * item)
 185 {
 186     static gchar *directories = NULL;
 187     static gint number = 0, percent = 0;
 188
 189     if (canceled_using_tree())
 190         return;
 191
 192     if (list == NULL) {
 193         /* First time for this menu. */
 194
 195         if (directories == NULL)
 196             /* First time. */
 197             directories = _("Directories");
 198
 199         number = 0;
 200         percent = 0;
 201         return;
 202     }
 203
 204     *list = g_slist_prepend(*list, new_menu_item(item, MENU_FILE));
 205
 206     set_progress(directories, &percent, number);
 207     number++;
 208 }
 209
 210 static GtkMenuItem *add_sub_menu(GSList ** list, tree_item * item)
 211 {
 212     GtkMenuShell *menu;
 213     GtkMenuItem *menu_item;
 214
 215     menu_item = new_menu_item(item, MENU_SUBMENU);
 216
 217     menu = GTK_MENU_SHELL(gtk_menu_new());
 218     gtk_menu_item_set_submenu(menu_item, GTK_WIDGET(menu));
 219
 220     gtk_menu_shell_prepend(menu, gtk_tearoff_menu_item_new());
 221     *list = g_slist_prepend(*list, menu_item);
 222
 223     return menu_item;
 224 }
 225
 226 static void make_menu_from_tree_rec(GNode * tree, GSList ** list)
 227 {
 228     GtkMenuItem *menu_item;
 229     tree_item *item;
 230     GSList *new_list = NULL;
 231
 232     if (canceled_using_tree())
 233         return;
 234
 235     item = tree->data;
 236
 237     if (G_NODE_IS_LEAF(tree)) {
 238         add_file_from_tree(list, item);
 239         return;
 240     }
 241
 242     menu_item = add_sub_menu(list, item);
 243
 244     push_mnemonics();
 245
 246     g_node_children_foreach(tree, G_TRAVERSE_ALL,
 247                             (GNodeForeachFunc) make_menu_from_tree_rec,
 248                             &new_list);
 249
 250     pop_mnemonics();
 251
 252     insert_list_into_menu(GTK_MENU_SHELL(gtk_menu_item_get_submenu(menu_item)),
 253                           new_list, 1);
 254 }
 255
 256 /*** Images menu. ***/
 257
 258 static gboolean add_file_item(GNode * tree, GSList ** list)
 259 {
 260     static gchar *images = NULL;
 261     static gint number = 0, percent = 0;
 262     GNode *sibling;
 263
 264     if (canceled_using_tree())
 265         return TRUE;
 266
 267     if (tree == NULL) {
 268         /* First time for this menu. */
 269
 270         if (images == NULL)
 271             /* First time. */
 272             images = _("Images");
 273
 274         number = 0;
 275         percent = 0;
 276         return FALSE;
 277     }
 278
 279
 280     /* Check if it is the first image in its directory. */
 281     sibling = g_node_prev_sibling(tree);
 282     if (!(G_NODE_IS_ROOT(tree) || (sibling && G_NODE_IS_LEAF(sibling))))
 283         *list = g_slist_prepend(*list,
 284                                 new_menu_item(tree->parent->data, MENU_DIR));
 285
 286     *list = g_slist_prepend(*list, new_menu_item(tree->data, MENU_FILE));
 287
 288     set_progress(images, &percent, number);
 289     number++;
 290
 291     return FALSE;
 292 }
 293
 294 /*** Menus builders. ***/
 295
 296 static GtkWidget *common_rebuild(GtkMenuItem * root, gboolean start)
 297 {
 298     static GtkMenuShell *menu;
 299
 300     if (root != NULL)
 301         gtk_menu_item_deselect(root);
 302
 303     if (start == FALSE) {
 304         const gchar *label;
 305         GtkMenuItem *item;
 306
 307         label = add_mnemonic(_("Rebuild this menu"));
 308         item = GTK_MENU_ITEM(gtk_menu_item_new_with_mnemonic(label));
 309
 310         gtk_menu_shell_insert(menu, GTK_WIDGET(item), 1);
 311
 312         return GTK_WIDGET(item);
 313     }
 314
 315     menu = GTK_MENU_SHELL(gtk_menu_new());
 316     gtk_menu_shell_prepend(menu, gtk_tearoff_menu_item_new());
 317     gtk_menu_item_set_submenu(root, GTK_WIDGET(menu));
 318
 319     return GTK_WIDGET(menu);
 320 }
 321
 322 static GNode *get_tree(void)
 323 {
 324     if (is_loading())
 325         /*
 326          * There is no problem in rebuilding the images menus during
 327          * a loading, it would just make the loading too long.
 328          */
 329         return NULL;
 330
 331     return make_tree();
 332 }
 333
 334 #define REBUILD_START(name)                                                  \
 335     do {                                                                     \
 336         if (root != NULL) {                                                  \
 337             menu_item = root;                                                \
 338             return TRUE;                                                     \
 339         }                                                                    \
 340                                                                              \
 341         if (has_timestamp(timestamp) && last_tree_ok(timestamp))             \
 342             /* The menu is already up to date. */                            \
 343             return TRUE;                                                     \
 344                                                                              \
 345         tree = get_tree();                                                   \
 346         if (tree == NULL)                                                    \
 347             return FALSE;                                                    \
 348                                                                              \
 349         gtk_widget_set_sensitive(GTK_WIDGET(cancel_menu_item), TRUE);        \
 350         reset_mnemonics();                                                   \
 351         menu = GTK_MENU_SHELL(common_rebuild(menu_item, TRUE));              \
 352         set_menu_indicator(name, 0);                                         \
 353     } while (0)
 354
 355 #define REBUILD_END(function)                                                \
 356     do {                                                                     \
 357         GtkMenuItem *launcher;                                               \
 358                                                                              \
 359         launcher = GTK_MENU_ITEM(common_rebuild(NULL, FALSE));               \
 360         g_signal_connect_swapped(launcher, "activate", G_CALLBACK(function), \
 361                                  NULL);                                      \
 362                                                                              \
 363         insert_list_into_menu(menu, list, 2);                                \
 364         gtk_widget_show_all(GTK_WIDGET(menu_item));                          \
 365         set_menu_indicator(NULL, 0);                                         \
 366         gtk_widget_set_sensitive(GTK_WIDGET(cancel_menu_item), FALSE);       \
 367         if (canceled_using_tree())                                           \
 368             reset_timestamp(&timestamp);                                     \
 369         else                                                                 \
 370             touch(&timestamp);                                               \
 371         end_using_tree();                                                    \
 372         reset_mnemonics();                                                   \
 373         return timestamp != 0;                                               \
 374     } while (0)
 375
 376 gboolean rebuild_directories(GtkMenuItem * root)
 377 {
 378     static GtkMenuItem *menu_item;
 379     static DECLARE_TIMESTAMP(timestamp);
 380     GtkMenuShell *menu;
 381     GNode *tree, *child;
 382     gchar *prefix, *old_name;
 383     tree_item *item;
 384     GSList *list = NULL;
 385
 386     REBUILD_START(_("Directories"));
 387
 388     /* Build the menu. */
 389     add_file_from_tree(NULL, NULL);
 390
 391     item = tree->data;
 392     prefix = item->path;
 393
 394     if (prefix[0] == '\0' || prefix[1] == '\0') {
 395         for (child = g_node_first_child(tree); child; child = child->next) {
 396             item = child->data;
 397             old_name = item->name;
 398             item->name = g_build_filename(prefix, item->name, NULL);
 399
 400             make_menu_from_tree_rec(child, &list);
 401
 402             g_free(item->name);
 403             item->name = old_name;
 404         }
 405     } else
 406         make_menu_from_tree_rec(tree, &list);
 407
 408     REBUILD_END(rebuild_directories);
 409 }
 410
 411 gboolean rebuild_images(GtkMenuItem * root)
 412 {
 413     static GtkMenuItem *menu_item;
 414     static DECLARE_TIMESTAMP(timestamp);
 415     GSList *list = NULL;
 416     GtkMenuShell *menu;
 417     GNode *tree;
 418
 419     REBUILD_START(_("Images"));
 420
 421     /* Build the menu. */
 422     add_file_item(NULL, NULL);
 423     g_node_traverse(tree, G_PRE_ORDER, G_TRAVERSE_LEAFS, -1,
 424                     (GNodeTraverseFunc) add_file_item, &list);
 425
 426     REBUILD_END(rebuild_images);
 427 }
 428
 429 /* Rebuild both menus. */
 430 gboolean rebuild_images_menus(void)
 431 {
 432     return rebuild_directories(NULL) && rebuild_images(NULL);
 433 }
 434
 435 void set_stop_rebuilding_menu(GtkMenuItem * item)
 436 {
 437     cancel_menu_item = item;
 438     gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
 439 }