ROX-Filer/src/menu.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 2000, Thomas Leonard, <tal197@ecs.soton.ac.uk>.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* menu.c - code for handling the popup menu */
  23
  24 #include <config.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <sys/stat.h>
  28 #include <sys/types.h>
  29 #include <sys/wait.h>
  30 #include <sys/param.h>
  31 #include <fcntl.h>
  32 #include <unistd.h>
  33 #include <errno.h>
  34 #include <string.h>
  35
  36 #include <gtk/gtk.h>
  37
  38 #include "menu.h"
  39 #include "run.h"
  40 #include "action.h"
  41 #include "filer.h"
  42 #include "type.h"
  43 #include "support.h"
  44 #include "gui_support.h"
  45 #include "options.h"
  46 #include "choices.h"
  47 #include "gtksavebox.h"
  48 #include "mount.h"
  49 #include "minibuffer.h"
  50 #include "i18n.h"
  51
  52 #define C_ "<control>"
  53
  54 #define MENU_MARGIN 32
  55
  56 GtkAccelGroup   *filer_keys;
  57 GtkAccelGroup   *panel_keys;
  58 GtkAccelGroup   *pinboard_keys;
  59
  60 static GtkWidget *popup_menu = NULL;    /* Currently open menu */
  61
  62 static gint updating_menu = 0;          /* Non-zero => ignore activations */
  63
  64 /* Options */
  65 static GtkWidget *xterm_here_entry;
  66 static char *xterm_here_value;
  67
  68 /* TRUE if we selected an icon automatically when the menu was opened */
  69 static gboolean pin_temp_item_selected;
  70
  71 /* Static prototypes */
  72
  73 static void save_menus(void);
  74 static void position_menu(GtkMenu *menu, gint *x, gint *y, gpointer data);
  75 static void pin_menu_closed(GtkWidget *widget);
  76 static void menu_closed(GtkWidget *widget);
  77 static void items_sensitive(gboolean state);
  78 static char *load_xterm_here(char *data);
  79 static void savebox_show(guchar *title, guchar *path, MaskedPixmap *image,
  80                 gboolean (*callback)(guchar *current, guchar *new));
  81 static gint save_to_file(GtkSavebox *savebox, guchar *pathname);
  82 static GList *list_paths(FilerWindow *filer_window);
  83 static void free_paths(GList *paths);
  84
  85 /* Note that for most of these callbacks none of the arguments are used. */
  86 static void large(gpointer data, guint action, GtkWidget *widget);
  87 static void small(gpointer data, guint action, GtkWidget *widget);
  88
  89 /* (action used in these two - (DetailsType) */
  90 static void large_with(gpointer data, guint action, GtkWidget *widget);
  91 static void small_with(gpointer data, guint action, GtkWidget *widget);
  92
  93 static void sort_name(gpointer data, guint action, GtkWidget *widget);
  94 static void sort_type(gpointer data, guint action, GtkWidget *widget);
  95 static void sort_size(gpointer data, guint action, GtkWidget *widget);
  96 static void sort_date(gpointer data, guint action, GtkWidget *widget);
  97
  98 static void hidden(gpointer data, guint action, GtkWidget *widget);
  99 static void refresh(gpointer data, guint action, GtkWidget *widget);
 100
 101 static void copy_item(gpointer data, guint action, GtkWidget *widget);
 102 static void rename_item(gpointer data, guint action, GtkWidget *widget);
 103 static void link_item(gpointer data, guint action, GtkWidget *widget);
 104 static void open_file(gpointer data, guint action, GtkWidget *widget);
 105 static void help(gpointer data, guint action, GtkWidget *widget);
 106 static void show_file_info(gpointer data, guint action, GtkWidget *widget);
 107 static void mount(gpointer data, guint action, GtkWidget *widget);
 108 static void delete(gpointer data, guint action, GtkWidget *widget);
 109 static void remove_link(gpointer data, guint action, GtkWidget *widget);
 110 static void usage(gpointer data, guint action, GtkWidget *widget);
 111 static void chmod_items(gpointer data, guint action, GtkWidget *widget);
 112 static void find(gpointer data, guint action, GtkWidget *widget);
 113
 114 static void open_vfs_rpm(gpointer data, guint action, GtkWidget *widget);
 115 static void open_vfs_utar(gpointer data, guint action, GtkWidget *widget);
 116 static void open_vfs_uzip(gpointer data, guint action, GtkWidget *widget);
 117
 118 static void select_all(gpointer data, guint action, GtkWidget *widget);
 119 static void clear_selection(gpointer data, guint action, GtkWidget *widget);
 120 static void show_options(gpointer data, guint action, GtkWidget *widget);
 121 static void new_directory(gpointer data, guint action, GtkWidget *widget);
 122 static void xterm_here(gpointer data, guint action, GtkWidget *widget);
 123
 124 static void open_parent_same(gpointer data, guint action, GtkWidget *widget);
 125 static void open_parent(gpointer data, guint action, GtkWidget *widget);
 126 static void new_window(gpointer data, guint action, GtkWidget *widget);
 127 static void close_window(gpointer data, guint action, GtkWidget *widget);
 128 static void enter_path(gpointer data, guint action, GtkWidget *widget);
 129 static void shell_command(gpointer data, guint action, GtkWidget *widget);
 130 static void run_action(gpointer data, guint action, GtkWidget *widget);
 131 static void select_if(gpointer data, guint action, GtkWidget *widget);
 132 static void rox_help(gpointer data, guint action, GtkWidget *widget);
 133
 134 static void open_as_dir(gpointer data, guint action, GtkWidget *widget);
 135 static void close_panel(gpointer data, guint action, GtkWidget *widget);
 136
 137 static void pin_help(gpointer data, guint action, GtkWidget *widget);
 138 static void pin_remove(gpointer data, guint action, GtkWidget *widget);
 139
 140 static void set_items_shaded(GtkWidget *menu, gboolean shaded, int from, int n);
 141
 142 static GtkWidget *create_options();
 143 static void update_options();
 144 static void set_options();
 145 static void save_options();
 146
 147 static OptionsSection options =
 148 {
 149         N_("Menu options"),
 150         create_options,
 151         update_options,
 152         set_options,
 153         save_options
 154 };
 155
 156
 157 static GtkWidget        *filer_menu;            /* The popup filer menu */
 158 static GtkWidget        *filer_file_item;       /* The File '' label */
 159 static GtkWidget        *filer_file_menu;       /* The File '' menu */
 160 static GtkWidget        *filer_vfs_menu;        /* The Open VFS menu */
 161 static GtkWidget        *filer_hidden_menu;     /* The Show Hidden item */
 162 static GtkWidget        *filer_new_window;      /* The New Window item */
 163 static GtkWidget        *panel_menu;            /* The popup panel menu */
 164 static GtkWidget        *panel_hidden_menu;     /* The Show Hidden item */
 165 static GtkWidget        *pinboard_menu;         /* The popup pinboard menu */
 166
 167 /* Used for Copy, etc */
 168 static GtkWidget        *savebox = NULL;
 169 static guchar           *current_path = NULL;
 170 static gboolean (*current_savebox_callback)(guchar *current, guchar *new);
 171
 172 #undef N_
 173 #define N_(x) x
 174
 175 static GtkItemFactoryEntry filer_menu_def[] = {
 176 {N_("Display"),                 NULL,   NULL, 0, "<Branch>"},
 177 {">" N_("Large Icons"),         NULL,   large, 0, NULL},
 178 {">" N_("Small Icons"),         NULL,   small, 0, NULL},
 179 {">" N_("Large, With..."),      NULL,   NULL, 0, "<Branch>"},
 180 {">>" N_("Summary"),    NULL,   large_with, DETAILS_SUMMARY, NULL},
 181 {">>" N_("Sizes"),      NULL,   large_with, DETAILS_SIZE, NULL},
 182 {">>" N_("Size Bars"),  NULL,   large_with, DETAILS_SIZE_BARS, NULL},
 183 {">" N_("Small, With..."),      NULL,   NULL, 0, "<Branch>"},
 184 {">>" N_("Summary"),    NULL,   small_with, DETAILS_SUMMARY, NULL},
 185 {">>" N_("Sizes"),      NULL,   small_with, DETAILS_SIZE, NULL},
 186 {">>" N_("Size Bars"),  NULL,   small_with, DETAILS_SIZE_BARS, NULL},
 187 {">",                   NULL,   NULL, 0, "<Separator>"},
 188 {">" N_("Sort by Name"),        NULL,   sort_name, 0, NULL},
 189 {">" N_("Sort by Type"),        NULL,   sort_type, 0, NULL},
 190 {">" N_("Sort by Date"),        NULL,   sort_date, 0, NULL},
 191 {">" N_("Sort by Size"),        NULL,   sort_size, 0, NULL},
 192 {">",                   NULL,   NULL, 0, "<Separator>"},
 193 {">" N_("Show Hidden"),         NULL,   hidden, 0, "<ToggleItem>"},
 194 {">" N_("Refresh"),     NULL,   refresh, 0,     NULL},
 195 {N_("File"),                    NULL,   NULL, 0, "<Branch>"},
 196 {">" N_("Copy..."),     NULL,   copy_item, 0, NULL},
 197 {">" N_("Rename..."),   NULL,   rename_item, 0, NULL},
 198 {">" N_("Link..."),     NULL,   link_item, 0, NULL},
 199 {">" N_("Shift Open"),          NULL,   open_file, 0, NULL},
 200 {">" N_("Help"),                NULL,   help, 0, NULL},
 201 {">" N_("Info"),                NULL,   show_file_info, 0, NULL},
 202 {">" N_("Open VFS"),    NULL,   NULL, 0, "<Branch>"},
 203 {">>" N_("Unzip"),      NULL,   open_vfs_uzip, 0, NULL},
 204 {">>" N_("Untar"),      NULL,   open_vfs_utar, 0, NULL},
 205 {">>" N_("RPM"),                NULL,   open_vfs_rpm, 0, NULL},
 206 {">",                   NULL,   NULL, 0, "<Separator>"},
 207 {">" N_("Mount"),               NULL,   mount, 0,       NULL},
 208 {">" N_("Delete"),              NULL,   delete, 0,      NULL},
 209 {">" N_("Disk Usage"),  NULL,   usage, 0, NULL},
 210 {">" N_("Permissions"), NULL,   chmod_items, 0, NULL},
 211 {">" N_("Find"),                NULL,   find, 0, NULL},
 212 {N_("Select All"),              NULL,   select_all, 0, NULL},
 213 {N_("Clear Selection"),         NULL,   clear_selection, 0, NULL},
 214 {N_("Options..."),              NULL,   show_options, 0, NULL},
 215 {N_("New Directory..."),        NULL,   new_directory, 0, NULL},
 216 {N_("Xterm Here"),              NULL,   xterm_here, 0, NULL},
 217 {N_("Window"),                  NULL,   NULL, 0, "<Branch>"},
 218 {">" N_("Parent, New Window"),  NULL,   open_parent, 0, NULL},
 219 {">" N_("Parent, Same Window"), NULL,  open_parent_same, 0, NULL},
 220 {">" N_("New Window"),  NULL,   new_window, 0, NULL},
 221 {">" N_("Close Window"),        NULL,   close_window, 0, NULL},
 222 {">",                   NULL,   NULL, 0, "<Separator>"},
 223 {">" N_("Enter Path..."),       NULL,   enter_path, 0, NULL},
 224 {">" N_("Shell Command..."),    NULL,   shell_command, 0, NULL},
 225 {">" N_("Set Run Action..."),   NULL,   run_action, 0, NULL},
 226 {">" N_("Select If..."),        NULL,   select_if, 0, NULL},
 227 {">",                   NULL,   NULL, 0, "<Separator>"},
 228 {">" N_("Show ROX-Filer Help"), NULL,  rox_help, 0, NULL},
 229 };
 230
 231 static GtkItemFactoryEntry panel_menu_def[] = {
 232 {N_("Display"),                 NULL,   NULL, 0, "<Branch>"},
 233 {">" N_("Sort by Name"),        NULL,   sort_name, 0, NULL},
 234 {">" N_("Sort by Type"),        NULL,   sort_type, 0, NULL},
 235 {">" N_("Sort by Date"),        NULL,   sort_date, 0, NULL},
 236 {">" N_("Sort by Size"),        NULL,   sort_size, 0, NULL},
 237 {">",                   NULL,   NULL, 0, "<Separator>"},
 238 {">" N_("Show Hidden"),         NULL,   hidden, 0, "<ToggleItem>"},
 239 {">" N_("Refresh"),     NULL,   refresh, 0,     NULL},
 240 {N_("Open Panel as Directory"), NULL,   open_as_dir, 0, NULL},
 241 {N_("Close Panel"),             NULL,   close_panel, 0, NULL},
 242 {"",                            NULL,   NULL, 0, "<Separator>"},
 243 {N_("ROX-Filer Help"),          NULL,   rox_help, 0, NULL},
 244 {N_("ROX-Filer Options..."),    NULL,   show_options, 0, NULL},
 245 {"",                            NULL,   NULL, 0, "<Separator>"},
 246 {N_("Show Help"),               NULL,   help, 0, NULL},
 247 {N_("Remove Item"),             NULL,   remove_link, 0, NULL},
 248 };
 249
 250 static GtkItemFactoryEntry pinboard_menu_def[] = {
 251 {N_("Show Help"),               NULL,   pin_help, 0, NULL},
 252 {N_("Remove Item(s)"),          NULL,   pin_remove, 0, NULL},
 253 {"",                            NULL,   NULL, 0, "<Separator>"},
 254 {N_("ROX-Filer Help"),          NULL,   rox_help, 0, NULL},
 255 {N_("ROX-Filer Options..."),    NULL,   show_options, 0, NULL},
 256 };
 257
 258
 259 typedef struct _FileStatus FileStatus;
 260
 261 /* This is for the 'file(1) says...' thing */
 262 struct _FileStatus
 263 {
 264         int     fd;     /* FD to read from, -1 if closed */
 265         int     input;  /* Input watcher tag if fd valid */
 266         GtkLabel *label;        /* Widget to output to */
 267         gboolean        start;  /* No output yet */
 268 };
 269
 270 #define GET_MENU_ITEM(var, menu)        \
 271                 var = gtk_item_factory_get_widget(item_factory, "<" menu ">");
 272
 273 #define GET_SMENU_ITEM(var, menu, sub)  \
 274         do {                            \
 275                 tmp = g_strdup_printf("<" menu ">/%s", _(sub));         \
 276                 var = gtk_item_factory_get_widget(item_factory, tmp);   \
 277                 g_free(tmp);            \
 278         } while (0)
 279
 280 #define GET_SSMENU_ITEM(var, menu, sub, subsub) \
 281         do {                            \
 282                 tmp = g_strdup_printf("<" menu ">/%s/%s", _(sub), _(subsub)); \
 283                 var = gtk_item_factory_get_widget(item_factory, tmp);   \
 284                 g_free(tmp);            \
 285         } while (0)
 286
 287 /* Creates menu <name> from the <name>_menu_def array.
 288  * The accel group <name>_keys must also have been created.
 289  * All menu items are translated. Sets 'item_factory'.
 290  */
 291 #define MAKE_MENU(name) \
 292 do {                                                                    \
 293         GtkItemFactoryEntry     *translated;                            \
 294         int                     n_entries;                              \
 295                                                                         \
 296         item_factory = gtk_item_factory_new(GTK_TYPE_MENU,              \
 297                                 "<" #name ">", name ## _keys);          \
 298                                                                         \
 299         n_entries = sizeof(name ## _menu_def) / sizeof(*name ## _menu_def); \
 300         translated = translate_entries(name ## _menu_def, n_entries);   \
 301         gtk_item_factory_create_items (item_factory, n_entries,         \
 302                                         translated, NULL);              \
 303         free_translated_entries(translated, n_entries);                 \
 304 } while (0)
 305
 306 void menu_init()
 307 {
 308         char                    *menurc;
 309         GList                   *items;
 310         guchar                  *tmp;
 311         GtkWidget               *item;
 312         GtkItemFactory          *item_factory;                          \
 313
 314         filer_keys = gtk_accel_group_new();
 315         MAKE_MENU(filer);
 316
 317         GET_MENU_ITEM(filer_menu, "filer");
 318         GET_SMENU_ITEM(filer_file_menu, "filer", "File");
 319         GET_SSMENU_ITEM(filer_vfs_menu, "filer", "File", "Open VFS");
 320         GET_SSMENU_ITEM(filer_hidden_menu, "filer", "Display", "Show Hidden");
 321
 322         items = gtk_container_children(GTK_CONTAINER(filer_menu));
 323         filer_file_item = GTK_BIN(g_list_nth(items, 1)->data)->child;
 324         g_list_free(items);
 325
 326         GET_SSMENU_ITEM(item, "filer", "Window", "New Window");
 327         filer_new_window = GTK_BIN(item)->child;
 328
 329         panel_keys = gtk_accel_group_new();
 330         MAKE_MENU(panel);
 331
 332         GET_MENU_ITEM(panel_menu, "panel");
 333         GET_SSMENU_ITEM(panel_hidden_menu, "panel", "Display", "Show Hidden");
 334
 335         menurc = choices_find_path_load("menus", PROJECT);
 336         if (menurc)
 337                 gtk_item_factory_parse_rc(menurc);
 338
 339         gtk_accel_group_lock(panel_keys);
 340
 341         pinboard_keys = gtk_accel_group_new();
 342         MAKE_MENU(pinboard);
 343         gtk_accel_group_lock(pinboard_keys);
 344         GET_MENU_ITEM(pinboard_menu, "pinboard");
 345
 346         gtk_signal_connect(GTK_OBJECT(pinboard_menu), "unmap_event",
 347                         GTK_SIGNAL_FUNC(pin_menu_closed), NULL);
 348         gtk_signal_connect(GTK_OBJECT(filer_menu), "unmap_event",
 349                         GTK_SIGNAL_FUNC(menu_closed), NULL);
 350         gtk_signal_connect(GTK_OBJECT(panel_menu), "unmap_event",
 351                         GTK_SIGNAL_FUNC(menu_closed), NULL);
 352         gtk_signal_connect(GTK_OBJECT(filer_file_menu), "unmap_event",
 353                         GTK_SIGNAL_FUNC(menu_closed), NULL);
 354
 355         options_sections = g_slist_prepend(options_sections, &options);
 356         xterm_here_value = g_strdup("xterm");
 357         option_register("xterm_here", load_xterm_here);
 358
 359         savebox = gtk_savebox_new();
 360         gtk_signal_connect_object(GTK_OBJECT(savebox), "save_to_file",
 361                                 GTK_SIGNAL_FUNC(save_to_file), NULL);
 362         gtk_signal_connect_object(GTK_OBJECT(savebox), "save_done",
 363                                 GTK_SIGNAL_FUNC(gtk_widget_hide),
 364                                 GTK_OBJECT(savebox));
 365
 366         atexit(save_menus);
 367 }
 368
 369 /* Build up some option widgets to go in the options dialog, but don't
 370  * fill them in yet.
 371  */
 372 static GtkWidget *create_options()
 373 {
 374         GtkWidget       *table, *label;
 375
 376         table = gtk_table_new(2, 2, FALSE);
 377         gtk_container_set_border_width(GTK_CONTAINER(table), 4);
 378
 379         label = gtk_label_new(
 380                         _("To set the keyboard short-cuts, simply open "
 381                         "the menu over a filer window, move the pointer over "
 382                         "the item you want to use and press a key. The key "
 383                         "will appear next to the menu item and you can just "
 384                         "press that key without opening the menu in future."));
 385         gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
 386         gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 2, 0, 1);
 387
 388         label = gtk_label_new(_("'Xterm here' program:"));
 389         gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
 390         xterm_here_entry = gtk_entry_new();
 391         gtk_table_attach_defaults(GTK_TABLE(table), xterm_here_entry,
 392                         1, 2, 1, 2);
 393
 394         return table;
 395 }
 396
 397 static char *load_xterm_here(char *data)
 398 {
 399         g_free(xterm_here_value);
 400         xterm_here_value = g_strdup(data);
 401         return NULL;
 402 }
 403
 404 static void update_options()
 405 {
 406         gtk_entry_set_text(GTK_ENTRY(xterm_here_entry), xterm_here_value);
 407 }
 408
 409 static void set_options()
 410 {
 411         g_free(xterm_here_value);
 412         xterm_here_value = g_strdup(gtk_entry_get_text(
 413                                 GTK_ENTRY(xterm_here_entry)));
 414 }
 415
 416 static void save_options()
 417 {
 418         save_menus();
 419         option_write("xterm_here", xterm_here_value);
 420 }
 421
 422
 423 static void items_sensitive(gboolean state)
 424 {
 425         int     n = 7;
 426         GList   *items, *item;
 427
 428         items = item = gtk_container_children(GTK_CONTAINER(filer_file_menu));
 429         while (item && n--)
 430         {
 431                 gtk_widget_set_sensitive(GTK_BIN(item->data)->child, state);
 432                 item = item->next;
 433         }
 434         g_list_free(items);
 435
 436         items = item = gtk_container_children(GTK_CONTAINER(filer_vfs_menu));
 437         while (item)
 438         {
 439                 gtk_widget_set_sensitive(GTK_BIN(item->data)->child, state);
 440                 item = item->next;
 441         }
 442         g_list_free(items);
 443 }
 444
 445 static void position_menu(GtkMenu *menu, gint *x, gint *y, gpointer data)
 446 {
 447         int             *pos = (int *) data;
 448         GtkRequisition  requisition;
 449
 450         gtk_widget_size_request(GTK_WIDGET(menu), &requisition);
 451
 452         if (pos[0] == -1)
 453                 *x = screen_width - MENU_MARGIN - requisition.width;
 454         else if (pos[0] == -2)
 455                 *x = MENU_MARGIN;
 456         else
 457                 *x = pos[0] - (requisition.width >> 2);
 458
 459         if (pos[1] == -1)
 460                 *y = screen_height - MENU_MARGIN - requisition.height;
 461         else if (pos[1] == -2)
 462                 *y = MENU_MARGIN;
 463         else
 464                 *y = pos[1] - (requisition.height >> 2);
 465
 466         *x = CLAMP(*x, 0, screen_width - requisition.width);
 467         *y = CLAMP(*y, 0, screen_height - requisition.height);
 468 }
 469
 470 /* Display the pinboard menu. Set icon to NULL if no particular icon
 471  * was clicked.
 472  */
 473 void show_pinboard_menu(GdkEventButton *event, PinIcon *icon)
 474 {
 475         int             pos[2];
 476         GList           *icons;
 477
 478         if (icon)
 479         {
 480                 if (pinboard_is_selected(icon))
 481                         pin_temp_item_selected = FALSE;
 482                 else
 483                 {
 484                         pinboard_select_only(icon);
 485                         pin_temp_item_selected = TRUE;
 486                 }
 487         }
 488
 489         icons = pinboard_get_selected();
 490
 491         pos[0] = event->x_root;
 492         pos[1] = event->y_root;
 493
 494         if (icons)
 495         {
 496                 set_items_shaded(pinboard_menu,
 497                                 icons->next ? TRUE : FALSE , 0, 1);
 498
 499                 set_items_shaded(pinboard_menu, FALSE, 1, 1);
 500         }
 501         else
 502                 set_items_shaded(pinboard_menu, TRUE, 0, 2);
 503
 504         gtk_menu_popup(GTK_MENU(pinboard_menu), NULL, NULL, position_menu,
 505                         (gpointer) pos, event->button, event->time);
 506 }
 507
 508 void show_filer_menu(FilerWindow *filer_window, GdkEventButton *event,
 509                      int item)
 510 {
 511         DirItem         *file_item;
 512         int             pos[2];
 513
 514         updating_menu++;
 515
 516         pos[0] = event->x_root;
 517         pos[1] = event->y_root;
 518
 519         window_with_focus = filer_window;
 520
 521         switch (filer_window->panel_type)
 522         {
 523                 case PANEL_TOP:
 524                         pos[1] = -2;
 525                         break;
 526                 case PANEL_BOTTOM:
 527                         pos[1] = -1;
 528                         break;
 529                 default:
 530                         break;
 531         }
 532
 533         if (filer_window->panel_type)
 534                 collection_clear_selection(filer_window->collection); /* ??? */
 535
 536         if (filer_window->collection->number_selected == 0 && item >= 0)
 537         {
 538                 collection_select_item(filer_window->collection, item);
 539                 filer_window->temp_item_selected = TRUE;
 540         }
 541         else
 542                 filer_window->temp_item_selected = FALSE;
 543
 544         if (filer_window->panel_type)
 545         {
 546                 gtk_check_menu_item_set_active(
 547                                 GTK_CHECK_MENU_ITEM(panel_hidden_menu),
 548                                 filer_window->show_hidden);
 549         }
 550         else
 551         {
 552                 GtkWidget       *file_label, *file_menu;
 553                 Collection      *collection = filer_window->collection;
 554                 GString         *buffer;
 555
 556                 file_label = filer_file_item;
 557                 file_menu = filer_file_menu;
 558                 gtk_check_menu_item_set_active(
 559                                 GTK_CHECK_MENU_ITEM(filer_hidden_menu),
 560                                 filer_window->show_hidden);
 561                 buffer = g_string_new(NULL);
 562                 switch (collection->number_selected)
 563                 {
 564                         case 0:
 565                                 g_string_assign(buffer, _("Next Click"));
 566                                 items_sensitive(TRUE);
 567                                 break;
 568                         case 1:
 569                                 items_sensitive(TRUE);
 570                                 file_item = selected_item(
 571                                                 filer_window->collection);
 572                                 g_string_sprintf(buffer, "%s '%s'",
 573                                                 basetype_name(file_item),
 574                                                 file_item->leafname);
 575                                 break;
 576                         default:
 577                                 items_sensitive(FALSE);
 578                                 g_string_sprintf(buffer, _("%d items"),
 579                                                 collection->number_selected);
 580                                 break;
 581                 }
 582                 gtk_label_set_text(GTK_LABEL(file_label), buffer->str);
 583                 g_string_free(buffer, TRUE);
 584         }
 585
 586
 587         gtk_widget_set_sensitive(filer_new_window, !o_unique_filer_windows);
 588
 589         if (filer_window->panel_type)
 590                 popup_menu = panel_menu;
 591         else
 592                 popup_menu = (event->state & GDK_CONTROL_MASK)
 593                                 ? filer_file_menu
 594                                 : filer_menu;
 595
 596         updating_menu--;
 597
 598         gtk_menu_popup(GTK_MENU(popup_menu), NULL, NULL, position_menu,
 599                         (gpointer) pos, event->button, event->time);
 600 }
 601
 602 static void pin_menu_closed(GtkWidget *widget)
 603 {
 604         if (pin_temp_item_selected)
 605                 pinboard_clear_selection();
 606 }
 607
 608 static void menu_closed(GtkWidget *widget)
 609 {
 610         if (window_with_focus == NULL || widget != popup_menu)
 611                 return;                 /* Close panel item chosen? */
 612
 613         if (window_with_focus->temp_item_selected)
 614         {
 615                 collection_clear_selection(window_with_focus->collection);
 616                 window_with_focus->temp_item_selected = FALSE;
 617         }
 618 }
 619
 620 void target_callback(Collection *collection, gint item, gpointer real_fn)
 621 {
 622         g_return_if_fail(window_with_focus != NULL);
 623         g_return_if_fail(window_with_focus->collection == collection);
 624         g_return_if_fail(real_fn != NULL);
 625
 626         collection_wink_item(collection, item);
 627         collection_clear_selection(collection);
 628         collection_select_item(collection, item);
 629         ((CollectionTargetFunc)real_fn)(NULL, 0, collection);
 630         if (item < collection->number_of_items)
 631                 collection_unselect_item(collection, item);
 632 }
 633
 634 /* Actions */
 635
 636 static void large(gpointer data, guint action, GtkWidget *widget)
 637 {
 638         g_return_if_fail(window_with_focus != NULL);
 639
 640         display_style_set(window_with_focus, LARGE_ICONS);
 641 }
 642
 643 static void small(gpointer data, guint action, GtkWidget *widget)
 644 {
 645         g_return_if_fail(window_with_focus != NULL);
 646
 647         display_style_set(window_with_focus, SMALL_ICONS);
 648 }
 649
 650 static void large_with(gpointer data, guint action, GtkWidget *widget)
 651 {
 652         g_return_if_fail(window_with_focus != NULL);
 653
 654         display_style_set(window_with_focus, LARGE_FULL_INFO);
 655         display_details_set(window_with_focus, (DetailsType) action);
 656 }
 657
 658 static void small_with(gpointer data, guint action, GtkWidget *widget)
 659 {
 660         g_return_if_fail(window_with_focus != NULL);
 661
 662         display_style_set(window_with_focus, SMALL_FULL_INFO);
 663         display_details_set(window_with_focus, (DetailsType) action);
 664 }
 665
 666 static void sort_name(gpointer data, guint action, GtkWidget *widget)
 667 {
 668         g_return_if_fail(window_with_focus != NULL);
 669
 670         display_set_sort_fn(window_with_focus, sort_by_name);
 671 }
 672
 673 static void sort_type(gpointer data, guint action, GtkWidget *widget)
 674 {
 675         g_return_if_fail(window_with_focus != NULL);
 676
 677         display_set_sort_fn(window_with_focus, sort_by_type);
 678 }
 679
 680 static void sort_date(gpointer data, guint action, GtkWidget *widget)
 681 {
 682         g_return_if_fail(window_with_focus != NULL);
 683
 684         display_set_sort_fn(window_with_focus, sort_by_date);
 685 }
 686
 687 static void sort_size(gpointer data, guint action, GtkWidget *widget)
 688 {
 689         g_return_if_fail(window_with_focus != NULL);
 690
 691         display_set_sort_fn(window_with_focus, sort_by_size);
 692 }
 693
 694 static void hidden(gpointer data, guint action, GtkWidget *widget)
 695 {
 696         if (updating_menu)
 697                 return;
 698
 699         g_return_if_fail(window_with_focus != NULL);
 700
 701         display_set_hidden(window_with_focus, !window_with_focus->show_hidden);
 702 }
 703
 704 static void refresh(gpointer data, guint action, GtkWidget *widget)
 705 {
 706         g_return_if_fail(window_with_focus != NULL);
 707
 708         full_refresh();
 709         filer_update_dir(window_with_focus, TRUE);
 710 }
 711
 712 static void mount(gpointer data, guint action, GtkWidget *widget)
 713 {
 714         g_return_if_fail(window_with_focus != NULL);
 715
 716         if (window_with_focus->collection->number_selected == 0)
 717                 collection_target(window_with_focus->collection,
 718                                 target_callback, mount);
 719         else
 720         {
 721                 GList   *paths;
 722
 723                 paths = list_paths(window_with_focus);
 724                 action_mount(paths);
 725                 free_paths(paths);
 726         }
 727 }
 728
 729 static void delete(gpointer data, guint action, GtkWidget *widget)
 730 {
 731         g_return_if_fail(window_with_focus != NULL);
 732
 733         if (window_with_focus->collection->number_selected == 0)
 734                 collection_target(window_with_focus->collection,
 735                                 target_callback, delete);
 736         else
 737                 action_delete(window_with_focus);
 738 }
 739
 740 static void remove_link(gpointer data, guint action, GtkWidget *widget)
 741 {
 742         g_return_if_fail(window_with_focus != NULL);
 743
 744         if (window_with_focus->collection->number_selected > 1)
 745         {
 746                 report_error(PROJECT,
 747                                 _("You can only remove one link at a time"));
 748                 return;
 749         }
 750         else if (window_with_focus->collection->number_selected == 0)
 751                 collection_target(window_with_focus->collection,
 752                                 target_callback, remove_link);
 753         else
 754         {
 755                 struct stat info;
 756                 DirItem *item;
 757                 guchar  *path;
 758
 759                 item = selected_item(window_with_focus->collection);
 760
 761                 path = make_path(window_with_focus->path, item->leafname)->str;
 762                 if (lstat(path, &info))
 763                         report_error(PROJECT, g_strerror(errno));
 764                 else if (!S_ISLNK(info.st_mode))
 765                         report_error(PROJECT,
 766                               _("You can only remove symbolic links this way - "
 767                                 "try the 'Open Panel as Directory' item."));
 768                 else if (unlink(path))
 769                         report_error(PROJECT, g_strerror(errno));
 770                 else
 771                         filer_update_dir(window_with_focus, TRUE);
 772         }
 773 }
 774
 775 static void usage(gpointer data, guint action, GtkWidget *widget)
 776 {
 777         g_return_if_fail(window_with_focus != NULL);
 778
 779         if (window_with_focus->collection->number_selected == 0)
 780                 collection_target(window_with_focus->collection,
 781                                 target_callback, usage);
 782         else
 783                 action_usage(window_with_focus);
 784 }
 785
 786 static void chmod_items(gpointer data, guint action, GtkWidget *widget)
 787 {
 788         g_return_if_fail(window_with_focus != NULL);
 789
 790         if (window_with_focus->collection->number_selected == 0)
 791                 collection_target(window_with_focus->collection,
 792                                 target_callback, chmod_items);
 793         else
 794                 action_chmod(window_with_focus);
 795 }
 796
 797 static void find(gpointer data, guint action, GtkWidget *widget)
 798 {
 799         g_return_if_fail(window_with_focus != NULL);
 800
 801         if (window_with_focus->collection->number_selected == 0)
 802                 collection_target(window_with_focus->collection,
 803                                 target_callback, find);
 804         else
 805                 action_find(window_with_focus);
 806 }
 807
 808 /* This pops up our savebox widget, cancelling any currently open one,
 809  * and allows the user to pick a new path for it.
 810  * Once the new path has been picked, the callback will be called with
 811  * both the current and new paths.
 812  */
 813 static void savebox_show(guchar *title, guchar *path, MaskedPixmap *image,
 814                 gboolean (*callback)(guchar *current, guchar *new))
 815 {
 816         if (GTK_WIDGET_VISIBLE(savebox))
 817                 gtk_widget_hide(savebox);
 818
 819         if (current_path)
 820                 g_free(current_path);
 821         current_path = g_strdup(path);
 822         current_savebox_callback = callback;
 823
 824         gtk_window_set_title(GTK_WINDOW(savebox), title);
 825         gtk_savebox_set_pathname(GTK_SAVEBOX(savebox), current_path);
 826         gtk_savebox_set_icon(GTK_SAVEBOX(savebox), image->pixmap, image->mask);
 827
 828         gtk_widget_grab_focus(GTK_SAVEBOX(savebox)->entry);
 829         gtk_widget_show(savebox);
 830 }
 831
 832 static gint save_to_file(GtkSavebox *savebox, guchar *pathname)
 833 {
 834         g_return_val_if_fail(current_savebox_callback != NULL,
 835                         GTK_XDS_SAVE_ERROR);
 836
 837         return current_savebox_callback(current_path, pathname)
 838                         ? GTK_XDS_SAVED : GTK_XDS_SAVE_ERROR;
 839 }
 840
 841 static gboolean copy_cb(guchar *current, guchar *new)
 842 {
 843         char    *new_dir, *leaf;
 844         GSList  *local_paths;
 845
 846         if (new[0] != '/')
 847         {
 848                 report_error(PROJECT, _("New pathname is not absolute"));
 849                 return FALSE;
 850         }
 851
 852         if (new[strlen(new) - 1] == '/')
 853         {
 854                 new_dir = g_strdup(new);
 855                 leaf = NULL;
 856         }
 857         else
 858         {
 859                 guchar *slash;
 860
 861                 slash = strrchr(new, '/');
 862                 new_dir = g_strndup(new, slash - new);
 863                 leaf = slash + 1;
 864         }
 865
 866         local_paths = g_slist_append(NULL, current);
 867         action_copy(local_paths, new_dir, leaf);
 868         g_slist_free(local_paths);
 869
 870         g_free(new_dir);
 871
 872         return TRUE;
 873 }
 874
 875 #define SHOW_SAVEBOX(title, callback)   \
 876 {       \
 877         DirItem *item;  \
 878         guchar  *path;  \
 879         item = selected_item(collection);       \
 880         path = make_path(window_with_focus->path, item->leafname)->str; \
 881         savebox_show(title, path, item->image, callback);       \
 882 }
 883
 884 static void copy_item(gpointer data, guint action, GtkWidget *widget)
 885 {
 886         Collection *collection;
 887
 888         g_return_if_fail(window_with_focus != NULL);
 889
 890         collection = window_with_focus->collection;
 891         if (collection->number_selected > 1)
 892         {
 893                 report_error(PROJECT, _("You cannot do this to more than "
 894                                                 "one item at a time"));
 895                 return;
 896         }
 897         else if (collection->number_selected != 1)
 898                 collection_target(collection, target_callback, copy_item);
 899         else
 900                 SHOW_SAVEBOX(_("Copy"), copy_cb);
 901 }
 902
 903 static gboolean rename_cb(guchar *current, guchar *new)
 904 {
 905         if (rename(current, new))
 906         {
 907                 report_error("ROX-Filer: rename()", g_strerror(errno));
 908                 return FALSE;
 909         }
 910         return TRUE;
 911 }
 912
 913 static void rename_item(gpointer data, guint action, GtkWidget *widget)
 914 {
 915         Collection *collection;
 916
 917         g_return_if_fail(window_with_focus != NULL);
 918
 919         collection = window_with_focus->collection;
 920         if (collection->number_selected > 1)
 921         {
 922                 report_error(PROJECT, _("You cannot do this to more than "
 923                                 "one item at a time"));
 924                 return;
 925         }
 926         else if (collection->number_selected != 1)
 927                 collection_target(collection, target_callback, rename_item);
 928         else
 929                 SHOW_SAVEBOX(_("Rename"), rename_cb);
 930 }
 931
 932 static gboolean link_cb(guchar *initial, guchar *path)
 933 {
 934         if (symlink(initial, path))
 935         {
 936                 report_error("ROX-Filer: symlink()", g_strerror(errno));
 937                 return FALSE;
 938         }
 939         return TRUE;
 940 }
 941
 942 static void link_item(gpointer data, guint action, GtkWidget *widget)
 943 {
 944         Collection *collection;
 945
 946         g_return_if_fail(window_with_focus != NULL);
 947
 948         collection = window_with_focus->collection;
 949         if (collection->number_selected > 1)
 950         {
 951                 report_error(PROJECT, _("You cannot do this to more than "
 952                                 "one item at a time"));
 953                 return;
 954         }
 955         else if (collection->number_selected != 1)
 956                 collection_target(collection, target_callback, link_item);
 957         else
 958                 SHOW_SAVEBOX(_("Symlink"), link_cb);
 959 }
 960
 961 static void open_file(gpointer data, guint action, GtkWidget *widget)
 962 {
 963         Collection *collection;
 964
 965         g_return_if_fail(window_with_focus != NULL);
 966
 967         collection = window_with_focus->collection;
 968         if (collection->number_selected > 1)
 969         {
 970                 report_error(PROJECT, _("You cannot do this to more than "
 971                                 "one item at a time"));
 972                 return;
 973         }
 974         else if (collection->number_selected != 1)
 975                 collection_target(collection, target_callback, open_file);
 976         else
 977                 filer_openitem(window_with_focus,
 978                                 selected_item_number(collection),
 979                                 OPEN_SAME_WINDOW | OPEN_SHIFT);
 980 }
 981
 982 /* Got some data from file(1) - stick it in the window. */
 983 static void add_file_output(FileStatus *fs,
 984                             gint source, GdkInputCondition condition)
 985 {
 986         char    buffer[20];
 987         char    *str;
 988         int     got;
 989
 990         got = read(source, buffer, sizeof(buffer) - 1);
 991         if (got <= 0)
 992         {
 993                 int     err = errno;
 994                 gtk_input_remove(fs->input);
 995                 close(source);
 996                 fs->fd = -1;
 997                 if (got < 0)
 998                         delayed_error(_("ROX-Filer: file(1) says..."),
 999                                         g_strerror(err));
1000                 return;
1001         }
1002         buffer[got] = '\0';
1003
1004         if (fs->start)
1005         {
1006                 str = "";
1007                 fs->start = FALSE;
1008         }
1009         else
1010                 gtk_label_get(fs->label, &str);
1011
1012         str = g_strconcat(str, buffer, NULL);
1013         gtk_label_set_text(fs->label, str);
1014         g_free(str);
1015 }
1016
1017 static void file_info_destroyed(GtkWidget *widget, FileStatus *fs)
1018 {
1019         if (fs->fd != -1)
1020         {
1021                 gtk_input_remove(fs->input);
1022                 close(fs->fd);
1023         }
1024
1025         g_free(fs);
1026 }
1027
1028 /* g_free() the result */
1029 guchar *pretty_type(DirItem *file, guchar *path)
1030 {
1031         if (file->flags & ITEM_FLAG_SYMLINK)
1032         {
1033                 char    p[MAXPATHLEN + 1];
1034                 int     got;
1035                 got = readlink(path, p, MAXPATHLEN);
1036                 if (got > 0 && got <= MAXPATHLEN)
1037                 {
1038                         p[got] = '\0';
1039                         return g_strconcat(_("Symbolic link to "), p, NULL);
1040                 }
1041
1042                 return g_strdup(_("Symbolic link"));
1043         }
1044
1045         if (file->flags & ITEM_FLAG_EXEC_FILE)
1046                 return g_strdup(_("Executable file"));
1047
1048         if (file->flags & ITEM_FLAG_APPDIR)
1049                 return g_strdup(_("ROX application"));
1050
1051         if (file->flags & ITEM_FLAG_MOUNT_POINT)
1052         {
1053                 MountPoint *mp;
1054                 if ((file->flags & ITEM_FLAG_MOUNTED) &&
1055                         (mp = g_hash_table_lookup(mtab_mounts, path)))
1056                         return g_strconcat(_("Mount point for "),
1057                                         mp->name, NULL);
1058
1059                 return g_strdup(_("Mount point"));
1060         }
1061
1062         if (file->mime_type)
1063                 return g_strconcat(file->mime_type->media_type, "/",
1064                                 file->mime_type->subtype, NULL);
1065
1066         return g_strdup("-");
1067 }
1068
1069 #define LABEL(text, row)                                                \
1070         label = gtk_label_new(text);                            \
1071         gtk_misc_set_alignment(GTK_MISC(label), 1, .5);                 \
1072         gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT);     \
1073         gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, row, row + 1);
1074
1075 #define VALUE(label, row)                                               \
1076         gtk_misc_set_alignment(GTK_MISC(label), 0, .5);                 \
1077         gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, row, row + 1);
1078
1079 static void show_file_info(gpointer data, guint action, GtkWidget *widget)
1080 {
1081         GtkWidget       *window, *table, *label, *button, *frame, *value;
1082         GtkWidget       *file_label;
1083         GString         *gstring;
1084         int             file_data[2];
1085         guchar          *path, *tmp;
1086         char            *argv[] = {"file", "-b", NULL, NULL};
1087         Collection      *collection;
1088         DirItem         *file;
1089         struct stat     info;
1090         FileStatus      *fs = NULL;
1091         guint           perm;
1092
1093         g_return_if_fail(window_with_focus != NULL);
1094
1095         collection = window_with_focus->collection;
1096         if (collection->number_selected > 1)
1097         {
1098                 report_error(PROJECT, _("You cannot do this to more than "
1099                                 "one item at a time"));
1100                 return;
1101         }
1102         else if (collection->number_selected != 1)
1103         {
1104                 collection_target(collection, target_callback, show_file_info);
1105                 return;
1106         }
1107         file = selected_item(collection);
1108         path = make_path(window_with_focus->path,
1109                         file->leafname)->str;
1110         if (lstat(path, &info))
1111         {
1112                 delayed_error(PROJECT, g_strerror(errno));
1113                 return;
1114         }
1115
1116         gstring = g_string_new(NULL);
1117
1118         window = gtk_window_new(GTK_WINDOW_DIALOG);
1119         gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_MOUSE);
1120         gtk_container_set_border_width(GTK_CONTAINER(window), 4);
1121         gtk_window_set_title(GTK_WINDOW(window), path);
1122
1123         table = gtk_table_new(10, 2, FALSE);
1124         gtk_container_add(GTK_CONTAINER(window), table);
1125         gtk_table_set_row_spacings(GTK_TABLE(table), 8);
1126         gtk_table_set_col_spacings(GTK_TABLE(table), 4);
1127
1128         value = gtk_label_new(file->leafname);
1129         LABEL(_("Name:"), 0);
1130         VALUE(value, 0);
1131
1132         g_string_sprintf(gstring, "%s, %s", user_name(info.st_uid),
1133                                             group_name(info.st_gid));
1134         value = gtk_label_new(gstring->str);
1135         LABEL(_("Owner, Group:"), 1);
1136         VALUE(value, 1);
1137
1138         if (info.st_size >= PRETTY_SIZE_LIMIT)
1139         {
1140                 g_string_sprintf(gstring, "%s (%ld %s)",
1141                                 format_size((unsigned long) info.st_size),
1142                                 (unsigned long) info.st_size, _("bytes"));
1143         }
1144         else
1145         {
1146                 g_string_assign(gstring,
1147                                 format_size((unsigned long) info.st_size));
1148         }
1149         value = gtk_label_new(gstring->str);
1150         LABEL(_("Size:"), 2);
1151         VALUE(value, 2);
1152
1153         value = gtk_label_new(pretty_time(&info.st_ctime));
1154         LABEL(_("Change time:"), 3);
1155         VALUE(value, 3);
1156
1157         value = gtk_label_new(pretty_time(&info.st_mtime));
1158         LABEL(_("Modify time:"), 4);
1159         VALUE(value, 4);
1160
1161         value = gtk_label_new(pretty_time(&info.st_atime));
1162         LABEL(_("Access time:"), 5);
1163         VALUE(value, 5);
1164
1165         value = gtk_label_new(pretty_permissions(info.st_mode));
1166         perm = applicable(info.st_uid, info.st_gid);
1167         gtk_label_set_pattern(GTK_LABEL(value),
1168                         perm == 0 ? "___        " :
1169                         perm == 1 ? "    ___    " :
1170                                     "        ___");
1171         gtk_widget_set_style(value, fixed_style);
1172         LABEL(_("Permissions:"), 6);
1173         VALUE(value, 6);
1174
1175         tmp = pretty_type(file, path);
1176         value = gtk_label_new(tmp);
1177         g_free(tmp);
1178         LABEL(_("Type:"), 7);
1179         VALUE(value, 7);
1180
1181         frame = gtk_frame_new(_("file(1) says..."));
1182         gtk_table_attach_defaults(GTK_TABLE(table), frame, 0, 2, 8, 9);
1183         file_label = gtk_label_new(_("<nothing yet>"));
1184         gtk_misc_set_padding(GTK_MISC(file_label), 4, 4);
1185         gtk_label_set_line_wrap(GTK_LABEL(file_label), TRUE);
1186         gtk_container_add(GTK_CONTAINER(frame), file_label);
1187
1188         button = gtk_button_new_with_label(_("OK"));
1189         gtk_window_set_focus(GTK_WINDOW(window), button);
1190         gtk_table_attach(GTK_TABLE(table), button, 0, 2, 10, 11,
1191                         GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 40, 4);
1192         gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
1193                         gtk_widget_destroy, GTK_OBJECT(window));
1194
1195         gtk_widget_show_all(window);
1196         gdk_flush();
1197
1198         if (pipe(file_data))
1199         {
1200                 g_string_sprintf(gstring, "pipe(): %s", g_strerror(errno));
1201                 g_string_free(gstring, TRUE);
1202                 return;
1203         }
1204         switch (fork())
1205         {
1206                 case -1:
1207                         g_string_sprintf(gstring, "fork(): %s",
1208                                         g_strerror(errno));
1209                         gtk_label_set_text(GTK_LABEL(file_label), gstring->str);
1210                         g_string_free(gstring, TRUE);
1211                         close(file_data[0]);
1212                         close(file_data[1]);
1213                         break;
1214                 case 0:
1215                         /* We are the child */
1216                         close(file_data[0]);
1217                         dup2(file_data[1], STDOUT_FILENO);
1218                         dup2(file_data[1], STDERR_FILENO);
1219 #ifdef FILE_B_FLAG
1220                         argv[2] = path;
1221 #else
1222                         argv[1] = file->leafname;
1223                         chdir(window_with_focus->path);
1224 #endif
1225                         if (execvp(argv[0], argv))
1226                                 fprintf(stderr, "execvp() error: %s\n",
1227                                                 g_strerror(errno));
1228                         _exit(0);
1229                 default:
1230                         /* We are the parent */
1231                         close(file_data[1]);
1232                         fs = g_new(FileStatus, 1);
1233                         fs->label = GTK_LABEL(file_label);
1234                         fs->fd = file_data[0];
1235                         fs->start = TRUE;
1236                         fs->input = gdk_input_add(fs->fd, GDK_INPUT_READ,
1237                                 (GdkInputFunction) add_file_output, fs);
1238                         gtk_signal_connect(GTK_OBJECT(window), "destroy",
1239                                 GTK_SIGNAL_FUNC(file_info_destroyed), fs);
1240                         g_string_free(gstring, TRUE);
1241                         break;
1242         }
1243 }
1244
1245 static void help(gpointer data, guint action, GtkWidget *widget)
1246 {
1247         Collection      *collection;
1248         DirItem *item;
1249
1250         g_return_if_fail(window_with_focus != NULL);
1251
1252         collection = window_with_focus->collection;
1253         if (collection->number_selected > 1)
1254         {
1255                 report_error(PROJECT, _("You cannot do this to more than "
1256                                 "one item at a time"));
1257                 return;
1258         }
1259         else if (collection->number_selected != 1)
1260         {
1261                 collection_target(collection, target_callback, help);
1262                 return;
1263         }
1264         item = selected_item(collection);
1265
1266         show_item_help(make_path(window_with_focus->path, item->leafname)->str,
1267                         item);
1268 }
1269
1270 #define OPEN_VFS(fs)            \
1271 static void open_vfs_ ## fs (gpointer data, guint action, GtkWidget *widget) \
1272 {                                                       \
1273         Collection      *collection;                    \
1274                                                         \
1275         g_return_if_fail(window_with_focus != NULL);    \
1276                                                         \
1277         collection = window_with_focus->collection;     \
1278         if (collection->number_selected < 1)                    \
1279                 collection_target(collection, target_callback,  \
1280                                                 open_vfs_ ## fs);       \
1281         else                                                            \
1282                 real_vfs_open(#fs);                     \
1283 }
1284
1285 static void real_vfs_open(char *fs)
1286 {
1287         gchar           *path;
1288         DirItem         *item;
1289
1290         if (window_with_focus->collection->number_selected != 1)
1291         {
1292                 report_error(PROJECT, _("You must select a single file "
1293                                 "to open as a Virtual File System"));
1294                 return;
1295         }
1296
1297         item = selected_item(window_with_focus->collection);
1298
1299         path = g_strconcat(window_with_focus->path,
1300                         "/",
1301                         item->leafname,
1302                         "#", fs, NULL);
1303
1304         filer_change_to(window_with_focus, path, NULL);
1305         g_free(path);
1306 }
1307
1308 OPEN_VFS(rpm)
1309 OPEN_VFS(utar)
1310 OPEN_VFS(uzip)
1311
1312 static void select_all(gpointer data, guint action, GtkWidget *widget)
1313 {
1314         g_return_if_fail(window_with_focus != NULL);
1315
1316         collection_select_all(window_with_focus->collection);
1317         window_with_focus->temp_item_selected = FALSE;
1318 }
1319
1320 static void clear_selection(gpointer data, guint action, GtkWidget *widget)
1321 {
1322         g_return_if_fail(window_with_focus != NULL);
1323
1324         collection_clear_selection(window_with_focus->collection);
1325         window_with_focus->temp_item_selected = FALSE;
1326 }
1327
1328 static void show_options(gpointer data, guint action, GtkWidget *widget)
1329 {
1330         options_show();
1331 }
1332
1333 static gboolean new_directory_cb(guchar *initial, guchar *path)
1334 {
1335         if (mkdir(path, S_IRWXU | S_IRWXG | S_IRWXO))
1336         {
1337                 report_error("mkdir", g_strerror(errno));
1338                 return FALSE;
1339         }
1340
1341         dir_check_this(path);
1342         return TRUE;
1343 }
1344
1345 static void new_directory(gpointer data, guint action, GtkWidget *widget)
1346 {
1347         g_return_if_fail(window_with_focus != NULL);
1348
1349         savebox_show(_("New Directory"),
1350                         make_path(window_with_focus->path, _("NewDir"))->str,
1351                         type_to_icon(&special_directory),
1352                         new_directory_cb);
1353 }
1354
1355 static void xterm_here(gpointer data, guint action, GtkWidget *widget)
1356 {
1357         char    *argv[] = {NULL, NULL};
1358
1359         argv[0] = xterm_here_value;
1360
1361         g_return_if_fail(window_with_focus != NULL);
1362
1363         if (!spawn_full(argv, window_with_focus->path))
1364                 report_error(PROJECT, "Failed to fork() child "
1365                                         "process");
1366 }
1367
1368 static void open_parent(gpointer data, guint action, GtkWidget *widget)
1369 {
1370         g_return_if_fail(window_with_focus != NULL);
1371
1372         filer_open_parent(window_with_focus);
1373 }
1374
1375 static void open_parent_same(gpointer data, guint action, GtkWidget *widget)
1376 {
1377         g_return_if_fail(window_with_focus != NULL);
1378
1379         change_to_parent(window_with_focus);
1380 }
1381
1382 static void new_window(gpointer data, guint action, GtkWidget *widget)
1383 {
1384         g_return_if_fail(window_with_focus != NULL);
1385
1386         if (o_unique_filer_windows)
1387                 report_error(PROJECT, _("You can't open a second view onto "
1388                         "this directory because the `Unique Windows' option "
1389                         "is turned on in the Options window."));
1390         else
1391                 filer_opendir(window_with_focus->path, PANEL_NO);
1392 }
1393
1394 static void close_window(gpointer data, guint action, GtkWidget *widget)
1395 {
1396         g_return_if_fail(window_with_focus != NULL);
1397
1398         gtk_widget_destroy(window_with_focus->window);
1399 }
1400
1401 static void enter_path(gpointer data, guint action, GtkWidget *widget)
1402 {
1403         g_return_if_fail(window_with_focus != NULL);
1404
1405         minibuffer_show(window_with_focus, MINI_PATH);
1406 }
1407
1408 static void shell_command(gpointer data, guint action, GtkWidget *widget)
1409 {
1410         g_return_if_fail(window_with_focus != NULL);
1411
1412         minibuffer_show(window_with_focus, MINI_SHELL);
1413 }
1414
1415 static void run_action(gpointer data, guint action, GtkWidget *widget)
1416 {
1417         g_return_if_fail(window_with_focus != NULL);
1418
1419         minibuffer_show(window_with_focus, MINI_RUN_ACTION);
1420 }
1421
1422 static void select_if(gpointer data, guint action, GtkWidget *widget)
1423 {
1424         g_return_if_fail(window_with_focus != NULL);
1425
1426         minibuffer_show(window_with_focus, MINI_SELECT_IF);
1427 }
1428
1429 void rox_help(gpointer data, guint action, GtkWidget *widget)
1430 {
1431         filer_opendir(make_path(getenv("APP_DIR"), "Help")->str, PANEL_NO);
1432 }
1433
1434 static void open_as_dir(gpointer data, guint action, GtkWidget *widget)
1435 {
1436         g_return_if_fail(window_with_focus != NULL);
1437
1438         filer_opendir(window_with_focus->path, PANEL_NO);
1439 }
1440
1441 static void close_panel(gpointer data, guint action, GtkWidget *widget)
1442 {
1443         g_return_if_fail(window_with_focus != NULL);
1444
1445         gtk_widget_destroy(window_with_focus->window);
1446 }
1447
1448 /* Return a list of full paths of all the selected items */
1449 static GList *list_paths(FilerWindow *filer_window)
1450 {
1451         Collection      *collection = filer_window->collection;
1452         GList           *paths = NULL;
1453         int             i;
1454
1455         for (i = 0; i < collection->number_of_items; i++)
1456         {
1457                 CollectionItem  *colitem = &collection->items[i];
1458
1459                 if (colitem->selected)
1460                 {
1461                         DirItem *item = (DirItem *) colitem->data;
1462
1463                         paths = g_list_prepend(paths,
1464                                 g_strdup(make_path(filer_window->path,
1465                                                    item->leafname)->str));
1466                 }
1467         }
1468
1469         return paths;
1470 }
1471
1472 static void free_paths(GList *paths)
1473 {
1474         GList   *next;
1475
1476         if (!paths)
1477                 return;
1478
1479         for (next = paths; next; next = next->next)
1480                 g_free(next->data);
1481
1482         g_list_free(paths);
1483 }
1484
1485 static void pin_help(gpointer data, guint action, GtkWidget *widget)
1486 {
1487         PinIcon *icon;
1488
1489         icon = pinboard_selected_icon();
1490
1491         if (icon)
1492                 pinboard_show_help(icon);
1493         else
1494                 delayed_error(PROJECT,
1495                         _("You must first select a single pinned icon to get "
1496                         "help on."));
1497 }
1498
1499 static void pin_remove(gpointer data, guint action, GtkWidget *widget)
1500 {
1501         pinboard_unpin_selection();
1502 }
1503
1504 /* Set n items from position 'from' in 'menu' to the 'shaded' state */
1505 static void set_items_shaded(GtkWidget *menu, gboolean shaded, int from, int n)
1506 {
1507         GList   *items, *item;
1508
1509         items = gtk_container_children(GTK_CONTAINER(menu));
1510
1511         item = g_list_nth(items, from);
1512         while (item && n--)
1513         {
1514                 gtk_widget_set_sensitive(GTK_BIN(item->data)->child, !shaded);
1515                 item = item->next;
1516         }
1517         g_list_free(items);
1518 }
1519
1520 static void save_menus(void)
1521 {
1522         char    *menurc;
1523
1524         menurc = choices_find_path_save("menus", PROJECT, TRUE);
1525         if (menurc)
1526                 gtk_item_factory_dump_rc(menurc, NULL, TRUE);
1527 }