src/find.c

   1 /* Find file command for the Midnight Commander
   2    Copyright (C) 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   3    2006, 2007 Free Software Foundation, Inc.
   4    Written 1995 by Miguel de Icaza
   5
   6    Complete rewrite.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  21
  22 /** \file find.c
  23  *  \brief Source: Find file command
  24  */
  25
  26 #include <config.h>
  27
  28 #include <ctype.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <fcntl.h>
  33 #include <sys/stat.h>
  34
  35 #include "lib/global.h"
  36
  37 #include "lib/util.h"           /* canonicalize_pathname() */
  38 #include "lib/tty/tty.h"
  39 #include "lib/tty/key.h"
  40 #include "lib/skin.h"
  41 #include "lib/search.h"
  42 #include "lib/mcconfig.h"
  43 #include "lib/vfs/mc-vfs/vfs.h"
  44 #include "lib/strutil.h"
  45 #include "lib/util.h"
  46 #include "lib/widget.h"
  47
  48 #include "setup.h"              /* verbose */
  49 #include "dir.h"
  50 #include "panel.h"              /* current_panel */
  51 #include "main.h"               /* do_cd, try_to_select */
  52 #include "cmd.h"                /* view_file_at_line */
  53 #include "boxes.h"
  54 #include "history.h"            /* MC_HISTORY_SHARED_SEARCH */
  55 #include "layout.h"             /* mc_refresh() */
  56
  57 #include "find.h"
  58
  59 /*** global variables ****************************************************************************/
  60
  61 /* List of directories to be ignored, separated by ':' */
  62 char **find_ignore_dirs = NULL;
  63
  64 /*** file scope macro definitions ****************************************************************/
  65
  66 /* Size of the find window */
  67 #define FIND2_Y (LINES - 4)
  68
  69 #define FIND2_X_USE (FIND2_X - 20)
  70
  71 /*** file scope type declarations ****************************************************************/
  72
  73 /* A couple of extra messages we need */
  74 enum
  75 {
  76     B_STOP = B_USER + 1,
  77     B_AGAIN,
  78     B_PANELIZE,
  79     B_TREE,
  80     B_VIEW
  81 };
  82
  83 typedef enum
  84 {
  85     FIND_CONT = 0,
  86     FIND_SUSPEND,
  87     FIND_ABORT
  88 } FindProgressStatus;
  89
  90 /* find file options */
  91 typedef struct
  92 {
  93     /* file name options */
  94     gboolean file_case_sens;
  95     gboolean file_pattern;
  96     gboolean find_recurs;
  97     gboolean skip_hidden;
  98     gboolean file_all_charsets;
  99
 100     /* file content options */
 101     gboolean content_use;
 102     gboolean content_case_sens;
 103     gboolean content_regexp;
 104     gboolean content_first_hit;
 105     gboolean content_whole_words;
 106     gboolean content_all_charsets;
 107 } find_file_options_t;
 108
 109 /*** file scope variables ************************************************************************/
 110
 111 /* Size of the find parameters window */
 112 #if HAVE_CHARSET
 113 static int FIND_Y = 17;
 114 #else
 115 static int FIND_Y = 16;
 116 #endif
 117 static int FIND_X = 68;
 118
 119 static int FIND2_X = 64;
 120
 121 /* static variables to remember find parameters */
 122 static WInput *in_start;        /* Start path */
 123 static WInput *in_name;         /* Filename */
 124 static WInput *in_with;         /* Text */
 125 static WLabel *content_label;   /* 'Content:' label */
 126 static WCheck *file_case_sens_cbox;     /* "case sensitive" checkbox */
 127 static WCheck *file_pattern_cbox;       /* File name is glob or regexp */
 128 static WCheck *recursively_cbox;
 129 static WCheck *skip_hidden_cbox;
 130 static WCheck *content_use_cbox;        /* Take into account the Content field */
 131 static WCheck *content_case_sens_cbox;  /* "case sensitive" checkbox */
 132 static WCheck *content_regexp_cbox;     /* "find regular expression" checkbox */
 133 static WCheck *content_first_hit_cbox;  /* "First hit" checkbox" */
 134 static WCheck *content_whole_words_cbox;        /* "whole words" checkbox */
 135 #ifdef HAVE_CHARSET
 136 static WCheck *file_all_charsets_cbox;
 137 static WCheck *content_all_charsets_cbox;
 138 #endif
 139
 140 static gboolean running = FALSE;        /* nice flag */
 141 static char *find_pattern = NULL;       /* Pattern to search */
 142 static char *content_pattern = NULL;    /* pattern to search inside files; if
 143                                            content_regexp_flag is true, it contains the
 144                                            regex pattern, else the search string. */
 145 static unsigned long matches;   /* Number of matches */
 146 static gboolean is_start = FALSE;       /* Status of the start/stop toggle button */
 147 static char *old_dir = NULL;
 148
 149 /* Where did we stop */
 150 static int resuming;
 151 static int last_line;
 152 static int last_pos;
 153
 154 static Dlg_head *find_dlg;      /* The dialog */
 155 static WButton *stop_button;    /* pointer to the stop button */
 156 static WLabel *status_label;    /* Finished, Searching etc. */
 157 static WLabel *found_num_label; /* Number of found items */
 158 static WListbox *find_list;     /* Listbox with the file list */
 159
 160 /* This keeps track of the directory stack */
 161 #if GLIB_CHECK_VERSION (2, 14, 0)
 162 static GQueue dir_queue = G_QUEUE_INIT;
 163 #else
 164 typedef struct dir_stack
 165 {
 166     char *name;
 167     struct dir_stack *prev;
 168 } dir_stack;
 169
 170 static dir_stack *dir_stack_base = 0;
 171 #endif /* GLIB_CHECK_VERSION */
 172
 173 /* *INDENT-OFF* */
 174 static struct
 175 {
 176     const char *text;
 177     int len;                    /* length including space and brackets */
 178     int x;
 179 } fbuts[] =
 180 {
 181     {N_("&Suspend"), 11, 29},
 182     {N_("Con&tinue"), 12, 29},
 183     {N_("&Chdir"), 11, 3},
 184     {N_("&Again"), 9, 17},
 185     {N_("&Quit"), 8, 43},
 186     {N_("Pane&lize"), 12, 3},
 187     {N_("&View - F3"), 13, 20},
 188     {N_("&Edit - F4"), 13, 38}
 189 };
 190 /* *INDENT-ON* */
 191
 192 static find_file_options_t options = {
 193     TRUE, TRUE, TRUE, FALSE, FALSE,
 194     FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
 195 };
 196
 197 static char *in_start_dir = INPUT_LAST_TEXT;
 198
 199 static mc_search_t *search_file_handle = NULL;
 200 static mc_search_t *search_content_handle = NULL;
 201
 202 /*** file scope functions ************************************************************************/
 203
 204 static int
 205 find_ignore_dirs_cmp (const void *d1, const void *d2)
 206 {
 207     return strcmp (*(const char **) d1, *(const char **) d2);
 208 }
 209
 210 /* --------------------------------------------------------------------------------------------- */
 211
 212 static void
 213 find_load_options (void)
 214 {
 215     static gboolean loaded = FALSE;
 216     char *ignore_dirs;
 217
 218     if (loaded)
 219         return;
 220
 221     loaded = TRUE;
 222
 223     /* Back compatibility: try load old parameter at first */
 224     ignore_dirs = mc_config_get_string (mc_main_config, "Misc", "find_ignore_dirs", "");
 225     if (ignore_dirs[0] != '\0')
 226     {
 227         find_ignore_dirs = g_strsplit (ignore_dirs, ":", -1);
 228         mc_config_set_string (mc_main_config, "FindFile", "ignore_dirs", ignore_dirs);
 229     }
 230     g_free (ignore_dirs);
 231     mc_config_del_param (mc_main_config, "Misc", "find_ignore_dirs");
 232
 233     /* Then load new parameters */
 234     ignore_dirs = mc_config_get_string (mc_main_config, "FindFile", "ignore_dirs", "");
 235     if (ignore_dirs[0] != '\0')
 236     {
 237         g_strfreev (find_ignore_dirs);
 238         find_ignore_dirs = g_strsplit (ignore_dirs, ":", -1);
 239     }
 240     g_free (ignore_dirs);
 241
 242     if (find_ignore_dirs != NULL)
 243     {
 244         /* Values like '/foo::/bar: produce holes in list.
 245            Find and remove them */
 246         size_t r = 0, w = 0; /* read and write iterators */
 247
 248         for (; find_ignore_dirs[r] != NULL; r++)
 249         {
 250             if (find_ignore_dirs [r][0] == '\0')
 251             {
 252                 /* empty entry -- skip it */
 253                 g_free (find_ignore_dirs [r]);
 254                 find_ignore_dirs [r] = NULL;
 255                 continue;
 256             }
 257
 258             if (r != w)
 259             {
 260                 /* copy entry to the previous free array cell */
 261                 find_ignore_dirs [w] = find_ignore_dirs [r];
 262                 find_ignore_dirs [r] = NULL;
 263             }
 264
 265             canonicalize_pathname (find_ignore_dirs [w]);
 266             w++;
 267         }
 268
 269         /* sort array */
 270         if (find_ignore_dirs[0] != NULL)
 271             qsort (find_ignore_dirs, g_strv_length (find_ignore_dirs),
 272                    sizeof (find_ignore_dirs[0]), &find_ignore_dirs_cmp);
 273         else
 274         {
 275             g_strfreev (find_ignore_dirs);
 276             find_ignore_dirs = NULL;
 277         }
 278     }
 279
 280     options.file_case_sens =
 281         mc_config_get_bool (mc_main_config, "FindFile", "file_case_sens", TRUE);
 282     options.file_pattern =
 283         mc_config_get_bool (mc_main_config, "FindFile", "file_shell_pattern", TRUE);
 284     options.find_recurs = mc_config_get_bool (mc_main_config, "FindFile", "file_find_recurs", TRUE);
 285     options.skip_hidden =
 286         mc_config_get_bool (mc_main_config, "FindFile", "file_skip_hidden", FALSE);
 287     options.file_all_charsets =
 288         mc_config_get_bool (mc_main_config, "FindFile", "file_all_charsets", FALSE);
 289     options.content_use = mc_config_get_bool (mc_main_config, "FindFile", "content_use", FALSE);
 290     options.content_case_sens =
 291         mc_config_get_bool (mc_main_config, "FindFile", "content_case_sens", TRUE);
 292     options.content_regexp =
 293         mc_config_get_bool (mc_main_config, "FindFile", "content_regexp", FALSE);
 294     options.content_first_hit =
 295         mc_config_get_bool (mc_main_config, "FindFile", "content_first_hit", FALSE);
 296     options.content_whole_words =
 297         mc_config_get_bool (mc_main_config, "FindFile", "content_whole_words", FALSE);
 298     options.content_all_charsets =
 299         mc_config_get_bool (mc_main_config, "FindFile", "content_all_charsets", FALSE);
 300 }
 301
 302 /* --------------------------------------------------------------------------------------------- */
 303
 304 static void
 305 find_save_options (void)
 306 {
 307     mc_config_set_bool (mc_main_config, "FindFile", "file_case_sens", options.file_case_sens);
 308     mc_config_set_bool (mc_main_config, "FindFile", "file_shell_pattern", options.file_pattern);
 309     mc_config_set_bool (mc_main_config, "FindFile", "file_find_recurs", options.find_recurs);
 310     mc_config_set_bool (mc_main_config, "FindFile", "file_skip_hidden", options.skip_hidden);
 311     mc_config_set_bool (mc_main_config, "FindFile", "file_all_charsets", options.file_all_charsets);
 312     mc_config_set_bool (mc_main_config, "FindFile", "content_use", options.content_use);
 313     mc_config_set_bool (mc_main_config, "FindFile", "content_case_sens", options.content_case_sens);
 314     mc_config_set_bool (mc_main_config, "FindFile", "content_regexp", options.content_regexp);
 315     mc_config_set_bool (mc_main_config, "FindFile", "content_first_hit", options.content_first_hit);
 316     mc_config_set_bool (mc_main_config, "FindFile", "content_whole_words",
 317                         options.content_whole_words);
 318     mc_config_set_bool (mc_main_config, "FindFile", "content_all_charsets",
 319                         options.content_all_charsets);
 320 }
 321
 322 /* --------------------------------------------------------------------------------------------- */
 323
 324 static inline char *
 325 add_to_list (const char *text, void *data)
 326 {
 327     return listbox_add_item (find_list, LISTBOX_APPEND_AT_END, 0, text, data);
 328 }
 329
 330 /* --------------------------------------------------------------------------------------------- */
 331
 332 static inline void
 333 stop_idle (void *data)
 334 {
 335     set_idle_proc (data, 0);
 336 }
 337
 338 /* --------------------------------------------------------------------------------------------- */
 339
 340 static inline void
 341 status_update (const char *text)
 342 {
 343     label_set_text (status_label, text);
 344 }
 345
 346 /* --------------------------------------------------------------------------------------------- */
 347
 348 static void
 349 found_num_update (void)
 350 {
 351     char buffer[BUF_TINY];
 352     g_snprintf (buffer, sizeof (buffer), _("Found: %ld"), matches);
 353     label_set_text (found_num_label, buffer);
 354 }
 355
 356 /* --------------------------------------------------------------------------------------------- */
 357
 358 static void
 359 get_list_info (char **file, char **dir)
 360 {
 361     listbox_get_current (find_list, file, (void **) dir);
 362 }
 363
 364 /* --------------------------------------------------------------------------------------------- */
 365 /** check regular expression */
 366
 367 static gboolean
 368 find_check_regexp (const char *r)
 369 {
 370     mc_search_t *search;
 371     gboolean regexp_ok = FALSE;
 372
 373     search = mc_search_new (r, -1);
 374
 375     if (search != NULL)
 376     {
 377         search->search_type = MC_SEARCH_T_REGEX;
 378         regexp_ok = mc_search_prepare (search);
 379         mc_search_free (search);
 380     }
 381
 382     return regexp_ok;
 383 }
 384
 385 /* --------------------------------------------------------------------------------------------- */
 386 /**
 387  * Callback for the parameter dialog.
 388  * Validate regex, prevent closing the dialog if it's invalid.
 389  */
 390
 391 static cb_ret_t
 392 find_parm_callback (Dlg_head * h, Widget * sender, dlg_msg_t msg, int parm, void *data)
 393 {
 394     switch (msg)
 395     {
 396     case DLG_ACTION:
 397         if (sender == (Widget *) content_use_cbox)
 398         {
 399             gboolean disable = !(content_use_cbox->state & C_BOOL);
 400
 401             widget_disable (content_label->widget, disable);
 402             send_message ((Widget *) content_label, WIDGET_DRAW, 0);
 403             widget_disable (in_with->widget, disable);
 404             send_message ((Widget *) in_with, WIDGET_DRAW, 0);
 405             widget_disable (content_first_hit_cbox->widget, disable);
 406             send_message ((Widget *) content_first_hit_cbox, WIDGET_DRAW, 0);
 407             widget_disable (content_regexp_cbox->widget, disable);
 408             send_message ((Widget *) content_regexp_cbox, WIDGET_DRAW, 0);
 409             widget_disable (content_case_sens_cbox->widget, disable);
 410             send_message ((Widget *) content_case_sens_cbox, WIDGET_DRAW, 0);
 411 #ifdef HAVE_CHARSET
 412             widget_disable (content_all_charsets_cbox->widget, disable);
 413             send_message ((Widget *) content_all_charsets_cbox, WIDGET_DRAW, 0);
 414 #endif
 415             widget_disable (content_whole_words_cbox->widget, disable);
 416             send_message ((Widget *) content_whole_words_cbox, WIDGET_DRAW, 0);
 417
 418             return MSG_HANDLED;
 419         }
 420
 421         return MSG_NOT_HANDLED;
 422
 423
 424     case DLG_VALIDATE:
 425         if (h->ret_value != B_ENTER)
 426             return MSG_HANDLED;
 427
 428         /* check filename regexp */
 429         if (!(file_pattern_cbox->state & C_BOOL)
 430             && (in_name->buffer[0] != '\0') && !find_check_regexp (in_name->buffer))
 431         {
 432             h->state = DLG_ACTIVE;      /* Don't stop the dialog */
 433             message (D_ERROR, MSG_ERROR, _("Malformed regular expression"));
 434             dlg_select_widget (in_name);
 435             return MSG_HANDLED;
 436         }
 437
 438         /* check content regexp */
 439         if ((content_regexp_cbox->state & C_BOOL)
 440             && (in_with->buffer[0] != '\0') && !find_check_regexp (in_with->buffer))
 441         {
 442             h->state = DLG_ACTIVE;      /* Don't stop the dialog */
 443             message (D_ERROR, MSG_ERROR, _("Malformed regular expression"));
 444             dlg_select_widget (in_with);
 445             return MSG_HANDLED;
 446         }
 447
 448         return MSG_HANDLED;
 449
 450     default:
 451         return default_dlg_callback (h, sender, msg, parm, data);
 452     }
 453 }
 454
 455 /* --------------------------------------------------------------------------------------------- */
 456 /**
 457  * find_parameters: gets information from the user
 458  *
 459  * If the return value is TRUE, then the following holds:
 460  *
 461  * START_DIR and PATTERN are pointers to char * and upon return they
 462  * contain the information provided by the user.
 463  *
 464  * CONTENT holds a strdup of the contents specified by the user if he
 465  * asked for them or 0 if not (note, this is different from the
 466  * behavior for the other two parameters.
 467  *
 468  */
 469
 470 static gboolean
 471 find_parameters (char **start_dir, char **pattern, char **content)
 472 {
 473     gboolean return_value;
 474
 475     /* file name */
 476     const char *file_case_label = N_("Cas&e sensitive");
 477     const char *file_pattern_label = N_("&Using shell patterns");
 478     const char *file_recurs_label = N_("&Find recursively");
 479     const char *file_skip_hidden_label = N_("S&kip hidden");
 480 #ifdef HAVE_CHARSET
 481     const char *file_all_charsets_label = N_("&All charsets");
 482 #endif
 483
 484     /* file content */
 485     const char *content_use_label = N_("Sea&rch for content");
 486     const char *content_case_label = N_("Case sens&itive");
 487     const char *content_regexp_label = N_("Re&gular expression");
 488     const char *content_first_hit_label = N_("Fir&st hit");
 489     const char *content_whole_words_label = N_("&Whole words");
 490 #ifdef HAVE_CHARSET
 491     const char *content_all_charsets_label = N_("A&ll charsets");
 492 #endif
 493
 494     const char *buts[] = { N_("&OK"), N_("&Cancel"), N_("&Tree") };
 495
 496     int b0, b1, b2;
 497
 498     int cbox_position;
 499     gboolean disable;
 500
 501 #ifdef ENABLE_NLS
 502     {
 503         int i = sizeof (buts) / sizeof (buts[0]);
 504         while (i-- != 0)
 505             buts[i] = _(buts[i]);
 506
 507         file_case_label = _(file_case_label);
 508         file_pattern_label = _(file_pattern_label);
 509         file_recurs_label = _(file_recurs_label);
 510         file_skip_hidden_label = _(file_skip_hidden_label);
 511 #ifdef HAVE_CHARSET
 512         file_all_charsets_label = _(file_all_charsets_label);
 513         content_all_charsets_label = _(content_all_charsets_label);
 514 #endif
 515         content_use_label = _(content_use_label);
 516         content_case_label = _(content_case_label);
 517         content_regexp_label = _(content_regexp_label);
 518         content_first_hit_label = _(content_first_hit_label);
 519         content_whole_words_label = _(content_whole_words_label);
 520     }
 521 #endif /* ENABLE_NLS */
 522
 523     b0 = str_term_width1 (buts[0]) + 6; /* default button */
 524     b1 = str_term_width1 (buts[1]) + 4;
 525     b2 = str_term_width1 (buts[2]) + 4;
 526
 527     find_load_options ();
 528
 529     if (in_start_dir == NULL)
 530         in_start_dir = g_strdup (".");
 531
 532     disable = !options.content_use;
 533
 534     find_dlg =
 535         create_dlg (TRUE, 0, 0, FIND_Y, FIND_X, dialog_colors,
 536                     find_parm_callback, "[Find File]", _("Find File"), DLG_CENTER | DLG_REVERSE);
 537
 538     add_widget (find_dlg,
 539                 button_new (FIND_Y - 3, FIND_X * 3 / 4 - b1 / 2, B_CANCEL, NORMAL_BUTTON, buts[1],
 540                             0));
 541     add_widget (find_dlg,
 542                 button_new (FIND_Y - 3, FIND_X / 4 - b0 / 2, B_ENTER, DEFPUSH_BUTTON, buts[0], 0));
 543
 544     cbox_position = FIND_Y - 5;
 545
 546     content_first_hit_cbox =
 547         check_new (cbox_position--, FIND_X / 2 + 1, options.content_first_hit,
 548                    content_first_hit_label);
 549     widget_disable (content_first_hit_cbox->widget, disable);
 550     add_widget (find_dlg, content_first_hit_cbox);
 551
 552     content_whole_words_cbox =
 553         check_new (cbox_position--, FIND_X / 2 + 1, options.content_whole_words,
 554                    content_whole_words_label);
 555     widget_disable (content_whole_words_cbox->widget, disable);
 556     add_widget (find_dlg, content_whole_words_cbox);
 557
 558 #ifdef HAVE_CHARSET
 559     content_all_charsets_cbox = check_new (cbox_position--, FIND_X / 2 + 1,
 560                                            options.content_all_charsets,
 561                                            content_all_charsets_label);
 562     widget_disable (content_all_charsets_cbox->widget, disable);
 563     add_widget (find_dlg, content_all_charsets_cbox);
 564 #endif
 565
 566     content_case_sens_cbox =
 567         check_new (cbox_position--, FIND_X / 2 + 1, options.content_case_sens, content_case_label);
 568     widget_disable (content_case_sens_cbox->widget, disable);
 569     add_widget (find_dlg, content_case_sens_cbox);
 570
 571     content_regexp_cbox =
 572         check_new (cbox_position--, FIND_X / 2 + 1, options.content_regexp, content_regexp_label);
 573     widget_disable (content_regexp_cbox->widget, disable);
 574     add_widget (find_dlg, content_regexp_cbox);
 575
 576     cbox_position = FIND_Y - 6;
 577
 578     skip_hidden_cbox = check_new (cbox_position--, 3, options.skip_hidden, file_skip_hidden_label);
 579     add_widget (find_dlg, skip_hidden_cbox);
 580
 581 #ifdef HAVE_CHARSET
 582     file_all_charsets_cbox =
 583         check_new (cbox_position--, 3, options.file_all_charsets, file_all_charsets_label);
 584     add_widget (find_dlg, file_all_charsets_cbox);
 585 #endif
 586
 587     file_case_sens_cbox = check_new (cbox_position--, 3, options.file_case_sens, file_case_label);
 588     add_widget (find_dlg, file_case_sens_cbox);
 589
 590     file_pattern_cbox = check_new (cbox_position--, 3, options.file_pattern, file_pattern_label);
 591     add_widget (find_dlg, file_pattern_cbox);
 592
 593     recursively_cbox = check_new (cbox_position, 3, options.find_recurs, file_recurs_label);
 594     add_widget (find_dlg, recursively_cbox);
 595
 596     /* This checkbox is located in the second column */
 597     content_use_cbox =
 598         check_new (cbox_position, FIND_X / 2 + 1, options.content_use, content_use_label);
 599     add_widget (find_dlg, content_use_cbox);
 600
 601     in_with =
 602         input_new (6, FIND_X / 2 + 1, input_get_default_colors (), FIND_X / 2 - 4, INPUT_LAST_TEXT,
 603                    MC_HISTORY_SHARED_SEARCH, INPUT_COMPLETE_DEFAULT);
 604     widget_disable (in_with->widget, disable);
 605     add_widget (find_dlg, in_with);
 606
 607     content_label = label_new (5, FIND_X / 2 + 1, _("Content:"));
 608     widget_disable (content_label->widget, disable);
 609     add_widget (find_dlg, content_label);
 610
 611     in_name = input_new (6, 3, input_get_default_colors (),
 612                          FIND_X / 2 - 4, INPUT_LAST_TEXT, "name", INPUT_COMPLETE_DEFAULT);
 613     add_widget (find_dlg, in_name);
 614     add_widget (find_dlg, label_new (5, 3, _("File name:")));
 615
 616     add_widget (find_dlg, button_new (3, FIND_X - b2 - 2, B_TREE, NORMAL_BUTTON, buts[2], 0));
 617
 618     in_start = input_new (3, 3, input_get_default_colors (),
 619                           FIND_X - b2 - 6, in_start_dir, "start", INPUT_COMPLETE_DEFAULT);
 620     add_widget (find_dlg, in_start);
 621     add_widget (find_dlg, label_new (2, 3, _("Start at:")));
 622
 623   find_par_start:
 624     dlg_select_widget (in_name);
 625
 626     switch (run_dlg (find_dlg))
 627     {
 628     case B_CANCEL:
 629         return_value = FALSE;
 630         break;
 631
 632     case B_TREE:
 633         {
 634             const char *temp_dir = in_start->buffer;
 635
 636             if ((temp_dir[0] == '\0') || ((temp_dir[0] == '.') && (temp_dir[1] == '\0')))
 637                 temp_dir = current_panel->cwd;
 638
 639             if (in_start_dir != INPUT_LAST_TEXT)
 640                 g_free (in_start_dir);
 641             in_start_dir = tree_box (temp_dir);
 642             if (in_start_dir == NULL)
 643                 in_start_dir = g_strdup (temp_dir);
 644
 645             input_assign_text (in_start, in_start_dir);
 646
 647             /* Warning: Dreadful goto */
 648             goto find_par_start;
 649         }
 650
 651     default:
 652 #ifdef HAVE_CHARSET
 653         options.file_all_charsets = file_all_charsets_cbox->state & C_BOOL;
 654         options.content_all_charsets = content_all_charsets_cbox->state & C_BOOL;
 655 #endif
 656         options.content_use = content_use_cbox->state & C_BOOL;
 657         options.content_case_sens = content_case_sens_cbox->state & C_BOOL;
 658         options.content_regexp = content_regexp_cbox->state & C_BOOL;
 659         options.content_first_hit = content_first_hit_cbox->state & C_BOOL;
 660         options.content_whole_words = content_whole_words_cbox->state & C_BOOL;
 661         options.find_recurs = recursively_cbox->state & C_BOOL;
 662         options.file_pattern = file_pattern_cbox->state & C_BOOL;
 663         options.file_case_sens = file_case_sens_cbox->state & C_BOOL;
 664         options.skip_hidden = skip_hidden_cbox->state & C_BOOL;
 665
 666         *content = (options.content_use && in_with->buffer[0] != '\0')
 667                     ? g_strdup (in_with->buffer) : NULL;
 668         *start_dir = in_start->buffer[0] != '\0' ? in_start->buffer : (char *) ".";
 669         *pattern = g_strdup (in_name->buffer);
 670         if (in_start_dir != INPUT_LAST_TEXT)
 671             g_free (in_start_dir);
 672         in_start_dir = g_strdup (*start_dir);
 673         if ((*start_dir)[0] == '.' && (*start_dir)[1] == '\0')
 674             *start_dir = g_strdup (current_panel->cwd);
 675         else if (g_path_is_absolute (*start_dir))
 676             *start_dir = g_strdup (*start_dir);
 677         else
 678             *start_dir = g_build_filename (current_panel->cwd, *start_dir, (char *) NULL);
 679
 680         canonicalize_pathname (*start_dir);
 681
 682         find_save_options ();
 683
 684         return_value = TRUE;
 685     }
 686
 687     destroy_dlg (find_dlg);
 688
 689     return return_value;
 690 }
 691
 692 /* --------------------------------------------------------------------------------------------- */
 693
 694 #if GLIB_CHECK_VERSION (2, 14, 0)
 695 static inline void
 696 push_directory (const char *dir)
 697 {
 698     g_queue_push_head (&dir_queue, (void *) dir);
 699 }
 700
 701 /* --------------------------------------------------------------------------------------------- */
 702
 703 static inline char *
 704 pop_directory (void)
 705 {
 706     return (char *) g_queue_pop_tail (&dir_queue);
 707 }
 708
 709 /* --------------------------------------------------------------------------------------------- */
 710 /** Remove all the items from the stack */
 711
 712 static void
 713 clear_stack (void)
 714 {
 715     g_queue_foreach (&dir_queue, (GFunc) g_free, NULL);
 716     g_queue_clear (&dir_queue);
 717 }
 718
 719 /* --------------------------------------------------------------------------------------------- */
 720
 721 #else /* GLIB_CHECK_VERSION */
 722 static void
 723 push_directory (const char *dir)
 724 {
 725     dir_stack *new;
 726
 727     new = g_new (dir_stack, 1);
 728     new->name = (char *) dir;
 729     new->prev = dir_stack_base;
 730     dir_stack_base = new;
 731 }
 732
 733 /* --------------------------------------------------------------------------------------------- */
 734
 735 static char *
 736 pop_directory (void)
 737 {
 738     char *name = NULL;
 739
 740     if (dir_stack_base != NULL)
 741     {
 742         dir_stack *next;
 743         name = dir_stack_base->name;
 744         next = dir_stack_base->prev;
 745         g_free (dir_stack_base);
 746         dir_stack_base = next;
 747     }
 748
 749     return name;
 750 }
 751
 752 /* --------------------------------------------------------------------------------------------- */
 753 /** Remove all the items from the stack */
 754
 755 static void
 756 clear_stack (void)
 757 {
 758     char *dir = NULL;
 759     while ((dir = pop_directory ()) != NULL)
 760         g_free (dir);
 761 }
 762 #endif /* GLIB_CHECK_VERSION */
 763
 764 /* --------------------------------------------------------------------------------------------- */
 765
 766 static void
 767 insert_file (const char *dir, const char *file)
 768 {
 769     char *tmp_name = NULL;
 770     static char *dirname = NULL;
 771
 772     while (dir[0] == PATH_SEP && dir[1] == PATH_SEP)
 773         dir++;
 774
 775     if (old_dir)
 776     {
 777         if (strcmp (old_dir, dir))
 778         {
 779             g_free (old_dir);
 780             old_dir = g_strdup (dir);
 781             dirname = add_to_list (dir, NULL);
 782         }
 783     }
 784     else
 785     {
 786         old_dir = g_strdup (dir);
 787         dirname = add_to_list (dir, NULL);
 788     }
 789
 790     tmp_name = g_strdup_printf ("    %s", file);
 791     add_to_list (tmp_name, dirname);
 792     g_free (tmp_name);
 793 }
 794
 795 /* --------------------------------------------------------------------------------------------- */
 796
 797 static void
 798 find_add_match (const char *dir, const char *file)
 799 {
 800     insert_file (dir, file);
 801
 802     /* Don't scroll */
 803     if (matches == 0)
 804         listbox_select_first (find_list);
 805     send_message (&find_list->widget, WIDGET_DRAW, 0);
 806
 807     matches++;
 808     found_num_update ();
 809 }
 810
 811 /* --------------------------------------------------------------------------------------------- */
 812 /**
 813  * get_line_at:
 814  *
 815  * Returns malloced null-terminated line from file file_fd.
 816  * Input is buffered in buf_size long buffer.
 817  * Current pos in buf is stored in pos.
 818  * n_read - number of read chars.
 819  * has_newline - is there newline ?
 820  */
 821
 822 static char *
 823 get_line_at (int file_fd, char *buf, int buf_size, int *pos, int *n_read, gboolean * has_newline)
 824 {
 825     char *buffer = NULL;
 826     int buffer_size = 0;
 827     char ch = 0;
 828     int i = 0;
 829
 830     for (;;)
 831     {
 832         if (*pos >= *n_read)
 833         {
 834             *pos = 0;
 835             *n_read = mc_read (file_fd, buf, buf_size);
 836             if (*n_read <= 0)
 837                 break;
 838         }
 839
 840         ch = buf[(*pos)++];
 841         if (ch == '\0')
 842         {
 843             /* skip possible leading zero(s) */
 844             if (i == 0)
 845                 continue;
 846             break;
 847         }
 848
 849         if (i >= buffer_size - 1)
 850             buffer = g_realloc (buffer, buffer_size += 80);
 851
 852         /* Strip newline */
 853         if (ch == '\n')
 854             break;
 855
 856         buffer[i++] = ch;
 857     }
 858
 859     *has_newline = (ch != '\0');
 860
 861     if (buffer != NULL)
 862         buffer[i] = '\0';
 863
 864     return buffer;
 865 }
 866
 867 /* --------------------------------------------------------------------------------------------- */
 868
 869 static FindProgressStatus
 870 check_find_events (Dlg_head * h)
 871 {
 872     Gpm_Event event;
 873     int c;
 874
 875     event.x = -1;
 876     c = tty_get_event (&event, h->mouse_status == MOU_REPEAT, FALSE);
 877     if (c != EV_NONE)
 878     {
 879         dlg_process_event (h, c, &event);
 880         if (h->ret_value == B_ENTER
 881             || h->ret_value == B_CANCEL || h->ret_value == B_AGAIN || h->ret_value == B_PANELIZE)
 882         {
 883             /* dialog terminated */
 884             return FIND_ABORT;
 885         }
 886         if (!(h->flags & DLG_WANT_IDLE))
 887         {
 888             /* searching suspended */
 889             return FIND_SUSPEND;
 890         }
 891     }
 892
 893     return FIND_CONT;
 894 }
 895
 896 /* --------------------------------------------------------------------------------------------- */
 897 /**
 898  * search_content:
 899  *
 900  * Search the content_pattern string in the DIRECTORY/FILE.
 901  * It will add the found entries to the find listbox.
 902  *
 903  * returns FALSE if do_search should look for another file
 904  *         TRUE if do_search should exit and proceed to the event handler
 905  */
 906
 907 static gboolean
 908 search_content (Dlg_head * h, const char *directory, const char *filename)
 909 {
 910     struct stat s;
 911     char buffer[BUF_4K];
 912     char *fname = NULL;
 913     int file_fd;
 914     gboolean ret_val = FALSE;
 915
 916     fname = concat_dir_and_file (directory, filename);
 917
 918     if (mc_stat (fname, &s) != 0 || !S_ISREG (s.st_mode))
 919     {
 920         g_free (fname);
 921         return 0;
 922     }
 923
 924     file_fd = mc_open (fname, O_RDONLY);
 925     g_free (fname);
 926
 927     if (file_fd == -1)
 928         return 0;
 929
 930     g_snprintf (buffer, sizeof (buffer), _("Grepping in %s"), str_trunc (filename, FIND2_X_USE));
 931
 932     status_update (buffer);
 933     mc_refresh ();
 934
 935     tty_enable_interrupt_key ();
 936     tty_got_interrupt ();
 937
 938     {
 939         int line = 1;
 940         int pos = 0;
 941         int n_read = 0;
 942         gboolean has_newline;
 943         char *p = NULL;
 944         gboolean found = FALSE;
 945         gsize found_len;
 946         char result[BUF_MEDIUM];
 947
 948         if (resuming)
 949         {
 950             /* We've been previously suspended, start from the previous position */
 951             resuming = 0;
 952             line = last_line;
 953             pos = last_pos;
 954         }
 955         while (!ret_val
 956                && (p = get_line_at (file_fd, buffer, sizeof (buffer),
 957                                     &pos, &n_read, &has_newline)) != NULL)
 958         {
 959             if (!found          /* Search in binary line once */
 960                 && mc_search_run (search_content_handle,
 961                                   (const void *) p, 0, strlen (p), &found_len))
 962             {
 963                 g_snprintf (result, sizeof (result), "%d:%s", line, filename);
 964                 find_add_match (directory, result);
 965                 found = TRUE;
 966             }
 967             g_free (p);
 968
 969             if (found && options.content_first_hit)
 970                 break;
 971
 972             if (has_newline)
 973             {
 974                 found = FALSE;
 975                 line++;
 976             }
 977
 978             if ((line & 0xff) == 0)
 979             {
 980                 FindProgressStatus res;
 981                 res = check_find_events (h);
 982                 switch (res)
 983                 {
 984                 case FIND_ABORT:
 985                     stop_idle (h);
 986                     ret_val = TRUE;
 987                     break;
 988                 case FIND_SUSPEND:
 989                     resuming = 1;
 990                     last_line = line;
 991                     last_pos = pos;
 992                     ret_val = TRUE;
 993                     break;
 994                 default:
 995                     break;
 996                 }
 997             }
 998         }
 999     }
1000     tty_disable_interrupt_key ();
1001     mc_close (file_fd);
1002     return ret_val;
1003 }
1004
1005 /* --------------------------------------------------------------------------------------------- */
1006
1007 static inline gboolean
1008 find_ignore_dir_search (const char *dir)
1009 {
1010     if (find_ignore_dirs != NULL)
1011     {
1012         const size_t dlen = strlen (dir);
1013         char **ignore_dir;
1014
1015         for (ignore_dir = find_ignore_dirs; *ignore_dir != NULL; ignore_dir++)
1016         {
1017             const size_t ilen = strlen (*ignore_dir);
1018
1019             if (dlen < ilen)
1020                 continue; /* ignore dir is too long -- skip it */
1021
1022             if (strncmp (dir, *ignore_dir, ilen) != 0)
1023                 continue; /* strings are different -- skip ignore_dir */
1024
1025             /* be sure than ignore_dir is not a part of dir like:
1026                ignore_dir is "/h", dir is "/home" */
1027             if (dir[ilen] == PATH_SEP || dir[ilen] == '\0')
1028                 return TRUE;
1029         }
1030     }
1031
1032     return FALSE;
1033 }
1034
1035 /* --------------------------------------------------------------------------------------------- */
1036
1037 static void
1038 find_rotate_dash (const Dlg_head *h, gboolean finish)
1039 {
1040     static const char rotating_dash[] = "|/-\\";
1041     static unsigned int pos = 0;
1042
1043     if (verbose)
1044     {
1045         pos = (pos + 1) % 4;
1046         tty_setcolor (h->color[DLG_COLOR_NORMAL]);
1047         dlg_move (h, FIND2_Y - 7, FIND2_X - 4);
1048         tty_print_char (finish ? ' ' : rotating_dash[pos]);
1049         mc_refresh ();
1050     }
1051 }
1052
1053 /* --------------------------------------------------------------------------------------------- */
1054
1055 static int
1056 do_search (Dlg_head *h)
1057 {
1058     static struct dirent *dp = NULL;
1059     static DIR *dirp = NULL;
1060     static char *directory = NULL;
1061     struct stat tmp_stat;
1062     static int subdirs_left = 0;
1063     gsize bytes_found;
1064     unsigned short count;
1065
1066     if (h == NULL)
1067     {                           /* someone forces me to close dirp */
1068         if (dirp != NULL)
1069         {
1070             mc_closedir (dirp);
1071             dirp = NULL;
1072         }
1073         g_free (directory);
1074         directory = NULL;
1075         dp = NULL;
1076         return 1;
1077     }
1078
1079     for (count = 0; count < 32; count++)
1080     {
1081         while (dp == NULL)
1082         {
1083             if (dirp != NULL)
1084             {
1085                 mc_closedir (dirp);
1086                 dirp = NULL;
1087             }
1088
1089             while (dirp == NULL)
1090             {
1091                 char *tmp = NULL;
1092
1093                 tty_setcolor (REVERSE_COLOR);
1094
1095                 while (TRUE)
1096                 {
1097                     tmp = pop_directory ();
1098                     if (tmp == NULL)
1099                     {
1100                         running = FALSE;
1101                         status_update (_("Finished"));
1102                         find_rotate_dash (h, TRUE);
1103                         stop_idle (h);
1104                         return 0;
1105                     }
1106
1107                     if (!find_ignore_dir_search (tmp))
1108                         break;
1109
1110                     g_free (tmp);
1111                 }
1112
1113                 g_free (directory);
1114                 directory = tmp;
1115
1116                 if (verbose)
1117                 {
1118                     char buffer[BUF_SMALL];
1119
1120                     g_snprintf (buffer, sizeof (buffer), _("Searching %s"),
1121                                 str_trunc (directory, FIND2_X_USE));
1122                     status_update (buffer);
1123                 }
1124                 /* mc_stat should not be called after mc_opendir
1125                    because vfs_s_opendir modifies the st_nlink
1126                  */
1127                 if (mc_stat (directory, &tmp_stat) == 0)
1128                     subdirs_left = tmp_stat.st_nlink - 2;
1129                 else
1130                     subdirs_left = 0;
1131
1132                 dirp = mc_opendir (directory);
1133             }                   /* while (!dirp) */
1134
1135             /* skip invalid filenames */
1136             while ((dp = mc_readdir (dirp)) != NULL && !str_is_valid_string (dp->d_name))
1137                 ;
1138         }                       /* while (!dp) */
1139
1140         if (strcmp (dp->d_name, ".") == 0 || strcmp (dp->d_name, "..") == 0)
1141         {
1142             /* skip invalid filenames */
1143             while ((dp = mc_readdir (dirp)) != NULL && !str_is_valid_string (dp->d_name))
1144                 ;
1145
1146             return 1;
1147         }
1148
1149         if (!(options.skip_hidden && (dp->d_name[0] == '.')))
1150         {
1151             gboolean search_ok;
1152
1153             if ((subdirs_left != 0) && options.find_recurs && (directory != NULL))
1154             {                   /* Can directory be NULL ? */
1155                 char *tmp_name = concat_dir_and_file (directory, dp->d_name);
1156                 if (mc_lstat (tmp_name, &tmp_stat) == 0 && S_ISDIR (tmp_stat.st_mode))
1157                 {
1158                     push_directory (tmp_name);
1159                     subdirs_left--;
1160                 }
1161                 else
1162                     g_free (tmp_name);
1163             }
1164
1165             search_ok = mc_search_run (search_file_handle, dp->d_name,
1166                                        0, strlen (dp->d_name), &bytes_found);
1167
1168             if (search_ok)
1169             {
1170                 if (content_pattern == NULL)
1171                     find_add_match (directory, dp->d_name);
1172                 else if (search_content (h, directory, dp->d_name))
1173                     return 1;
1174             }
1175         }
1176
1177         /* skip invalid filenames */
1178         while ((dp = mc_readdir (dirp)) != NULL && !str_is_valid_string (dp->d_name))
1179             ;
1180     }                           /* for */
1181
1182     find_rotate_dash (h, FALSE);
1183
1184     return 1;
1185 }
1186
1187 /* --------------------------------------------------------------------------------------------- */
1188
1189 static void
1190 init_find_vars (void)
1191 {
1192     g_free (old_dir);
1193     old_dir = NULL;
1194     matches = 0;
1195
1196     /* Remove all the items from the stack */
1197     clear_stack ();
1198 }
1199
1200 /* --------------------------------------------------------------------------------------------- */
1201
1202 static char *
1203 make_fullname (const char *dirname, const char *filename)
1204 {
1205
1206     if (strcmp (dirname, ".") == 0 || strcmp (dirname, "." PATH_SEP_STR) == 0)
1207         return g_strdup (filename);
1208     if (strncmp (dirname, "." PATH_SEP_STR, 2) == 0)
1209         return concat_dir_and_file (dirname + 2, filename);
1210     return concat_dir_and_file (dirname, filename);
1211 }
1212
1213 /* --------------------------------------------------------------------------------------------- */
1214
1215 static void
1216 find_do_view_edit (int unparsed_view, int edit, char *dir, char *file)
1217 {
1218     char *fullname = NULL;
1219     const char *filename = NULL;
1220     int line;
1221
1222     if (content_pattern != NULL)
1223     {
1224         filename = strchr (file + 4, ':') + 1;
1225         line = atoi (file + 4);
1226     }
1227     else
1228     {
1229         filename = file + 4;
1230         line = 0;
1231     }
1232
1233     fullname = make_fullname (dir, filename);
1234     if (edit)
1235         do_edit_at_line (fullname, use_internal_edit, line);
1236     else
1237         view_file_at_line (fullname, unparsed_view, use_internal_view, line);
1238     g_free (fullname);
1239 }
1240
1241 /* --------------------------------------------------------------------------------------------- */
1242
1243 static cb_ret_t
1244 view_edit_currently_selected_file (int unparsed_view, int edit)
1245 {
1246     char *dir = NULL;
1247     char *text = NULL;
1248
1249     listbox_get_current (find_list, &text, (void **) &dir);
1250
1251     if ((text == NULL) || (dir == NULL))
1252         return MSG_NOT_HANDLED;
1253
1254     find_do_view_edit (unparsed_view, edit, dir, text);
1255     return MSG_HANDLED;
1256 }
1257
1258 /* --------------------------------------------------------------------------------------------- */
1259
1260 static cb_ret_t
1261 find_callback (Dlg_head *h, Widget * sender, dlg_msg_t msg, int parm, void *data)
1262 {
1263     switch (msg)
1264     {
1265     case DLG_KEY:
1266         if (parm == KEY_F (3) || parm == KEY_F (13))
1267         {
1268             int unparsed_view = (parm == KEY_F (13));
1269             return view_edit_currently_selected_file (unparsed_view, 0);
1270         }
1271         if (parm == KEY_F (4))
1272         {
1273             return view_edit_currently_selected_file (0, 1);
1274         }
1275         return MSG_NOT_HANDLED;
1276
1277     case DLG_IDLE:
1278         do_search (h);
1279         return MSG_HANDLED;
1280
1281     default:
1282         return default_dlg_callback (h, sender, msg, parm, data);
1283     }
1284 }
1285
1286 /* --------------------------------------------------------------------------------------------- */
1287 /** Handles the Stop/Start button in the find window */
1288
1289 static int
1290 start_stop (WButton * button, int action)
1291 {
1292     (void) button;
1293     (void) action;
1294
1295     running = is_start;
1296     set_idle_proc (find_dlg, running);
1297     is_start = !is_start;
1298
1299     status_update (is_start ? _("Stopped") : _("Searching"));
1300     button_set_text (stop_button, fbuts[is_start ? 1 : 0].text);
1301
1302     return 0;
1303 }
1304
1305 /* --------------------------------------------------------------------------------------------- */
1306 /** Handle view command, when invoked as a button */
1307
1308 static int
1309 find_do_view_file (WButton * button, int action)
1310 {
1311     (void) button;
1312     (void) action;
1313
1314     view_edit_currently_selected_file (0, 0);
1315     return 0;
1316 }
1317
1318 /* --------------------------------------------------------------------------------------------- */
1319 /** Handle edit command, when invoked as a button */
1320
1321 static int
1322 find_do_edit_file (WButton * button, int action)
1323 {
1324     (void) button;
1325     (void) action;
1326
1327     view_edit_currently_selected_file (0, 1);
1328     return 0;
1329 }
1330
1331 /* --------------------------------------------------------------------------------------------- */
1332
1333 static void
1334 setup_gui (void)
1335 {
1336 #ifdef ENABLE_NLS
1337     static gboolean i18n_flag = FALSE;
1338
1339     if (!i18n_flag)
1340     {
1341         int i = sizeof (fbuts) / sizeof (fbuts[0]);
1342         while (i-- != 0)
1343         {
1344             fbuts[i].text = _(fbuts[i].text);
1345             fbuts[i].len = str_term_width1 (fbuts[i].text) + 3;
1346         }
1347
1348         fbuts[2].len += 2;      /* DEFPUSH_BUTTON */
1349         i18n_flag = TRUE;
1350     }
1351 #endif /* ENABLE_NLS */
1352
1353     /*
1354      * Dynamically place buttons centered within current window size
1355      */
1356     {
1357         int l0 = max (fbuts[0].len, fbuts[1].len);
1358         int l1 = fbuts[2].len + fbuts[3].len + l0 + fbuts[4].len;
1359         int l2 = fbuts[5].len + fbuts[6].len + fbuts[7].len;
1360         int r1, r2;
1361
1362         /* Check, if both button rows fit within FIND2_X */
1363         FIND2_X = max (l1 + 9, COLS - 16);
1364         FIND2_X = max (l2 + 8, FIND2_X);
1365
1366         /* compute amount of space between buttons for each row */
1367         r1 = (FIND2_X - 4 - l1) % 5;
1368         l1 = (FIND2_X - 4 - l1) / 5;
1369         r2 = (FIND2_X - 4 - l2) % 4;
1370         l2 = (FIND2_X - 4 - l2) / 4;
1371
1372         /* ...and finally, place buttons */
1373         fbuts[2].x = 2 + r1 / 2 + l1;
1374         fbuts[3].x = fbuts[2].x + fbuts[2].len + l1;
1375         fbuts[0].x = fbuts[3].x + fbuts[3].len + l1;
1376         fbuts[4].x = fbuts[0].x + l0 + l1;
1377         fbuts[5].x = 2 + r2 / 2 + l2;
1378         fbuts[6].x = fbuts[5].x + fbuts[5].len + l2;
1379         fbuts[7].x = fbuts[6].x + fbuts[6].len + l2;
1380     }
1381
1382     find_dlg =
1383         create_dlg (TRUE, 0, 0, FIND2_Y, FIND2_X, dialog_colors, find_callback,
1384                     "[Find File]", _("Find File"), DLG_CENTER | DLG_REVERSE);
1385
1386     add_widget (find_dlg,
1387                 button_new (FIND2_Y - 3, fbuts[7].x, B_VIEW, NORMAL_BUTTON,
1388                             fbuts[7].text, find_do_edit_file));
1389     add_widget (find_dlg,
1390                 button_new (FIND2_Y - 3, fbuts[6].x, B_VIEW, NORMAL_BUTTON,
1391                             fbuts[6].text, find_do_view_file));
1392     add_widget (find_dlg,
1393                 button_new (FIND2_Y - 3, fbuts[5].x, B_PANELIZE, NORMAL_BUTTON, fbuts[5].text,
1394                             NULL));
1395
1396     add_widget (find_dlg,
1397                 button_new (FIND2_Y - 4, fbuts[4].x, B_CANCEL, NORMAL_BUTTON, fbuts[4].text, NULL));
1398     stop_button =
1399         button_new (FIND2_Y - 4, fbuts[0].x, B_STOP, NORMAL_BUTTON, fbuts[0].text, start_stop);
1400     add_widget (find_dlg, stop_button);
1401     add_widget (find_dlg,
1402                 button_new (FIND2_Y - 4, fbuts[3].x, B_AGAIN, NORMAL_BUTTON, fbuts[3].text, NULL));
1403     add_widget (find_dlg,
1404                 button_new (FIND2_Y - 4, fbuts[2].x, B_ENTER, DEFPUSH_BUTTON, fbuts[2].text, NULL));
1405
1406     status_label = label_new (FIND2_Y - 7, 4, _("Searching"));
1407     add_widget (find_dlg, status_label);
1408
1409     found_num_label = label_new (FIND2_Y - 6, 4, "");
1410     add_widget (find_dlg, found_num_label);
1411
1412     find_list = listbox_new (2, 2, FIND2_Y - 10, FIND2_X - 4, FALSE, NULL);
1413     add_widget (find_dlg, find_list);
1414 }
1415
1416 /* --------------------------------------------------------------------------------------------- */
1417
1418 static int
1419 run_process (void)
1420 {
1421     int ret;
1422
1423     search_content_handle = mc_search_new (content_pattern, -1);
1424     if (search_content_handle)
1425     {
1426         search_content_handle->search_type =
1427             options.content_regexp ? MC_SEARCH_T_REGEX : MC_SEARCH_T_NORMAL;
1428         search_content_handle->is_case_sensitive = options.content_case_sens;
1429         search_content_handle->whole_words = options.content_whole_words;
1430         search_content_handle->is_all_charsets = options.content_all_charsets;
1431     }
1432     search_file_handle = mc_search_new (find_pattern, -1);
1433     search_file_handle->search_type = options.file_pattern ? MC_SEARCH_T_GLOB : MC_SEARCH_T_REGEX;
1434     search_file_handle->is_case_sensitive = options.file_case_sens;
1435     search_file_handle->is_all_charsets = options.file_all_charsets;
1436     search_file_handle->is_entire_line = options.file_pattern;
1437
1438     resuming = 0;
1439     set_idle_proc (find_dlg, 1);
1440     ret = run_dlg (find_dlg);
1441
1442     mc_search_free (search_file_handle);
1443     search_file_handle = NULL;
1444     mc_search_free (search_content_handle);
1445     search_content_handle = NULL;
1446
1447     return ret;
1448 }
1449
1450 /* --------------------------------------------------------------------------------------------- */
1451
1452 static void
1453 kill_gui (void)
1454 {
1455     set_idle_proc (find_dlg, 0);
1456     destroy_dlg (find_dlg);
1457 }
1458
1459 /* --------------------------------------------------------------------------------------------- */
1460
1461 static int
1462 find_file (const char *start_dir, const char *pattern, const char *content,
1463            char **dirname, char **filename)
1464 {
1465     int return_value = 0;
1466     char *dir_tmp = NULL, *file_tmp = NULL;
1467
1468     setup_gui ();
1469
1470     /* FIXME: Need to cleanup this, this ought to be passed non-globaly */
1471     find_pattern = (char *) pattern;
1472
1473     content_pattern = NULL;
1474     if (options.content_use && content != NULL && str_is_valid_string (content))
1475         content_pattern = g_strdup (content);
1476
1477     init_find_vars ();
1478     push_directory (start_dir);
1479
1480     return_value = run_process ();
1481
1482     /* Remove all the items from the stack */
1483     clear_stack ();
1484
1485     get_list_info (&file_tmp, &dir_tmp);
1486
1487     if (dir_tmp)
1488         *dirname = g_strdup (dir_tmp);
1489     if (file_tmp)
1490         *filename = g_strdup (file_tmp);
1491
1492     if (return_value == B_PANELIZE && *filename)
1493     {
1494         int status, link_to_dir, stale_link;
1495         int next_free = 0;
1496         int i;
1497         struct stat st;
1498         GList *entry;
1499         dir_list *list = &current_panel->dir;
1500         char *name = NULL;
1501
1502         for (i = 0, entry = find_list->list; entry != NULL; i++, entry = g_list_next (entry))
1503         {
1504             const char *lc_filename = NULL;
1505             WLEntry *le = (WLEntry *) entry->data;
1506
1507             if ((le->text == NULL) || (le->data == NULL))
1508                 continue;
1509
1510             if (content_pattern != NULL)
1511                 lc_filename = strchr (le->text + 4, ':') + 1;
1512             else
1513                 lc_filename = le->text + 4;
1514
1515             name = make_fullname (le->data, lc_filename);
1516             status = handle_path (list, name, &st, next_free, &link_to_dir, &stale_link);
1517             if (status == 0)
1518             {
1519                 g_free (name);
1520                 continue;
1521             }
1522             if (status == -1)
1523             {
1524                 g_free (name);
1525                 break;
1526             }
1527
1528             /* don't add files more than once to the panel */
1529             if (content_pattern != NULL && next_free > 0
1530                 && strcmp (list->list[next_free - 1].fname, name) == 0)
1531             {
1532                 g_free (name);
1533                 continue;
1534             }
1535
1536             if (!next_free)     /* first turn i.e clean old list */
1537                 panel_clean_dir (current_panel);
1538             list->list[next_free].fnamelen = strlen (name);
1539             list->list[next_free].fname = name;
1540             list->list[next_free].f.marked = 0;
1541             list->list[next_free].f.link_to_dir = link_to_dir;
1542             list->list[next_free].f.stale_link = stale_link;
1543             list->list[next_free].f.dir_size_computed = 0;
1544             list->list[next_free].st = st;
1545             list->list[next_free].sort_key = NULL;
1546             list->list[next_free].second_sort_key = NULL;
1547             next_free++;
1548             if (!(next_free & 15))
1549                 rotate_dash ();
1550         }
1551
1552         if (next_free)
1553         {
1554             current_panel->count = next_free;
1555             current_panel->is_panelized = 1;
1556
1557             if (start_dir[0] == PATH_SEP)
1558             {
1559                 int ret;
1560                 strcpy (current_panel->cwd, PATH_SEP_STR);
1561                 ret = chdir (PATH_SEP_STR);
1562             }
1563         }
1564     }
1565
1566     g_free (content_pattern);
1567     kill_gui ();
1568     do_search (NULL);           /* force do_search to release resources */
1569     g_free (old_dir);
1570     old_dir = NULL;
1571
1572     return return_value;
1573 }
1574
1575 /* --------------------------------------------------------------------------------------------- */
1576 /*** public functions ****************************************************************************/
1577 /* --------------------------------------------------------------------------------------------- */
1578
1579 void
1580 do_find (void)
1581 {
1582     char *start_dir = NULL, *pattern = NULL, *content = NULL;
1583     char *filename = NULL, *dirname = NULL;
1584     int v;
1585     gboolean dir_and_file_set;
1586
1587     while (find_parameters (&start_dir, &pattern, &content))
1588     {
1589         if (pattern[0] == '\0')
1590             break;              /* nothing search */
1591
1592         dirname = filename = NULL;
1593         is_start = FALSE;
1594         v = find_file (start_dir, pattern, content, &dirname, &filename);
1595         g_free (pattern);
1596
1597         if (v == B_ENTER)
1598         {
1599             if (dirname != NULL)
1600             {
1601                 do_cd (dirname, cd_exact);
1602                 if (filename != NULL)
1603                     try_to_select (current_panel,
1604                                    filename + (content != NULL
1605                                                ? strchr (filename + 4, ':') - filename + 1 : 4));
1606             }
1607             else if (filename != NULL)
1608                 do_cd (filename, cd_exact);
1609
1610             g_free (dirname);
1611             g_free (filename);
1612             break;
1613         }
1614
1615         g_free (content);
1616         dir_and_file_set = (dirname != NULL) && (filename != NULL);
1617         g_free (dirname);
1618         g_free (filename);
1619
1620         if (v == B_CANCEL)
1621             break;
1622
1623         if (v == B_PANELIZE)
1624         {
1625             if (dir_and_file_set)
1626             {
1627                 try_to_select (current_panel, NULL);
1628                 panel_re_sort (current_panel);
1629                 try_to_select (current_panel, NULL);
1630             }
1631             break;
1632         }
1633     }
1634 }
1635
1636 /* --------------------------------------------------------------------------------------------- */