gnome/gcmd.c

   1 /*
   2  * Various Menu-invoked Command implementations specific to the GNOME port
   3  *
   4  * Copyright (C) 1998 the Free Software Foundation
   5  *
   6  * Author: Miguel de Icaza (miguel@kernel.org)
   7  */
   8 #include <config.h>
   9 #include "x.h"
  10 #include <stdio.h>
  11 #include <sys/stat.h>
  12 #include "dir.h"
  13 #include "panel.h"
  14 #include "gscreen.h"
  15 #include "main.h"
  16 #include "gmain.h"
  17 #include "cmd.h"
  18 #include "boxes.h"
  19 #include "profile.h"
  20 #include "setup.h"
  21 #include "panelize.h"
  22 #include "gcmd.h"
  23 #include "dialog.h"
  24 #include "layout.h"
  25 #include "../vfs/vfs.h"
  26
  27 enum {
  28         SORT_NAME,
  29         SORT_EXTENSION,
  30         SORT_ACCESS,
  31         SORT_MODIFY,
  32         SORT_CHANGE,
  33         SORT_SIZE
  34 };
  35
  36 static char *panelize_section = "Panelize";
  37
  38 void
  39 gnome_listing_cmd (GtkWidget *widget, WPanel *panel)
  40 {
  41         int   view_type, use_msformat;
  42         char  *user, *status;
  43
  44         view_type = display_box (panel, &user, &status, &use_msformat, get_current_index ());
  45
  46         if (view_type == -1)
  47                 return;
  48
  49         configure_panel_listing (panel, view_type, use_msformat, user, status);
  50 }
  51
  52 void
  53 gnome_compare_panels (void)
  54 {
  55         if (get_other_panel () == NULL){
  56                 message (1, MSG_ERROR, _(" There is no other panel to compare contents to "));
  57                 return;
  58         }
  59         compare_dirs_cmd ();
  60 }
  61
  62 void
  63 gnome_open_terminal (void)
  64 {
  65         char *p;
  66
  67         if (!(p = gnome_is_program_in_path ("gnome-terminal")))
  68                 if (!(p = gnome_is_program_in_path ("dtterm")))
  69                         if (!(p = gnome_is_program_in_path ("nxterm")))
  70                                 if (!(p = gnome_is_program_in_path ("color-xterm")))
  71                                         if (!(p = gnome_is_program_in_path ("rxvt")))
  72                                                 p = gnome_is_program_in_path ("xterm");
  73
  74         if (p)
  75                 my_system (EXECUTE_AS_SHELL, shell, p);
  76         else
  77                 message (1, MSG_ERROR, " Could not start a terminal ");
  78 }
  79
  80 void
  81 gnome_about_cmd (void)
  82 {
  83         GtkWidget *about;
  84         const gchar *authors[] = {
  85                 "The Midnight Commander Team",
  86                 "http://www.gnome.org/mc/",
  87                 "bug reports: mc-bugs@nuclecu.unam.mx",
  88                 NULL
  89         };
  90
  91         about = gnome_about_new (_("GNU Midnight Commander"), VERSION,
  92                                  "Copyright 1994-1999 the Free Software Foundation",
  93                                  authors,
  94                                  _("The GNOME edition of the Midnight Commander file manager."),
  95                                  NULL);
  96         gtk_widget_show (about);
  97 }
  98
  99 void
 100 gnome_quit_cmd (void)
 101 {
 102         int q = 0;
 103
 104         if (!confirm_exit)
 105                 q = 1;
 106         else if (query_dialog (_(" The Midnight Commander "),
 107                                _(" Do you really want to quit the Midnight Commander? "),
 108                                0, 2, _("&Yes"), _("&No")) == 0)
 109                 q = 1;
 110
 111         if (q == 1)
 112                 gtk_main_quit ();
 113 }
 114
 115 void
 116 gnome_open_panel (GtkWidget *widget, WPanel *panel)
 117 {
 118         new_panel_at (panel->cwd);
 119 }
 120
 121 int
 122 gnome_close_panel (GtkWidget *widget, WPanel *panel)
 123 {
 124         Dlg_head *h = panel->widget.parent;
 125         g_print ("closing the panel\n");
 126         if (panel->timer_id){
 127                 gtk_timeout_remove (panel->timer_id);
 128                 panel->timer_id = -1;
 129         }
 130
 131         /* Remove the widgets from the dialog head */
 132         remove_widget (h, panel->current_dir);
 133         remove_widget (h, panel->filter_w);
 134         remove_widget (h, panel);
 135
 136         /* Kill them */
 137         destroy_widget (panel->current_dir);
 138         destroy_widget (panel->filter_w);
 139         destroy_widget ((void *)panel);
 140
 141         layout_panel_gone (panel);
 142
 143         mc_chdir ("/");
 144         return TRUE;
 145 }
 146
 147 void
 148 gnome_icon_view_cmd (GtkWidget *widget, WPanel *panel)
 149 {
 150         if (panel->list_type == list_icons)
 151                 return;
 152         panel->list_type = list_icons;
 153         set_panel_formats (panel);
 154         paint_panel (panel);
 155         do_refresh ();
 156 }
 157 void
 158 gnome_partial_view_cmd (GtkWidget *widget, WPanel *panel)
 159 {
 160         if (panel->list_type == list_brief)
 161                 return;
 162         panel->list_type = list_brief;
 163         set_panel_formats (panel);
 164         paint_panel (panel);
 165         do_refresh ();
 166 }
 167 void
 168 gnome_full_view_cmd (GtkWidget *widget, WPanel *panel)
 169 {
 170         if (panel->list_type == list_full)
 171                 return;
 172         panel->list_type = list_full;
 173         set_panel_formats (panel);
 174         paint_panel (panel);
 175         do_refresh ();
 176 }
 177 void
 178 gnome_custom_view_cmd (GtkWidget *widget, WPanel *panel)
 179 {
 180         if (panel->list_type == list_user)
 181                 return;
 182         panel->list_type = list_user;
 183         set_panel_formats (panel);
 184         paint_panel (panel);
 185         do_refresh ();
 186 }
 187 static void
 188 sort_callback (GtkWidget *menu_item, GtkWidget *cbox1)
 189 {
 190         if (gtk_object_get_data (GTK_OBJECT (menu_item), "SORT_ORDER_CODE") == SORT_NAME)
 191                 gtk_widget_set_sensitive (cbox1, TRUE);
 192         else
 193                 gtk_widget_set_sensitive (cbox1, FALSE);
 194 }
 195 void
 196 gnome_sort_cmd (GtkWidget *widget, WPanel *panel)
 197 {
 198         GtkWidget *sort_box;
 199         GtkWidget *hbox;
 200         GtkWidget *omenu;
 201         GtkWidget *menu;
 202         GtkWidget *menu_item;
 203         GtkWidget *cbox1, *cbox2;
 204         sortfn *sfn = NULL;
 205
 206         sort_box = gnome_dialog_new (_("Sort By"), GNOME_STOCK_BUTTON_OK,
 207                                      GNOME_STOCK_BUTTON_CANCEL, NULL);
 208         gmc_window_setup_from_panel (GNOME_DIALOG (sort_box), panel);
 209
 210         /* we define this up here so we can pass it in to our callback */
 211         cbox1 = gtk_check_button_new_with_label (N_("Ignore case sensitivity."));
 212         hbox = gtk_hbox_new (FALSE, 0);
 213         gtk_box_pack_start (GTK_BOX (GNOME_DIALOG (sort_box)->vbox), hbox, FALSE, FALSE, 0);
 214         gtk_box_pack_start (GTK_BOX (hbox), gtk_label_new ("Sort files by "), FALSE, FALSE, 0);
 215
 216         omenu = gtk_option_menu_new ();
 217         gtk_box_pack_start (GTK_BOX (hbox), omenu, FALSE, FALSE, 0);
 218         menu = gtk_menu_new ();
 219         menu_item = gtk_menu_item_new_with_label ( _("Name"));
 220         /* FIXME: we want to set the option menu to be the correct ordering. */
 221         gtk_menu_append (GTK_MENU (menu), menu_item);
 222         gtk_object_set_data (GTK_OBJECT (menu_item), "SORT_ORDER_CODE", (gpointer) SORT_NAME);
 223         gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
 224                                    GTK_SIGNAL_FUNC (sort_callback), cbox1);
 225
 226         menu_item = gtk_menu_item_new_with_label ( _("File Type"));
 227         gtk_menu_append (GTK_MENU (menu), menu_item);
 228         gtk_object_set_data (GTK_OBJECT (menu_item), "SORT_ORDER_CODE", (gpointer) SORT_EXTENSION);
 229         gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
 230                                    GTK_SIGNAL_FUNC (sort_callback), cbox1);
 231
 232         menu_item = gtk_menu_item_new_with_label ( _("Size"));
 233         gtk_menu_append (GTK_MENU (menu), menu_item);
 234         gtk_object_set_data (GTK_OBJECT (menu_item), "SORT_ORDER_CODE", (gpointer) SORT_SIZE);
 235         gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
 236                                    GTK_SIGNAL_FUNC (sort_callback), cbox1);
 237
 238         menu_item = gtk_menu_item_new_with_label ( _("Time Last Accessed"));
 239         gtk_menu_append (GTK_MENU (menu), menu_item);
 240         gtk_object_set_data (GTK_OBJECT (menu_item), "SORT_ORDER_CODE", (gpointer) SORT_ACCESS);
 241         gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
 242                                    GTK_SIGNAL_FUNC (sort_callback), cbox1);
 243
 244         menu_item = gtk_menu_item_new_with_label ( _("Time Last Modified"));
 245         gtk_menu_append (GTK_MENU (menu), menu_item);
 246         gtk_object_set_data (GTK_OBJECT (menu_item), "SORT_ORDER_CODE", (gpointer) SORT_MODIFY);
 247         gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
 248                                    GTK_SIGNAL_FUNC (sort_callback), cbox1);
 249
 250         menu_item = gtk_menu_item_new_with_label ( _("Time Last Changed"));
 251         gtk_menu_append (GTK_MENU (menu), menu_item);
 252         gtk_object_set_data (GTK_OBJECT (menu_item), "SORT_ORDER_CODE", (gpointer) SORT_CHANGE);
 253         gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
 254                                    GTK_SIGNAL_FUNC (sort_callback), cbox1);
 255
 256         gtk_widget_show_all (menu);
 257         gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
 258
 259
 260         gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (cbox1), panel->case_sensitive);
 261         gtk_box_pack_start (GTK_BOX (GNOME_DIALOG (sort_box)->vbox),
 262                             cbox1, FALSE, FALSE, 0);
 263
 264         cbox2 = gtk_check_button_new_with_label (N_("Reverse the order."));
 265         gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (cbox2), panel->reverse);
 266         gtk_box_pack_start (GTK_BOX (GNOME_DIALOG (sort_box)->vbox),
 267                             cbox2, FALSE, FALSE, 0);
 268         /* off to the races */
 269         gtk_widget_show_all (GNOME_DIALOG (sort_box)->vbox);
 270         switch (gnome_dialog_run (GNOME_DIALOG (sort_box))) {
 271         case 0:
 272                 switch( (gint) gtk_object_get_data (GTK_OBJECT
 273                                                     (GTK_OPTION_MENU
 274                                                      (omenu)->menu_item),
 275                                                     "SORT_ORDER_CODE") ) {
 276                 case SORT_NAME:
 277                         sfn = (sortfn *) sort_name;
 278                         break;
 279                 case SORT_EXTENSION:
 280                         sfn = (sortfn *) sort_ext;
 281                         break;
 282                 case SORT_ACCESS:
 283                         sfn = (sortfn *) sort_atime;
 284                         break;
 285                 case SORT_MODIFY:
 286                         sfn = (sortfn *) sort_time;
 287                         break;
 288                 case SORT_CHANGE:
 289                         sfn = (sortfn *) sort_ctime;
 290                         break;
 291                 case SORT_SIZE:
 292                         sfn = (sortfn *) sort_size;
 293                         break;
 294                 }
 295                 /* case sensitive */
 296                 panel->case_sensitive = GTK_TOGGLE_BUTTON (cbox1)->active;
 297                 /* Reverse order */
 298                 panel->reverse = GTK_TOGGLE_BUTTON (cbox2)->active;
 299
 300                 panel_set_sort_order (panel, sfn);
 301                 break;
 302         case 1:
 303         default:
 304                 break;
 305         }
 306         gtk_widget_destroy (sort_box);
 307 }
 308 typedef struct ep_dlg_data {
 309         GtkWidget *ep_dlg;
 310         GtkWidget *clist;
 311         GtkWidget *entry;
 312         GtkWidget *add_button;
 313         GtkWidget *remove_button;
 314         gboolean setting_text;
 315         gint selected; /* if this is -1 then nothing is selected, otherwise, it's the row selected */
 316 } ep_dlg_data;
 317
 318 static gchar *
 319 get_nickname (gchar *text)
 320 {
 321         GtkWidget *dlg;
 322         GtkWidget *entry;
 323         GtkWidget *label;
 324         gchar *retval = NULL;
 325
 326         dlg = gnome_dialog_new (_("Enter name."), GNOME_STOCK_BUTTON_OK,
 327                                 GNOME_STOCK_BUTTON_CANCEL, NULL);
 328         gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
 329         entry = gtk_entry_new ();
 330         if (text)
 331                 gtk_entry_set_text (GTK_ENTRY (entry), text);
 332         label = gtk_label_new (_("Enter label for command:"));
 333         gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 334         gtk_box_pack_start (GTK_BOX (GNOME_DIALOG (dlg)->vbox),
 335                             label, FALSE, FALSE, 0);
 336         gtk_box_pack_start (GTK_BOX (GNOME_DIALOG (dlg)->vbox),
 337                             entry, FALSE, FALSE, 0);
 338         gtk_widget_show_all (GNOME_DIALOG (dlg)->vbox);
 339         switch (gnome_dialog_run (GNOME_DIALOG (dlg))) {
 340         case 0:
 341                 retval = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
 342                 break;
 343         case 1:
 344         default:
 345         }
 346         gtk_widget_destroy (dlg);
 347         return retval;
 348 }
 349 static void
 350 ep_add_callback (GtkWidget *widget, ep_dlg_data *data)
 351 {
 352         gint i;
 353         gchar *insert_tab[1];
 354
 355         insert_tab[0] = get_nickname (NULL);
 356         if (insert_tab[0] == NULL)
 357                 return;
 358         i = gtk_clist_append (GTK_CLIST (data->clist), insert_tab);
 359         gtk_clist_set_row_data (GTK_CLIST (data->clist), i,
 360                                 g_strdup (gtk_entry_get_text (GTK_ENTRY (data->entry))));
 361         g_free (insert_tab [0]);
 362         data->selected = -1;
 363         gtk_widget_set_sensitive (data->add_button, FALSE);
 364         gtk_entry_set_text (GTK_ENTRY (data->entry), "");
 365 }
 366 static void
 367 ep_remove_callback (GtkWidget *widget, ep_dlg_data *data)
 368 {
 369         if (data->selected > -1) {
 370                 g_free (gtk_clist_get_row_data (GTK_CLIST (data->clist), data->selected));
 371                 gtk_clist_remove (GTK_CLIST (data->clist), data->selected);
 372                 data->selected = -1;
 373                 gtk_entry_set_text (GTK_ENTRY (data->entry), "");
 374         }
 375         gtk_widget_set_sensitive (data->remove_button, FALSE);
 376 }
 377
 378 static void
 379 ep_select_callback (GtkWidget *widget,
 380                     gint row,
 381                     gint column,
 382                     GdkEventButton *event,
 383                     ep_dlg_data *data)
 384 {
 385         if (event && event->type == GDK_2BUTTON_PRESS) {
 386                 gchar *nick;
 387
 388                 gtk_clist_get_text (GTK_CLIST (widget), row, 0, &nick);
 389                 /* ugly but correct... (: */
 390                 nick = get_nickname (nick);
 391                 gtk_clist_set_text (GTK_CLIST (data->clist), row, 0, nick);
 392                 gtk_clist_select_row (GTK_CLIST (data->clist), row, 0);
 393         } else {
 394                 data->setting_text = TRUE;
 395                 gtk_entry_set_text (GTK_ENTRY (data->entry),
 396                                     (gchar *) gtk_clist_get_row_data (GTK_CLIST (widget), row));
 397                 data->setting_text = FALSE;
 398                 data->selected = row;
 399                 gtk_widget_set_sensitive (data->remove_button, TRUE);
 400                 gtk_widget_set_sensitive (data->add_button, FALSE);
 401         }
 402 }
 403 static void
 404 ep_text_changed_callback (GtkWidget *widget, ep_dlg_data *data)
 405 {
 406         if (data->setting_text)
 407                 /* we don't want to deselect text if we just clicked on something */
 408                 return;
 409         if (data->selected > -1) {
 410                 gtk_clist_unselect_row (GTK_CLIST (data->clist), data->selected, 0);
 411                 data->selected = -1;
 412         }
 413         gtk_widget_set_sensitive (data->remove_button, FALSE);
 414         gtk_widget_set_sensitive (data->add_button, TRUE);
 415 }
 416 static void
 417 load_settings (GtkCList *clist)
 418 {
 419         gchar *insert_tab[1];
 420         void *profile_keys;
 421         gchar *key, *value;
 422         gint i = 0;
 423
 424         profile_keys = profile_init_iterator (panelize_section, profile_name);
 425
 426         if (!profile_keys){
 427                 insert_tab[0] = _("Find all core files");
 428                 i = gtk_clist_insert (clist, i, insert_tab);
 429                 gtk_clist_set_row_data (clist, i, g_strdup ("find / -name core"));
 430                 insert_tab[0] = _("Find rejects after patching");
 431                 i = gtk_clist_insert (clist, i, insert_tab);
 432                 gtk_clist_set_row_data (clist, i, g_strdup ("find . -name \\*.rej -print"));
 433         } else {
 434                 while (profile_keys) {
 435                         profile_keys = profile_iterator_next (profile_keys, &key, &value);
 436                         insert_tab[0] = key;
 437                         i = gtk_clist_insert (clist, i, insert_tab);
 438                         gtk_clist_set_row_data (clist, i, g_strdup (value));
 439                 }
 440         }
 441 }
 442 static void
 443 save_settings (GtkCList *clist)
 444 {
 445         gint i;
 446         gchar *text;
 447
 448         profile_clean_section (panelize_section, profile_name);
 449         for (i = 0; i < GTK_CLIST (clist)->rows; i++) {
 450                 gtk_clist_get_text (GTK_CLIST (clist), i, 0, &text);
 451                 WritePrivateProfileString (panelize_section,
 452                                            text,
 453                                            (gchar *) gtk_clist_get_row_data (GTK_CLIST (clist), i),
 454                                            profile_name);
 455         }
 456         sync_profiles ();
 457 }
 458 void
 459 gnome_external_panelize (GtkWidget *widget, WPanel *panel)
 460 {
 461         ep_dlg_data *data;
 462         GtkWidget *frame;
 463         GtkWidget *sw;
 464         GtkWidget *vbox;
 465         GtkWidget *hbox;
 466         gint i;
 467         gchar *row_data;
 468
 469         data = g_new0 (ep_dlg_data, 1);
 470         data->setting_text = FALSE;
 471         data->selected = -1;
 472         data->ep_dlg = gnome_dialog_new (_("Run Command"), GNOME_STOCK_BUTTON_OK,
 473                                    GNOME_STOCK_BUTTON_CANCEL, NULL);
 474         gtk_window_set_position (GTK_WINDOW (data->ep_dlg), GTK_WIN_POS_MOUSE);
 475
 476                                 /* Frame 1 */
 477         frame = gtk_frame_new (_("Preset Commands"));
 478         gtk_box_pack_start (GTK_BOX (GNOME_DIALOG (data->ep_dlg)->vbox),
 479                             frame, FALSE, FALSE, 0);
 480         data->clist = gtk_clist_new (1);
 481         load_settings (GTK_CLIST (data->clist));
 482         gtk_signal_connect (GTK_OBJECT (data->clist), "select_row", GTK_SIGNAL_FUNC (ep_select_callback), (gpointer) data);
 483         vbox = gtk_vbox_new (FALSE, GNOME_PAD_SMALL);
 484         gtk_clist_columns_autosize (GTK_CLIST (data->clist));
 485         gtk_clist_set_auto_sort (GTK_CLIST (data->clist), TRUE);
 486         gtk_container_set_border_width (GTK_CONTAINER (vbox), GNOME_PAD_SMALL);
 487         sw = gtk_scrolled_window_new (GTK_CLIST (data->clist)->hadjustment, GTK_CLIST (data->clist)->vadjustment);
 488         gtk_widget_set_usize (sw, 300, 100);
 489         gtk_container_add (GTK_CONTAINER (sw), data->clist);
 490         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 491         gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
 492         gtk_container_add (GTK_CONTAINER (frame), vbox);
 493         hbox = gtk_hbox_new (FALSE, GNOME_PAD_SMALL);
 494         data->add_button = gtk_button_new_with_label (_("Add"));
 495         gtk_signal_connect (GTK_OBJECT (data->add_button), "clicked", GTK_SIGNAL_FUNC (ep_add_callback), (gpointer) data);
 496         gtk_widget_set_usize (data->add_button, 75, 25);
 497         gtk_box_pack_end (GTK_BOX (hbox), data->add_button, FALSE, FALSE, 0);
 498         data->remove_button = gtk_button_new_with_label (_("Remove"));
 499         gtk_widget_set_sensitive (data->remove_button, FALSE);
 500         gtk_signal_connect (GTK_OBJECT (data->remove_button), "clicked", GTK_SIGNAL_FUNC (ep_remove_callback), (gpointer) data);
 501         gtk_widget_set_usize (data->remove_button, 75, 25);
 502         gtk_box_pack_end (GTK_BOX (hbox), data->remove_button, FALSE, FALSE, 0);
 503         gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 504
 505                                 /* Frame 2 */
 506         frame = gtk_frame_new (_("Run this Command"));
 507         gtk_box_pack_start (GTK_BOX (GNOME_DIALOG (data->ep_dlg)->vbox),
 508                             frame, FALSE, FALSE, 0);
 509         data->entry = gtk_entry_new ();
 510         gtk_signal_connect (GTK_OBJECT (data->entry), "changed", GTK_SIGNAL_FUNC (ep_text_changed_callback), (gpointer) data);
 511         hbox = gtk_hbox_new (FALSE, GNOME_PAD_SMALL);
 512         gtk_container_set_border_width (GTK_CONTAINER (hbox), GNOME_PAD_SMALL);
 513         gtk_box_pack_start (GTK_BOX (hbox), gtk_label_new (_("Command: ")), FALSE, FALSE, 0);
 514         gtk_box_pack_start (GTK_BOX (hbox), data->entry, TRUE, TRUE, 0);
 515         gtk_container_add (GTK_CONTAINER (frame), hbox);
 516         gtk_widget_show_all (GNOME_DIALOG (data->ep_dlg)->vbox);
 517         switch (gnome_dialog_run (GNOME_DIALOG (data->ep_dlg))) {
 518         case 0:
 519                 gtk_widget_hide (data->ep_dlg);
 520                 while (gtk_events_pending () )
 521                         gtk_main_iteration ();
 522
 523                 do_external_panelize (gtk_entry_get_text (GTK_ENTRY (data->entry)));
 524                 save_settings (GTK_CLIST (data->clist));
 525                 break;
 526         case 1:
 527         default:
 528         }
 529         for (i = 0; i < GTK_CLIST (data->clist)->rows; i++) {
 530                 row_data = gtk_clist_get_row_data (GTK_CLIST (data->clist), i);
 531                 if (row_data)
 532                         g_free (row_data);
 533         }
 534         gtk_widget_destroy (GTK_WIDGET (data->ep_dlg));
 535         g_free (data);
 536 }
 537 void
 538 gnome_select_all_cmd (GtkWidget *widget, WPanel *panel)
 539 {
 540         gint i;
 541         for (i = 0; i < panel->count; i++){
 542                 if (!strcmp (panel->dir.list [i].fname, "..")) {
 543                         continue;
 544                 }
 545                 do_file_mark (panel, i, 1);
 546         }
 547         paint_panel (panel);
 548         do_refresh ();
 549 }
 550 void
 551 gnome_reverse_selection_cmd_panel (WPanel *panel)
 552 {
 553     file_entry *file;
 554     int i;
 555
 556     for (i = 0; i < panel->count; i++){
 557             if (!strcmp (panel->dir.list [i].fname, "..")) {
 558                     continue;
 559             }
 560             file = &panel->dir.list [i];
 561             do_file_mark (panel, i, !file->f.marked);
 562     }
 563     paint_panel (panel);
 564 }
 565
 566 void
 567 gnome_filter_cmd (GtkWidget *widget, WPanel *panel)
 568 {
 569         GtkWidget *filter_dlg;
 570         GtkWidget *entry;
 571         GtkWidget *label;
 572         gchar *text1, *text2, *text3;
 573
 574         filter_dlg = gnome_dialog_new (_("Set Filter"), GNOME_STOCK_BUTTON_OK,
 575                                        GNOME_STOCK_BUTTON_CANCEL, NULL);
 576         gtk_window_set_position (GTK_WINDOW (filter_dlg), GTK_WIN_POS_MOUSE);
 577         if (easy_patterns) {
 578                 text1 = "mc_filter_globs";
 579                 text3 = _("Show all files");
 580                 if (panel->filter && (strcmp (panel->filter, "*")))
 581                         text2 = panel->filter;
 582                 else
 583                         text2 = NULL;
 584         } else {
 585                 text1 = ("mc_filter_regexps");
 586                 text3 = _(".");
 587                 if (!panel->filter)
 588                         text2 = NULL;
 589                 else
 590                         text2 = panel->filter;
 591         }
 592         entry = gnome_entry_new (text1);
 593         gnome_entry_load_history (GNOME_ENTRY (entry));
 594
 595         if (text2) {
 596                 gtk_entry_set_text (GTK_ENTRY (gnome_entry_gtk_entry (GNOME_ENTRY (entry))), text2);
 597                 gnome_entry_prepend_history (GNOME_ENTRY (entry), FALSE, text3);
 598         } else
 599                 gtk_entry_set_text (GTK_ENTRY (gnome_entry_gtk_entry (GNOME_ENTRY (entry))), text3);
 600
 601         if (easy_patterns)
 602                 label = gtk_label_new (_("Enter a filter here for files in the panel view.\n\nFor example:\n*.gif will show just gif images"));
 603         else
 604                 label = gtk_label_new (_("Enter a Regular Expression to filter files in the panel view."));
 605         gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
 606         gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
 607
 608         gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 609         gtk_box_pack_start (GTK_BOX (GNOME_DIALOG (filter_dlg)->vbox), label, FALSE, FALSE, 0);
 610         gtk_box_pack_start (GTK_BOX (GNOME_DIALOG (filter_dlg)->vbox), entry, FALSE, FALSE, 0);
 611         gtk_widget_show_all (GNOME_DIALOG (filter_dlg)->vbox);
 612         switch (gnome_dialog_run (GNOME_DIALOG (filter_dlg))) {
 613         case 0:
 614                 gtk_widget_hide (filter_dlg);
 615                 if (panel->filter) {
 616                         g_free (panel->filter);
 617                         panel->filter = NULL;
 618                 }
 619                 panel->filter = g_strdup (gtk_entry_get_text (GTK_ENTRY (gnome_entry_gtk_entry (GNOME_ENTRY (entry)))));
 620                 if (!strcmp (_("Show all files"), panel->filter)) {
 621                         g_free (panel->filter);
 622                         panel->filter = NULL;
 623                         gtk_entry_set_text (GTK_ENTRY (gnome_entry_gtk_entry (GNOME_ENTRY (entry))),
 624                                             "");
 625                         gtk_label_set_text (GTK_LABEL (panel->status), _("Show all files"));
 626                 } else if (!strcmp ("*", panel->filter)) {
 627                         g_free (panel->filter);
 628                         panel->filter = NULL;
 629                         gtk_label_set_text (GTK_LABEL (panel->status), _("Show all files"));
 630                 } else
 631                         gtk_label_set_text (GTK_LABEL (panel->status), panel->filter);
 632
 633                 gnome_entry_save_history (GNOME_ENTRY (entry));
 634                 reread_cmd ();
 635                 x_filter_changed (panel);
 636                 break;
 637         }
 638         gtk_widget_destroy (filter_dlg);
 639 }
 640
 641 void
 642 gnome_open_files (GtkWidget *widget, WPanel *panel)
 643 {
 644         GList *later = NULL;
 645 #if 0
 646         GList *now;
 647 #endif
 648         gint i;
 649
 650         /* FIXME: this is the easy way to do things.  We want the
 651          * hard way sometime. */
 652         for (i = 0; i < panel->count; i++) {
 653                 if (panel->dir.list [i].f.marked)
 654                         if (!do_enter_on_file_entry ((panel->dir.list) + i))
 655                                 later = g_list_prepend (later, panel->dir.list + i);
 656         }
 657 #if 0
 658         /* This is sorta ugly.  Should we just skip these? There should be a better way. */
 659         for (now = later; now; now = now->next) {
 660                 gchar *command;
 661                 command = input_expand_dialog (_(" Open with..."),
 662                                                _("Enter extra arguments:"), (WPanel *) now->data);
 663                 if (!command)
 664                         /* we break out. */
 665                         break;
 666                 execute (command);
 667                  g_free (command);
 668         }
 669 #endif
 670         g_list_free (later);
 671
 672 }
 673
 674 void
 675 gnome_run_new (GtkWidget *widget, GnomeDesktopEntry *gde)
 676 {
 677         gnome_desktop_entry_launch (gde);
 678 }
 679
 680 void
 681 gnome_mkdir_cmd (GtkWidget *widget, WPanel *panel)
 682 {
 683         mkdir_cmd (panel);
 684 }
 685