src/filemanager/hotlist.c

   1 /*
   2    Directory hotlist -- for the Midnight Commander
   3
   4    Copyright (C) 1994-2020
   5    Free Software Foundation, Inc.
   6
   7    Written by:
   8    Radek Doulik, 1994
   9    Janne Kukonlehto, 1995
  10    Andrej Borsenkow, 1996
  11    Norbert Warmuth, 1997
  12    Andrew Borodin <aborodin@vmail.ru>, 2012, 2013
  13
  14    Janne did the original Hotlist code, Andrej made the groupable
  15    hotlist; the move hotlist and revamped the file format and made
  16    it stronger.
  17
  18    This file is part of the Midnight Commander.
  19
  20    The Midnight Commander is free software: you can redistribute it
  21    and/or modify it under the terms of the GNU General Public License as
  22    published by the Free Software Foundation, either version 3 of the License,
  23    or (at your option) any later version.
  24
  25    The Midnight Commander is distributed in the hope that it will be useful,
  26    but WITHOUT ANY WARRANTY; without even the implied warranty of
  27    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28    GNU General Public License for more details.
  29
  30    You should have received a copy of the GNU General Public License
  31    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  32  */
  33
  34 /** \file hotlist.c
  35  *  \brief Source: directory hotlist
  36  */
  37
  38 #include <config.h>
  39
  40 #include <ctype.h>
  41 #include <stdio.h>
  42 #include <string.h>
  43 #include <sys/types.h>
  44 #include <sys/stat.h>
  45 #include <unistd.h>
  46
  47 #include "lib/global.h"
  48
  49 #include "lib/tty/tty.h"        /* COLS */
  50 #include "lib/tty/key.h"        /* KEY_M_CTRL */
  51 #include "lib/skin.h"           /* colors */
  52 #include "lib/mcconfig.h"       /* Load/save directories hotlist */
  53 #include "lib/fileloc.h"
  54 #include "lib/strutil.h"
  55 #include "lib/vfs/vfs.h"
  56 #include "lib/util.h"
  57 #include "lib/widget.h"
  58
  59 #include "src/setup.h"          /* For profile_bname */
  60 #include "src/history.h"
  61
  62 #include "midnight.h"           /* current_panel */
  63 #include "command.h"            /* cmdline */
  64
  65 #include "hotlist.h"
  66
  67 /*** global variables ****************************************************************************/
  68
  69 /*** file scope macro definitions ****************************************************************/
  70
  71 #define UX 3
  72 #define UY 2
  73
  74 #define B_ADD_CURRENT   B_USER
  75 #define B_REMOVE        (B_USER + 1)
  76 #define B_NEW_GROUP     (B_USER + 2)
  77 #define B_NEW_ENTRY     (B_USER + 3)
  78 #define B_ENTER_GROUP   (B_USER + 4)
  79 #define B_UP_GROUP      (B_USER + 5)
  80 #define B_INSERT        (B_USER + 6)
  81 #define B_APPEND        (B_USER + 7)
  82 #define B_MOVE          (B_USER + 8)
  83 #ifdef ENABLE_VFS
  84 #define B_FREE_ALL_VFS  (B_USER + 9)
  85 #define B_REFRESH_VFS   (B_USER + 10)
  86 #endif
  87
  88 #define TKN_GROUP   0
  89 #define TKN_ENTRY   1
  90 #define TKN_STRING  2
  91 #define TKN_URL     3
  92 #define TKN_ENDGROUP 4
  93 #define TKN_COMMENT  5
  94 #define TKN_EOL      125
  95 #define TKN_EOF      126
  96 #define TKN_UNKNOWN  127
  97
  98 #define SKIP_TO_EOL \
  99 { \
 100     int _tkn; \
 101     while ((_tkn = hot_next_token ()) != TKN_EOF && _tkn != TKN_EOL) ; \
 102 }
 103
 104 #define CHECK_TOKEN(_TKN_) \
 105 tkn = hot_next_token (); \
 106 if (tkn != _TKN_) \
 107 { \
 108     hotlist_state.readonly = TRUE; \
 109     hotlist_state.file_error = TRUE; \
 110     while (tkn != TKN_EOL && tkn != TKN_EOF) \
 111         tkn = hot_next_token (); \
 112     break; \
 113 }
 114
 115 /*** file scope type declarations ****************************************************************/
 116
 117 enum HotListType
 118 {
 119     HL_TYPE_GROUP,
 120     HL_TYPE_ENTRY,
 121     HL_TYPE_COMMENT,
 122     HL_TYPE_DOTDOT
 123 };
 124
 125 static struct
 126 {
 127     /*
 128      * these reflect run time state
 129      */
 130
 131     gboolean loaded;            /* hotlist is loaded */
 132     gboolean readonly;          /* hotlist readonly */
 133     gboolean file_error;        /* parse error while reading file */
 134     gboolean running;           /* we are running dlg (and have to
 135                                    update listbox */
 136     gboolean moving;            /* we are in moving hotlist currently */
 137     gboolean modified;          /* hotlist was modified */
 138     hotlist_t type;             /* LIST_HOTLIST || LIST_VFSLIST */
 139 } hotlist_state;
 140
 141 /* Directory hotlist */
 142 struct hotlist
 143 {
 144     enum HotListType type;
 145     char *directory;
 146     char *label;
 147     struct hotlist *head;
 148     struct hotlist *up;
 149     struct hotlist *next;
 150 };
 151
 152 /*** file scope variables ************************************************************************/
 153
 154 static gboolean hotlist_has_dot_dot = TRUE;
 155
 156 static WDialog *hotlist_dlg, *movelist_dlg;
 157 static WGroupbox *hotlist_group, *movelist_group;
 158 static WListbox *l_hotlist, *l_movelist;
 159 static WLabel *pname;
 160
 161 static struct
 162 {
 163     int ret_cmd, flags, y, x, len;
 164     const char *text;
 165     int type;
 166     widget_pos_flags_t pos_flags;
 167 } hotlist_but[] =
 168 {
 169     /* *INDENT-OFF* */
 170     { B_ENTER, DEFPUSH_BUTTON, 0, 0, 0, N_("Change &to"),
 171             LIST_HOTLIST | LIST_VFSLIST | LIST_MOVELIST, WPOS_KEEP_LEFT | WPOS_KEEP_BOTTOM },
 172 #ifdef ENABLE_VFS
 173     { B_FREE_ALL_VFS, NORMAL_BUTTON, 0, 20, 0, N_("&Free VFSs now"),
 174             LIST_VFSLIST, WPOS_KEEP_LEFT | WPOS_KEEP_BOTTOM },
 175     { B_REFRESH_VFS, NORMAL_BUTTON, 0, 43, 0, N_("&Refresh"),
 176             LIST_VFSLIST, WPOS_KEEP_LEFT | WPOS_KEEP_BOTTOM },
 177 #endif
 178     { B_ADD_CURRENT, NORMAL_BUTTON, 0, 20, 0, N_("&Add current"),
 179             LIST_HOTLIST, WPOS_KEEP_LEFT | WPOS_KEEP_BOTTOM },
 180     { B_UP_GROUP, NORMAL_BUTTON, 0, 42, 0, N_("&Up"),
 181             LIST_HOTLIST | LIST_MOVELIST, WPOS_KEEP_LEFT | WPOS_KEEP_BOTTOM },
 182     { B_CANCEL, NORMAL_BUTTON, 0, 53, 0, N_("&Cancel"),
 183             LIST_HOTLIST | LIST_VFSLIST | LIST_MOVELIST, WPOS_KEEP_RIGHT | WPOS_KEEP_BOTTOM },
 184     { B_NEW_GROUP, NORMAL_BUTTON, 1, 0, 0, N_("New &group"),
 185             LIST_HOTLIST, WPOS_KEEP_LEFT | WPOS_KEEP_BOTTOM },
 186     { B_NEW_ENTRY, NORMAL_BUTTON, 1, 15, 0, N_("New &entry"),
 187             LIST_HOTLIST, WPOS_KEEP_LEFT | WPOS_KEEP_BOTTOM },
 188     { B_INSERT, NORMAL_BUTTON, 1, 0, 0, N_("&Insert"),
 189             LIST_MOVELIST, WPOS_KEEP_LEFT | WPOS_KEEP_BOTTOM },
 190     { B_APPEND, NORMAL_BUTTON, 1, 15, 0, N_("A&ppend"),
 191             LIST_MOVELIST, WPOS_KEEP_LEFT | WPOS_KEEP_BOTTOM },
 192     { B_REMOVE, NORMAL_BUTTON, 1, 30, 0, N_("&Remove"),
 193             LIST_HOTLIST, WPOS_KEEP_LEFT | WPOS_KEEP_BOTTOM },
 194     { B_MOVE, NORMAL_BUTTON, 1, 42, 0, N_("&Move"),
 195             LIST_HOTLIST, WPOS_KEEP_LEFT | WPOS_KEEP_BOTTOM }
 196     /* *INDENT-ON* */
 197 };
 198
 199 static const size_t hotlist_but_num = G_N_ELEMENTS (hotlist_but);
 200
 201 static struct hotlist *hotlist = NULL;
 202
 203 static struct hotlist *current_group;
 204
 205 static GString *tkn_buf = NULL;
 206
 207 static char *hotlist_file_name;
 208 static FILE *hotlist_file;
 209 static time_t hotlist_file_mtime;
 210
 211 static int list_level = 0;
 212
 213 /* --------------------------------------------------------------------------------------------- */
 214 /*** file scope functions ************************************************************************/
 215 /* --------------------------------------------------------------------------------------------- */
 216
 217 static void init_movelist (struct hotlist *item);
 218 static void add_new_group_cmd (void);
 219 static void add_new_entry_cmd (void);
 220 static void remove_from_hotlist (struct hotlist *entry);
 221 static void load_hotlist (void);
 222 static void add_dotdot_to_list (void);
 223
 224 /* --------------------------------------------------------------------------------------------- */
 225 /** If current->data is 0, then we are dealing with a VFS pathname */
 226
 227 static void
 228 update_path_name (void)
 229 {
 230     const char *text = "";
 231     char *p;
 232     WListbox *list = hotlist_state.moving ? l_movelist : l_hotlist;
 233     Widget *w = WIDGET (list);
 234
 235     if (!listbox_is_empty (list))
 236     {
 237         char *ctext = NULL;
 238         void *cdata = NULL;
 239
 240         listbox_get_current (list, &ctext, &cdata);
 241         if (cdata == NULL)
 242             text = ctext;
 243         else
 244         {
 245             struct hotlist *hlp = (struct hotlist *) cdata;
 246
 247             if (hlp->type == HL_TYPE_ENTRY || hlp->type == HL_TYPE_DOTDOT)
 248                 text = hlp->directory;
 249             else if (hlp->type == HL_TYPE_GROUP)
 250                 text = _("Subgroup - press ENTER to see list");
 251         }
 252     }
 253
 254     p = g_strconcat (" ", current_group->label, " ", (char *) NULL);
 255     if (hotlist_state.moving)
 256         groupbox_set_title (movelist_group, str_trunc (p, w->cols - 2));
 257     else
 258     {
 259         groupbox_set_title (hotlist_group, str_trunc (p, w->cols - 2));
 260         label_set_text (pname, str_trunc (text, w->cols));
 261     }
 262     g_free (p);
 263 }
 264
 265 /* --------------------------------------------------------------------------------------------- */
 266
 267 static void
 268 fill_listbox (WListbox * list)
 269 {
 270     struct hotlist *current;
 271     GString *buff;
 272
 273     buff = g_string_new ("");
 274
 275     for (current = current_group->head; current != NULL; current = current->next)
 276         switch (current->type)
 277         {
 278         case HL_TYPE_GROUP:
 279             {
 280                 /* buff clean up */
 281                 g_string_truncate (buff, 0);
 282                 g_string_append (buff, "->");
 283                 g_string_append (buff, current->label);
 284                 listbox_add_item (list, LISTBOX_APPEND_AT_END, 0, buff->str, current, FALSE);
 285             }
 286             break;
 287         case HL_TYPE_DOTDOT:
 288         case HL_TYPE_ENTRY:
 289             listbox_add_item (list, LISTBOX_APPEND_AT_END, 0, current->label, current, FALSE);
 290         default:
 291             break;
 292         }
 293
 294     g_string_free (buff, TRUE);
 295 }
 296
 297 /* --------------------------------------------------------------------------------------------- */
 298
 299 static void
 300 unlink_entry (struct hotlist *entry)
 301 {
 302     struct hotlist *current = current_group->head;
 303
 304     if (current == entry)
 305         current_group->head = entry->next;
 306     else
 307     {
 308         while (current != NULL && current->next != entry)
 309             current = current->next;
 310         if (current != NULL)
 311             current->next = entry->next;
 312     }
 313     entry->next = entry->up = NULL;
 314 }
 315
 316 /* --------------------------------------------------------------------------------------------- */
 317
 318 #ifdef ENABLE_VFS
 319 static void
 320 add_name_to_list (const char *path)
 321 {
 322     listbox_add_item (l_hotlist, LISTBOX_APPEND_AT_END, 0, path, NULL, FALSE);
 323 }
 324 #endif /* !ENABLE_VFS */
 325
 326 /* --------------------------------------------------------------------------------------------- */
 327
 328 static int
 329 hotlist_run_cmd (int action)
 330 {
 331     switch (action)
 332     {
 333     case B_MOVE:
 334         {
 335             struct hotlist *saved = current_group;
 336             struct hotlist *item = NULL;
 337             struct hotlist *moveto_item = NULL;
 338             struct hotlist *moveto_group = NULL;
 339             int ret;
 340
 341             if (listbox_is_empty (l_hotlist))
 342                 return 0;       /* empty group - nothing to do */
 343
 344             listbox_get_current (l_hotlist, NULL, (void **) &item);
 345             init_movelist (item);
 346             hotlist_state.moving = TRUE;
 347             ret = dlg_run (movelist_dlg);
 348             hotlist_state.moving = FALSE;
 349             listbox_get_current (l_movelist, NULL, (void **) &moveto_item);
 350             moveto_group = current_group;
 351             dlg_destroy (movelist_dlg);
 352             current_group = saved;
 353             if (ret == B_CANCEL)
 354                 return 0;
 355             if (moveto_item == item)
 356                 return 0;       /* If we insert/append a before/after a
 357                                    it hardly changes anything ;) */
 358             unlink_entry (item);
 359             listbox_remove_current (l_hotlist);
 360             item->up = moveto_group;
 361             if (moveto_group->head == NULL)
 362                 moveto_group->head = item;
 363             else if (moveto_item == NULL)
 364             {                   /* we have group with just comments */
 365                 struct hotlist *p = moveto_group->head;
 366
 367                 /* skip comments */
 368                 while (p->next != NULL)
 369                     p = p->next;
 370                 p->next = item;
 371             }
 372             else if (ret == B_ENTER || ret == B_APPEND)
 373             {
 374                 if (moveto_item->next == NULL)
 375                     moveto_item->next = item;
 376                 else
 377                 {
 378                     item->next = moveto_item->next;
 379                     moveto_item->next = item;
 380                 }
 381             }
 382             else if (moveto_group->head == moveto_item)
 383             {
 384                 moveto_group->head = item;
 385                 item->next = moveto_item;
 386             }
 387             else
 388             {
 389                 struct hotlist *p = moveto_group->head;
 390
 391                 while (p->next != moveto_item)
 392                     p = p->next;
 393                 item->next = p->next;
 394                 p->next = item;
 395             }
 396             listbox_remove_list (l_hotlist);
 397             fill_listbox (l_hotlist);
 398             repaint_screen ();
 399             hotlist_state.modified = TRUE;
 400             return 0;
 401         }
 402     case B_REMOVE:
 403         {
 404             struct hotlist *entry = NULL;
 405
 406             listbox_get_current (l_hotlist, NULL, (void **) &entry);
 407             remove_from_hotlist (entry);
 408         }
 409         return 0;
 410
 411     case B_NEW_GROUP:
 412         add_new_group_cmd ();
 413         return 0;
 414
 415     case B_ADD_CURRENT:
 416         add2hotlist_cmd ();
 417         return 0;
 418
 419     case B_NEW_ENTRY:
 420         add_new_entry_cmd ();
 421         return 0;
 422
 423     case B_ENTER:
 424     case B_ENTER_GROUP:
 425         {
 426             WListbox *list;
 427             void *data;
 428             struct hotlist *hlp;
 429
 430             list = hotlist_state.moving ? l_movelist : l_hotlist;
 431             listbox_get_current (list, NULL, &data);
 432
 433             if (data == NULL)
 434                 return 1;
 435
 436             hlp = (struct hotlist *) data;
 437
 438             if (hlp->type == HL_TYPE_ENTRY)
 439                 return (action == B_ENTER ? 1 : 0);
 440             if (hlp->type != HL_TYPE_DOTDOT)
 441             {
 442                 listbox_remove_list (list);
 443                 current_group = hlp;
 444                 fill_listbox (list);
 445                 return 0;
 446             }
 447             MC_FALLTHROUGH;     /* go up */
 448         }
 449         MC_FALLTHROUGH;         /* if list empty - just go up */
 450
 451     case B_UP_GROUP:
 452         {
 453             WListbox *list = hotlist_state.moving ? l_movelist : l_hotlist;
 454
 455             listbox_remove_list (list);
 456             current_group = current_group->up;
 457             fill_listbox (list);
 458             return 0;
 459         }
 460
 461 #ifdef ENABLE_VFS
 462     case B_FREE_ALL_VFS:
 463         vfs_expire (TRUE);
 464         MC_FALLTHROUGH;
 465
 466     case B_REFRESH_VFS:
 467         listbox_remove_list (l_hotlist);
 468         listbox_add_item (l_hotlist, LISTBOX_APPEND_AT_END, 0, mc_config_get_home_dir (), NULL,
 469                           FALSE);
 470         vfs_fill_names (add_name_to_list);
 471         return 0;
 472 #endif /* ENABLE_VFS */
 473
 474     default:
 475         return 1;
 476     }
 477 }
 478
 479 /* --------------------------------------------------------------------------------------------- */
 480
 481 static int
 482 hotlist_button_callback (WButton * button, int action)
 483 {
 484     int ret;
 485
 486     (void) button;
 487     ret = hotlist_run_cmd (action);
 488     update_path_name ();
 489     return ret;
 490 }
 491
 492 /* --------------------------------------------------------------------------------------------- */
 493
 494 static inline cb_ret_t
 495 hotlist_handle_key (WDialog * h, int key)
 496 {
 497     switch (key)
 498     {
 499     case KEY_M_CTRL | '\n':
 500         goto l1;
 501
 502     case '\n':
 503     case KEY_ENTER:
 504         if (hotlist_button_callback (NULL, B_ENTER) != 0)
 505         {
 506             h->ret_value = B_ENTER;
 507             dlg_stop (h);
 508         }
 509         return MSG_HANDLED;
 510
 511     case KEY_RIGHT:
 512         /* enter to the group */
 513         if (hotlist_state.type == LIST_VFSLIST)
 514             return MSG_NOT_HANDLED;
 515         return hotlist_button_callback (NULL, B_ENTER_GROUP) == 0 ? MSG_HANDLED : MSG_NOT_HANDLED;
 516
 517     case KEY_LEFT:
 518         /* leave the group */
 519         if (hotlist_state.type == LIST_VFSLIST)
 520             return MSG_NOT_HANDLED;
 521         return hotlist_button_callback (NULL, B_UP_GROUP) == 0 ? MSG_HANDLED : MSG_NOT_HANDLED;
 522
 523     case KEY_DC:
 524         if (hotlist_state.moving)
 525             return MSG_NOT_HANDLED;
 526         hotlist_button_callback (NULL, B_REMOVE);
 527         return MSG_HANDLED;
 528
 529       l1:
 530     case ALT ('\n'):
 531     case ALT ('\r'):
 532         if (!hotlist_state.moving)
 533         {
 534             void *ldata = NULL;
 535
 536             listbox_get_current (l_hotlist, NULL, &ldata);
 537
 538             if (ldata != NULL)
 539             {
 540                 struct hotlist *hlp = (struct hotlist *) ldata;
 541
 542                 if (hlp->type == HL_TYPE_ENTRY)
 543                 {
 544                     char *tmp;
 545
 546                     tmp = g_strconcat ("cd ", hlp->directory, (char *) NULL);
 547                     input_insert (cmdline, tmp, FALSE);
 548                     g_free (tmp);
 549                     h->ret_value = B_CANCEL;
 550                     dlg_stop (h);
 551                 }
 552             }
 553         }
 554         return MSG_HANDLED;     /* ignore key */
 555
 556     default:
 557         return MSG_NOT_HANDLED;
 558     }
 559 }
 560
 561 /* --------------------------------------------------------------------------------------------- */
 562
 563 static cb_ret_t
 564 hotlist_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
 565 {
 566     WDialog *h = DIALOG (w);
 567
 568     switch (msg)
 569     {
 570     case MSG_INIT:
 571     case MSG_NOTIFY:           /* MSG_NOTIFY is fired by the listbox to tell us the item has changed. */
 572         update_path_name ();
 573         return MSG_HANDLED;
 574
 575     case MSG_UNHANDLED_KEY:
 576         return hotlist_handle_key (h, parm);
 577
 578     case MSG_POST_KEY:
 579         /*
 580          * The code here has two purposes:
 581          *
 582          * (1) Always stay on the hotlist.
 583          *
 584          * Activating a button using its hotkey (and even pressing ENTER, as
 585          * there's a "default button") moves the focus to the button. But we
 586          * want to stay on the hotlist, to be able to use the usual keys (up,
 587          * down, etc.). So we do `widget_select (lst)`.
 588          *
 589          * (2) Refresh the hotlist.
 590          *
 591          * We may have run a command that changed the contents of the list.
 592          * We therefore need to refresh it. So we do `widget_draw (lst)`.
 593          */
 594         {
 595             Widget *lst;
 596
 597             lst = WIDGET (h == hotlist_dlg ? l_hotlist : l_movelist);
 598
 599             /* widget_select() already redraws the widget, but since it's a
 600              * no-op if the widget is already selected ("focused"), we have
 601              * to call widget_draw() separately. */
 602             if (!widget_get_state (lst, WST_FOCUSED))
 603                 widget_select (lst);
 604             else
 605                 widget_draw (lst);
 606         }
 607         return MSG_HANDLED;
 608
 609     case MSG_RESIZE:
 610         /* simply call dlg_set_size() with new size */
 611         dlg_set_size (h, LINES - (h == hotlist_dlg ? 2 : 6), COLS - 6);
 612         return MSG_HANDLED;
 613
 614     default:
 615         return dlg_default_callback (w, sender, msg, parm, data);
 616     }
 617 }
 618
 619 /* --------------------------------------------------------------------------------------------- */
 620
 621 static lcback_ret_t
 622 hotlist_listbox_callback (WListbox * list)
 623 {
 624     WDialog *dlg = DIALOG (WIDGET (list)->owner);
 625
 626     if (!listbox_is_empty (list))
 627     {
 628         void *data = NULL;
 629
 630         listbox_get_current (list, NULL, &data);
 631
 632         if (data != NULL)
 633         {
 634             struct hotlist *hlp = (struct hotlist *) data;
 635
 636             if (hlp->type == HL_TYPE_ENTRY)
 637             {
 638                 dlg->ret_value = B_ENTER;
 639                 dlg_stop (dlg);
 640                 return LISTBOX_DONE;
 641             }
 642             else
 643             {
 644                 hotlist_button_callback (NULL, B_ENTER);
 645                 send_message (dlg, NULL, MSG_POST_KEY, '\n', NULL);
 646                 return LISTBOX_CONT;
 647             }
 648         }
 649         else
 650         {
 651             dlg->ret_value = B_ENTER;
 652             dlg_stop (dlg);
 653             return LISTBOX_DONE;
 654         }
 655     }
 656
 657     hotlist_button_callback (NULL, B_UP_GROUP);
 658     send_message (dlg, NULL, MSG_POST_KEY, 'u', NULL);
 659     return LISTBOX_CONT;
 660 }
 661
 662 /* --------------------------------------------------------------------------------------------- */
 663 /**
 664  * Expands all button names (once) and recalculates button positions.
 665  * returns number of columns in the dialog box, which is 10 chars longer
 666  * then buttonbar.
 667  *
 668  * If common width of the window (i.e. in xterm) is less than returned
 669  * width - sorry :)  (anyway this did not handled in previous version too)
 670  */
 671
 672 static int
 673 init_i18n_stuff (int list_type, int cols)
 674 {
 675     size_t i;
 676
 677     static gboolean i18n_flag = FALSE;
 678
 679     if (!i18n_flag)
 680     {
 681         for (i = 0; i < hotlist_but_num; i++)
 682         {
 683 #ifdef ENABLE_NLS
 684             hotlist_but[i].text = _(hotlist_but[i].text);
 685 #endif /* ENABLE_NLS */
 686             hotlist_but[i].len = str_term_width1 (hotlist_but[i].text) + 3;
 687             if (hotlist_but[i].flags == DEFPUSH_BUTTON)
 688                 hotlist_but[i].len += 2;
 689         }
 690
 691         i18n_flag = TRUE;
 692     }
 693
 694     /* Dynamic resizing of buttonbars */
 695     {
 696         int len[2], count[2];   /* at most two lines of buttons */
 697         int cur_x[2];
 698
 699         len[0] = len[1] = 0;
 700         count[0] = count[1] = 0;
 701         cur_x[0] = cur_x[1] = 0;
 702
 703         /* Count len of buttonbars, assuming 1 extra space between buttons */
 704         for (i = 0; i < hotlist_but_num; i++)
 705             if ((hotlist_but[i].type & list_type) != 0)
 706             {
 707                 int row;
 708
 709                 row = hotlist_but[i].y;
 710                 ++count[row];
 711                 len[row] += hotlist_but[i].len + 1;
 712             }
 713
 714         (len[0])--;
 715         (len[1])--;
 716
 717         cols = MAX (cols, MAX (len[0], len[1]));
 718
 719         /* arrange buttons */
 720         for (i = 0; i < hotlist_but_num; i++)
 721             if ((hotlist_but[i].type & list_type) != 0)
 722             {
 723                 int row;
 724
 725                 row = hotlist_but[i].y;
 726
 727                 if (hotlist_but[i].x != 0)
 728                 {
 729                     /* not first int the row */
 730                     if (hotlist_but[i].ret_cmd == B_CANCEL)
 731                         hotlist_but[i].x = cols - hotlist_but[i].len - 6;
 732                     else
 733                         hotlist_but[i].x = cur_x[row];
 734                 }
 735
 736                 cur_x[row] += hotlist_but[i].len + 1;
 737             }
 738     }
 739
 740     return cols;
 741 }
 742
 743 /* --------------------------------------------------------------------------------------------- */
 744
 745 static void
 746 init_hotlist (hotlist_t list_type)
 747 {
 748     size_t i;
 749     const char *title, *help_node;
 750     int lines, cols;
 751     int y;
 752     int dh = 0;
 753     WGroup *g;
 754     WGroupbox *path_box;
 755     Widget *hotlist_widget;
 756
 757     do_refresh ();
 758
 759     lines = LINES - 2;
 760     cols = init_i18n_stuff (list_type, COLS - 6);
 761
 762 #ifdef ENABLE_VFS
 763     if (list_type == LIST_VFSLIST)
 764     {
 765         title = _("Active VFS directories");
 766         help_node = "[vfshot]"; /* FIXME - no such node */
 767         dh = 1;
 768     }
 769     else
 770 #endif /* !ENABLE_VFS */
 771     {
 772         title = _("Directory hotlist");
 773         help_node = "[Hotlist]";
 774     }
 775
 776     hotlist_dlg =
 777         dlg_create (TRUE, 0, 0, lines, cols, WPOS_CENTER, FALSE, dialog_colors, hotlist_callback,
 778                     NULL, help_node, title);
 779     g = GROUP (hotlist_dlg);
 780
 781     y = UY;
 782     hotlist_group = groupbox_new (y, UX, lines - 10 + dh, cols - 2 * UX, _("Top level group"));
 783     hotlist_widget = WIDGET (hotlist_group);
 784     group_add_widget_autopos (g, hotlist_widget, WPOS_KEEP_ALL, NULL);
 785
 786     l_hotlist =
 787         listbox_new (y + 1, UX + 1, hotlist_widget->lines - 2, hotlist_widget->cols - 2, FALSE,
 788                      hotlist_listbox_callback);
 789
 790     /* Fill the hotlist with the active VFS or the hotlist */
 791 #ifdef ENABLE_VFS
 792     if (list_type == LIST_VFSLIST)
 793     {
 794         listbox_add_item (l_hotlist, LISTBOX_APPEND_AT_END, 0, mc_config_get_home_dir (), NULL,
 795                           FALSE);
 796         vfs_fill_names (add_name_to_list);
 797     }
 798     else
 799 #endif /* !ENABLE_VFS */
 800         fill_listbox (l_hotlist);
 801
 802     /* insert before groupbox to view scrollbar */
 803     group_add_widget_autopos (g, l_hotlist, WPOS_KEEP_ALL, NULL);
 804
 805     y += hotlist_widget->lines;
 806
 807     path_box = groupbox_new (y, UX, 3, hotlist_widget->cols, _("Directory path"));
 808     group_add_widget_autopos (g, path_box, WPOS_KEEP_BOTTOM | WPOS_KEEP_HORZ, NULL);
 809
 810     pname = label_new (y + 1, UX + 2, "");
 811     group_add_widget_autopos (g, pname, WPOS_KEEP_BOTTOM | WPOS_KEEP_LEFT, NULL);
 812     y += WIDGET (path_box)->lines;
 813
 814     group_add_widget_autopos (g, hline_new (y++, -1, -1), WPOS_KEEP_BOTTOM, NULL);
 815
 816     for (i = 0; i < hotlist_but_num; i++)
 817         if ((hotlist_but[i].type & list_type) != 0)
 818             group_add_widget_autopos (g,
 819                                       button_new (y + hotlist_but[i].y, UX + hotlist_but[i].x,
 820                                                   hotlist_but[i].ret_cmd, hotlist_but[i].flags,
 821                                                   hotlist_but[i].text, hotlist_button_callback),
 822                                       hotlist_but[i].pos_flags, NULL);
 823
 824     widget_select (WIDGET (l_hotlist));
 825 }
 826
 827 /* --------------------------------------------------------------------------------------------- */
 828
 829 static void
 830 init_movelist (struct hotlist *item)
 831 {
 832     size_t i;
 833     char *hdr;
 834     int lines, cols;
 835     int y;
 836     WGroup *g;
 837     Widget *movelist_widget;
 838
 839     do_refresh ();
 840
 841     lines = LINES - 6;
 842     cols = init_i18n_stuff (LIST_MOVELIST, COLS - 6);
 843
 844     hdr = g_strdup_printf (_("Moving %s"), item->label);
 845
 846     movelist_dlg =
 847         dlg_create (TRUE, 0, 0, lines, cols, WPOS_CENTER, FALSE, dialog_colors, hotlist_callback,
 848                     NULL, "[Hotlist]", hdr);
 849     g = GROUP (movelist_dlg);
 850
 851     g_free (hdr);
 852
 853     y = UY;
 854     movelist_group = groupbox_new (y, UX, lines - 7, cols - 2 * UX, _("Directory label"));
 855     movelist_widget = WIDGET (movelist_group);
 856     group_add_widget_autopos (g, movelist_widget, WPOS_KEEP_ALL, NULL);
 857
 858     l_movelist =
 859         listbox_new (y + 1, UX + 1, movelist_widget->lines - 2, movelist_widget->cols - 2, FALSE,
 860                      hotlist_listbox_callback);
 861     fill_listbox (l_movelist);
 862     /* insert before groupbox to view scrollbar */
 863     group_add_widget_autopos (g, l_movelist, WPOS_KEEP_ALL, NULL);
 864
 865     y += movelist_widget->lines;
 866
 867     group_add_widget_autopos (g, hline_new (y++, -1, -1), WPOS_KEEP_BOTTOM, NULL);
 868
 869     for (i = 0; i < hotlist_but_num; i++)
 870         if ((hotlist_but[i].type & LIST_MOVELIST) != 0)
 871             group_add_widget_autopos (g,
 872                                       button_new (y + hotlist_but[i].y, UX + hotlist_but[i].x,
 873                                                   hotlist_but[i].ret_cmd, hotlist_but[i].flags,
 874                                                   hotlist_but[i].text, hotlist_button_callback),
 875                                       hotlist_but[i].pos_flags, NULL);
 876
 877     widget_select (WIDGET (l_movelist));
 878 }
 879
 880 /* --------------------------------------------------------------------------------------------- */
 881 /**
 882  * Destroy the list dialog.
 883  * Don't confuse with done_hotlist() for the list in memory.
 884  */
 885
 886 static void
 887 hotlist_done (void)
 888 {
 889     dlg_destroy (hotlist_dlg);
 890     l_hotlist = NULL;
 891 #if 0
 892     update_panels (UP_OPTIMIZE, UP_KEEPSEL);
 893 #endif
 894     repaint_screen ();
 895 }
 896
 897 /* --------------------------------------------------------------------------------------------- */
 898
 899 static inline char *
 900 find_group_section (struct hotlist *grp)
 901 {
 902     return g_strconcat (grp->directory, ".Group", (char *) NULL);
 903 }
 904
 905 /* --------------------------------------------------------------------------------------------- */
 906
 907 static struct hotlist *
 908 add2hotlist (char *label, char *directory, enum HotListType type, listbox_append_t pos)
 909 {
 910     struct hotlist *new;
 911     struct hotlist *current = NULL;
 912
 913     /*
 914      * Hotlist is neither loaded nor loading.
 915      * Must be called by "Ctrl-x a" before using hotlist.
 916      */
 917     if (current_group == NULL)
 918         load_hotlist ();
 919
 920     listbox_get_current (l_hotlist, NULL, (void **) &current);
 921
 922     /* Make sure '..' stays at the top of the list. */
 923     if ((current != NULL) && (current->type == HL_TYPE_DOTDOT))
 924         pos = LISTBOX_APPEND_AFTER;
 925
 926     new = g_new0 (struct hotlist, 1);
 927
 928     new->type = type;
 929     new->label = label;
 930     new->directory = directory;
 931     new->up = current_group;
 932
 933     if (type == HL_TYPE_GROUP)
 934     {
 935         current_group = new;
 936         add_dotdot_to_list ();
 937         current_group = new->up;
 938     }
 939
 940     if (current_group->head == NULL)
 941     {
 942         /* first element in group */
 943         current_group->head = new;
 944     }
 945     else if (pos == LISTBOX_APPEND_AFTER)
 946     {
 947         new->next = current->next;
 948         current->next = new;
 949     }
 950     else if (pos == LISTBOX_APPEND_BEFORE && current == current_group->head)
 951     {
 952         /* should be inserted before first item */
 953         new->next = current;
 954         current_group->head = new;
 955     }
 956     else if (pos == LISTBOX_APPEND_BEFORE)
 957     {
 958         struct hotlist *p = current_group->head;
 959
 960         while (p->next != current)
 961             p = p->next;
 962
 963         new->next = current;
 964         p->next = new;
 965     }
 966     else
 967     {                           /* append at the end */
 968         struct hotlist *p = current_group->head;
 969
 970         while (p->next != NULL)
 971             p = p->next;
 972
 973         p->next = new;
 974     }
 975
 976     if (hotlist_state.running && type != HL_TYPE_COMMENT && type != HL_TYPE_DOTDOT)
 977     {
 978         if (type == HL_TYPE_GROUP)
 979         {
 980             char *lbl;
 981
 982             lbl = g_strconcat ("->", new->label, (char *) NULL);
 983             listbox_add_item (l_hotlist, pos, 0, lbl, new, FALSE);
 984             g_free (lbl);
 985         }
 986         else
 987             listbox_add_item (l_hotlist, pos, 0, new->label, new, FALSE);
 988         listbox_select_entry (l_hotlist, l_hotlist->pos);
 989     }
 990
 991     return new;
 992 }
 993
 994 /* --------------------------------------------------------------------------------------------- */
 995
 996 static int
 997 add_new_entry_input (const char *header, const char *text1, const char *text2,
 998                      const char *help, char **r1, char **r2)
 999 {
1000     quick_widget_t quick_widgets[] = {
1001         /* *INDENT-OFF* */
1002         QUICK_LABELED_INPUT (text1, input_label_above, *r1, "input-lbl", r1, NULL,
1003                              FALSE, FALSE, INPUT_COMPLETE_NONE),
1004         QUICK_SEPARATOR (FALSE),
1005         QUICK_LABELED_INPUT (text2, input_label_above, *r2, "input-lbl", r2, NULL,
1006                              FALSE, FALSE, INPUT_COMPLETE_FILENAMES | INPUT_COMPLETE_CD),
1007         QUICK_START_BUTTONS (TRUE, TRUE),
1008             QUICK_BUTTON (N_("&Append"), B_APPEND, NULL, NULL),
1009             QUICK_BUTTON (N_("&Insert"), B_INSERT, NULL, NULL),
1010             QUICK_BUTTON (N_("&Cancel"), B_CANCEL, NULL, NULL),
1011         QUICK_END
1012         /* *INDENT-ON* */
1013     };
1014
1015     quick_dialog_t qdlg = {
1016         -1, -1, 64,
1017         header, help,
1018         quick_widgets, NULL, NULL
1019     };
1020
1021     int ret;
1022
1023     ret = quick_dialog (&qdlg);
1024
1025     return (ret != B_CANCEL) ? ret : 0;
1026 }
1027
1028 /* --------------------------------------------------------------------------------------------- */
1029
1030 static void
1031 add_new_entry_cmd (void)
1032 {
1033     char *title, *url, *to_free;
1034     int ret;
1035
1036     /* Take current directory as default value for input fields */
1037     to_free = title = url = vfs_path_to_str_flags (current_panel->cwd_vpath, 0, VPF_STRIP_PASSWORD);
1038
1039     ret = add_new_entry_input (_("New hotlist entry"), _("Directory label:"),
1040                                _("Directory path:"), "[Hotlist]", &title, &url);
1041     g_free (to_free);
1042
1043     if (ret == 0)
1044         return;
1045     if (title == NULL || *title == '\0' || url == NULL || *url == '\0')
1046     {
1047         g_free (title);
1048         g_free (url);
1049         return;
1050     }
1051
1052     if (ret == B_ENTER || ret == B_APPEND)
1053         add2hotlist (title, url, HL_TYPE_ENTRY, LISTBOX_APPEND_AFTER);
1054     else
1055         add2hotlist (title, url, HL_TYPE_ENTRY, LISTBOX_APPEND_BEFORE);
1056
1057     hotlist_state.modified = TRUE;
1058 }
1059
1060 /* --------------------------------------------------------------------------------------------- */
1061
1062 static int
1063 add_new_group_input (const char *header, const char *label, char **result)
1064 {
1065     quick_widget_t quick_widgets[] = {
1066         /* *INDENT-OFF* */
1067         QUICK_LABELED_INPUT (label, input_label_above, "", "input", result, NULL,
1068                              FALSE, FALSE, INPUT_COMPLETE_NONE),
1069         QUICK_START_BUTTONS (TRUE, TRUE),
1070             QUICK_BUTTON (N_("&Append"), B_APPEND, NULL, NULL),
1071             QUICK_BUTTON (N_("&Insert"), B_INSERT, NULL, NULL),
1072             QUICK_BUTTON (N_("&Cancel"), B_CANCEL, NULL, NULL),
1073         QUICK_END
1074         /* *INDENT-ON* */
1075     };
1076
1077     quick_dialog_t qdlg = {
1078         -1, -1, 64,
1079         header, "[Hotlist]",
1080         quick_widgets, NULL, NULL
1081     };
1082
1083     int ret;
1084
1085     ret = quick_dialog (&qdlg);
1086
1087     return (ret != B_CANCEL) ? ret : 0;
1088 }
1089
1090 /* --------------------------------------------------------------------------------------------- */
1091
1092 static void
1093 add_new_group_cmd (void)
1094 {
1095     char *label;
1096     int ret;
1097
1098     ret = add_new_group_input (_("New hotlist group"), _("Name of new group:"), &label);
1099     if (ret == 0 || label == NULL || *label == '\0')
1100         return;
1101
1102     if (ret == B_ENTER || ret == B_APPEND)
1103         add2hotlist (label, 0, HL_TYPE_GROUP, LISTBOX_APPEND_AFTER);
1104     else
1105         add2hotlist (label, 0, HL_TYPE_GROUP, LISTBOX_APPEND_BEFORE);
1106
1107     hotlist_state.modified = TRUE;
1108 }
1109
1110 /* --------------------------------------------------------------------------------------------- */
1111
1112 static void
1113 remove_group (struct hotlist *grp)
1114 {
1115     struct hotlist *current = grp->head;
1116
1117     while (current != NULL)
1118     {
1119         struct hotlist *next = current->next;
1120
1121         if (current->type == HL_TYPE_GROUP)
1122             remove_group (current);
1123
1124         g_free (current->label);
1125         g_free (current->directory);
1126         g_free (current);
1127
1128         current = next;
1129     }
1130 }
1131
1132 /* --------------------------------------------------------------------------------------------- */
1133
1134 static void
1135 remove_from_hotlist (struct hotlist *entry)
1136 {
1137     if (entry == NULL)
1138         return;
1139
1140     if (entry->type == HL_TYPE_DOTDOT)
1141         return;
1142
1143     if (confirm_directory_hotlist_delete)
1144     {
1145         char text[BUF_MEDIUM];
1146         int result;
1147
1148         if (safe_delete)
1149             query_set_sel (1);
1150
1151         g_snprintf (text, sizeof (text), _("Are you sure you want to remove entry \"%s\"?"),
1152                     str_trunc (entry->label, 30));
1153         result = query_dialog (Q_ ("DialogTitle|Delete"), text, D_ERROR | D_CENTER, 2,
1154                                _("&Yes"), _("&No"));
1155         if (result != 0)
1156             return;
1157     }
1158
1159     if (entry->type == HL_TYPE_GROUP)
1160     {
1161         struct hotlist *head = entry->head;
1162
1163         if (head != NULL && (head->type != HL_TYPE_DOTDOT || head->next != NULL))
1164         {
1165             char text[BUF_MEDIUM];
1166             int result;
1167
1168             g_snprintf (text, sizeof (text), _("Group \"%s\" is not empty.\nRemove it?"),
1169                         str_trunc (entry->label, 30));
1170             result = query_dialog (Q_ ("DialogTitle|Delete"), text, D_ERROR | D_CENTER, 2,
1171                                    _("&Yes"), _("&No"));
1172             if (result != 0)
1173                 return;
1174         }
1175
1176         remove_group (entry);
1177     }
1178
1179     unlink_entry (entry);
1180
1181     g_free (entry->label);
1182     g_free (entry->directory);
1183     g_free (entry);
1184     /* now remove list entry from screen */
1185     listbox_remove_current (l_hotlist);
1186     hotlist_state.modified = TRUE;
1187 }
1188
1189 /* --------------------------------------------------------------------------------------------- */
1190
1191 static void
1192 load_group (struct hotlist *grp)
1193 {
1194     gchar **profile_keys, **keys;
1195     char *group_section;
1196     struct hotlist *current = 0;
1197
1198     group_section = find_group_section (grp);
1199
1200     keys = mc_config_get_keys (mc_global.main_config, group_section, NULL);
1201
1202     current_group = grp;
1203
1204     for (profile_keys = keys; *profile_keys != NULL; profile_keys++)
1205         add2hotlist (mc_config_get_string (mc_global.main_config, group_section, *profile_keys, ""),
1206                      g_strdup (*profile_keys), HL_TYPE_GROUP, LISTBOX_APPEND_AT_END);
1207
1208     g_free (group_section);
1209     g_strfreev (keys);
1210
1211     keys = mc_config_get_keys (mc_global.main_config, grp->directory, NULL);
1212
1213     for (profile_keys = keys; *profile_keys != NULL; profile_keys++)
1214         add2hotlist (mc_config_get_string (mc_global.main_config, group_section, *profile_keys, ""),
1215                      g_strdup (*profile_keys), HL_TYPE_ENTRY, LISTBOX_APPEND_AT_END);
1216
1217     g_strfreev (keys);
1218
1219     for (current = grp->head; current; current = current->next)
1220         load_group (current);
1221 }
1222
1223 /* --------------------------------------------------------------------------------------------- */
1224
1225 static int
1226 hot_skip_blanks (void)
1227 {
1228     int c;
1229
1230     while ((c = getc (hotlist_file)) != EOF && c != '\n' && g_ascii_isspace (c))
1231         ;
1232     return c;
1233 }
1234
1235 /* --------------------------------------------------------------------------------------------- */
1236
1237 static int
1238 hot_next_token (void)
1239 {
1240     int c, ret = 0;
1241     size_t l;
1242
1243     if (tkn_buf == NULL)
1244         tkn_buf = g_string_new ("");
1245     g_string_set_size (tkn_buf, 0);
1246
1247   again:
1248     c = hot_skip_blanks ();
1249     switch (c)
1250     {
1251     case EOF:
1252         ret = TKN_EOF;
1253         break;
1254     case '\n':
1255         ret = TKN_EOL;
1256         break;
1257     case '#':
1258         while ((c = getc (hotlist_file)) != EOF && c != '\n')
1259             g_string_append_c (tkn_buf, c);
1260         ret = TKN_COMMENT;
1261         break;
1262     case '"':
1263         while ((c = getc (hotlist_file)) != EOF && c != '"')
1264         {
1265             if (c == '\\')
1266             {
1267                 c = getc (hotlist_file);
1268                 if (c == EOF)
1269                 {
1270                     g_string_free (tkn_buf, TRUE);
1271                     return TKN_EOF;
1272                 }
1273             }
1274             g_string_append_c (tkn_buf, c == '\n' ? ' ' : c);
1275         }
1276         ret = (c == EOF) ? TKN_EOF : TKN_STRING;
1277         break;
1278     case '\\':
1279         c = getc (hotlist_file);
1280         if (c == EOF)
1281         {
1282             g_string_free (tkn_buf, TRUE);
1283             return TKN_EOF;
1284         }
1285         if (c == '\n')
1286             goto again;
1287
1288         MC_FALLTHROUGH;         /* it is taken as normal character */
1289
1290     default:
1291         do
1292         {
1293             g_string_append_c (tkn_buf, g_ascii_toupper (c));
1294         }
1295         while ((c = fgetc (hotlist_file)) != EOF && (g_ascii_isalnum (c) || !isascii (c)));
1296         if (c != EOF)
1297             ungetc (c, hotlist_file);
1298         l = tkn_buf->len;
1299         if (strncmp (tkn_buf->str, "GROUP", l) == 0)
1300             ret = TKN_GROUP;
1301         else if (strncmp (tkn_buf->str, "ENTRY", l) == 0)
1302             ret = TKN_ENTRY;
1303         else if (strncmp (tkn_buf->str, "ENDGROUP", l) == 0)
1304             ret = TKN_ENDGROUP;
1305         else if (strncmp (tkn_buf->str, "URL", l) == 0)
1306             ret = TKN_URL;
1307         else
1308             ret = TKN_UNKNOWN;
1309         break;
1310     }
1311     return ret;
1312 }
1313
1314 /* --------------------------------------------------------------------------------------------- */
1315
1316 static void
1317 hot_load_group (struct hotlist *grp)
1318 {
1319     int tkn;
1320     struct hotlist *new_grp;
1321     char *label, *url;
1322
1323     current_group = grp;
1324
1325     while ((tkn = hot_next_token ()) != TKN_ENDGROUP)
1326         switch (tkn)
1327         {
1328         case TKN_GROUP:
1329             CHECK_TOKEN (TKN_STRING);
1330             new_grp =
1331                 add2hotlist (g_strndup (tkn_buf->str, tkn_buf->len), 0, HL_TYPE_GROUP,
1332                              LISTBOX_APPEND_AT_END);
1333             SKIP_TO_EOL;
1334             hot_load_group (new_grp);
1335             current_group = grp;
1336             break;
1337         case TKN_ENTRY:
1338             {
1339                 CHECK_TOKEN (TKN_STRING);
1340                 label = g_strndup (tkn_buf->str, tkn_buf->len);
1341                 CHECK_TOKEN (TKN_URL);
1342                 CHECK_TOKEN (TKN_STRING);
1343                 url = tilde_expand (tkn_buf->str);
1344                 add2hotlist (label, url, HL_TYPE_ENTRY, LISTBOX_APPEND_AT_END);
1345                 SKIP_TO_EOL;
1346             }
1347             break;
1348         case TKN_COMMENT:
1349             label = g_strndup (tkn_buf->str, tkn_buf->len);
1350             add2hotlist (label, 0, HL_TYPE_COMMENT, LISTBOX_APPEND_AT_END);
1351             break;
1352         case TKN_EOF:
1353             hotlist_state.readonly = TRUE;
1354             hotlist_state.file_error = TRUE;
1355             return;
1356         case TKN_EOL:
1357             /* skip empty lines */
1358             break;
1359         default:
1360             hotlist_state.readonly = TRUE;
1361             hotlist_state.file_error = TRUE;
1362             SKIP_TO_EOL;
1363             break;
1364         }
1365     SKIP_TO_EOL;
1366 }
1367
1368 /* --------------------------------------------------------------------------------------------- */
1369
1370 static void
1371 hot_load_file (struct hotlist *grp)
1372 {
1373     int tkn;
1374     struct hotlist *new_grp;
1375     char *label, *url;
1376
1377     current_group = grp;
1378
1379     while ((tkn = hot_next_token ()) != TKN_EOF)
1380         switch (tkn)
1381         {
1382         case TKN_GROUP:
1383             CHECK_TOKEN (TKN_STRING);
1384             new_grp =
1385                 add2hotlist (g_strndup (tkn_buf->str, tkn_buf->len), 0, HL_TYPE_GROUP,
1386                              LISTBOX_APPEND_AT_END);
1387             SKIP_TO_EOL;
1388             hot_load_group (new_grp);
1389             current_group = grp;
1390             break;
1391         case TKN_ENTRY:
1392             {
1393                 CHECK_TOKEN (TKN_STRING);
1394                 label = g_strndup (tkn_buf->str, tkn_buf->len);
1395                 CHECK_TOKEN (TKN_URL);
1396                 CHECK_TOKEN (TKN_STRING);
1397                 url = tilde_expand (tkn_buf->str);
1398                 add2hotlist (label, url, HL_TYPE_ENTRY, LISTBOX_APPEND_AT_END);
1399                 SKIP_TO_EOL;
1400             }
1401             break;
1402         case TKN_COMMENT:
1403             label = g_strndup (tkn_buf->str, tkn_buf->len);
1404             add2hotlist (label, 0, HL_TYPE_COMMENT, LISTBOX_APPEND_AT_END);
1405             break;
1406         case TKN_EOL:
1407             /* skip empty lines */
1408             break;
1409         default:
1410             hotlist_state.readonly = TRUE;
1411             hotlist_state.file_error = TRUE;
1412             SKIP_TO_EOL;
1413             break;
1414         }
1415 }
1416
1417 /* --------------------------------------------------------------------------------------------- */
1418
1419 static void
1420 clean_up_hotlist_groups (const char *section)
1421 {
1422     char *grp_section;
1423
1424     grp_section = g_strconcat (section, ".Group", (char *) NULL);
1425     if (mc_config_has_group (mc_global.main_config, section))
1426         mc_config_del_group (mc_global.main_config, section);
1427
1428     if (mc_config_has_group (mc_global.main_config, grp_section))
1429     {
1430         char **profile_keys, **keys;
1431
1432         keys = mc_config_get_keys (mc_global.main_config, grp_section, NULL);
1433
1434         for (profile_keys = keys; *profile_keys != NULL; profile_keys++)
1435             clean_up_hotlist_groups (*profile_keys);
1436
1437         g_strfreev (keys);
1438         mc_config_del_group (mc_global.main_config, grp_section);
1439     }
1440     g_free (grp_section);
1441 }
1442
1443 /* --------------------------------------------------------------------------------------------- */
1444
1445 static void
1446 load_hotlist (void)
1447 {
1448     gboolean remove_old_list = FALSE;
1449     struct stat stat_buf;
1450
1451     if (hotlist_state.loaded)
1452     {
1453         stat (hotlist_file_name, &stat_buf);
1454         if (hotlist_file_mtime < stat_buf.st_mtime)
1455             done_hotlist ();
1456         else
1457             return;
1458     }
1459
1460     if (hotlist_file_name == NULL)
1461         hotlist_file_name = mc_config_get_full_path (MC_HOTLIST_FILE);
1462
1463     hotlist = g_new0 (struct hotlist, 1);
1464     hotlist->type = HL_TYPE_GROUP;
1465     hotlist->label = g_strdup (_("Top level group"));
1466     hotlist->up = hotlist;
1467     /*
1468      * compatibility :-(
1469      */
1470     hotlist->directory = g_strdup ("Hotlist");
1471
1472     hotlist_file = fopen (hotlist_file_name, "r");
1473     if (hotlist_file == NULL)
1474     {
1475         int result;
1476
1477         load_group (hotlist);
1478         hotlist_state.loaded = TRUE;
1479         /*
1480          * just to be sure we got copy
1481          */
1482         hotlist_state.modified = TRUE;
1483         result = save_hotlist ();
1484         hotlist_state.modified = FALSE;
1485         if (result != 0)
1486             remove_old_list = TRUE;
1487         else
1488             message (D_ERROR, _("Hotlist Load"),
1489                      _
1490                      ("MC was unable to write %s file,\nyour old hotlist entries were not deleted"),
1491                      MC_USERCONF_DIR PATH_SEP_STR MC_HOTLIST_FILE);
1492     }
1493     else
1494     {
1495         hot_load_file (hotlist);
1496         fclose (hotlist_file);
1497         hotlist_state.loaded = TRUE;
1498     }
1499
1500     if (remove_old_list)
1501     {
1502         GError *mcerror = NULL;
1503
1504         clean_up_hotlist_groups ("Hotlist");
1505         if (!mc_config_save_file (mc_global.main_config, &mcerror))
1506             setup_save_config_show_error (mc_global.main_config->ini_path, &mcerror);
1507
1508         mc_error_message (&mcerror, NULL);
1509     }
1510
1511     stat (hotlist_file_name, &stat_buf);
1512     hotlist_file_mtime = stat_buf.st_mtime;
1513     current_group = hotlist;
1514 }
1515
1516 /* --------------------------------------------------------------------------------------------- */
1517
1518 static void
1519 hot_save_group (struct hotlist *grp)
1520 {
1521     struct hotlist *current;
1522     int i;
1523     char *s;
1524
1525 #define INDENT(n) \
1526 do { \
1527     for (i = 0; i < n; i++) \
1528         putc (' ', hotlist_file); \
1529 } while (0)
1530
1531     for (current = grp->head; current != NULL; current = current->next)
1532         switch (current->type)
1533         {
1534         case HL_TYPE_GROUP:
1535             INDENT (list_level);
1536             fputs ("GROUP \"", hotlist_file);
1537             for (s = current->label; *s != '\0'; s++)
1538             {
1539                 if (*s == '"' || *s == '\\')
1540                     putc ('\\', hotlist_file);
1541                 putc (*s, hotlist_file);
1542             }
1543             fputs ("\"\n", hotlist_file);
1544             list_level += 2;
1545             hot_save_group (current);
1546             list_level -= 2;
1547             INDENT (list_level);
1548             fputs ("ENDGROUP\n", hotlist_file);
1549             break;
1550         case HL_TYPE_ENTRY:
1551             INDENT (list_level);
1552             fputs ("ENTRY \"", hotlist_file);
1553             for (s = current->label; *s != '\0'; s++)
1554             {
1555                 if (*s == '"' || *s == '\\')
1556                     putc ('\\', hotlist_file);
1557                 putc (*s, hotlist_file);
1558             }
1559             fputs ("\" URL \"", hotlist_file);
1560             for (s = current->directory; *s != '\0'; s++)
1561             {
1562                 if (*s == '"' || *s == '\\')
1563                     putc ('\\', hotlist_file);
1564                 putc (*s, hotlist_file);
1565             }
1566             fputs ("\"\n", hotlist_file);
1567             break;
1568         case HL_TYPE_COMMENT:
1569             fprintf (hotlist_file, "#%s\n", current->label);
1570             break;
1571         case HL_TYPE_DOTDOT:
1572             /* do nothing */
1573             break;
1574         default:
1575             break;
1576         }
1577 }
1578
1579 /* --------------------------------------------------------------------------------------------- */
1580
1581 static void
1582 add_dotdot_to_list (void)
1583 {
1584     if (current_group != hotlist && hotlist_has_dot_dot)
1585         add2hotlist (g_strdup (".."), g_strdup (".."), HL_TYPE_DOTDOT, LISTBOX_APPEND_AT_END);
1586 }
1587
1588 /* --------------------------------------------------------------------------------------------- */
1589 /*** public functions ****************************************************************************/
1590 /* --------------------------------------------------------------------------------------------- */
1591
1592 void
1593 add2hotlist_cmd (void)
1594 {
1595     char *lc_prompt;
1596     const char *cp = N_("Label for \"%s\":");
1597     int l;
1598     char *label_string, *label;
1599
1600 #ifdef ENABLE_NLS
1601     cp = _(cp);
1602 #endif
1603
1604     l = str_term_width1 (cp);
1605     label_string = vfs_path_to_str_flags (current_panel->cwd_vpath, 0, VPF_STRIP_PASSWORD);
1606     lc_prompt = g_strdup_printf (cp, str_trunc (label_string, COLS - 2 * UX - (l + 8)));
1607     label =
1608         input_dialog (_("Add to hotlist"), lc_prompt, MC_HISTORY_HOTLIST_ADD, label_string,
1609                       INPUT_COMPLETE_NONE);
1610     g_free (lc_prompt);
1611
1612     if (label == NULL || *label == '\0')
1613     {
1614         g_free (label_string);
1615         g_free (label);
1616     }
1617     else
1618     {
1619         add2hotlist (label, label_string, HL_TYPE_ENTRY, LISTBOX_APPEND_AT_END);
1620         hotlist_state.modified = TRUE;
1621     }
1622 }
1623
1624 /* --------------------------------------------------------------------------------------------- */
1625
1626 char *
1627 hotlist_show (hotlist_t list_type)
1628 {
1629     char *target = NULL;
1630     int res;
1631
1632     hotlist_state.type = list_type;
1633     load_hotlist ();
1634
1635     init_hotlist (list_type);
1636
1637     /* display file info */
1638     tty_setcolor (SELECTED_COLOR);
1639
1640     hotlist_state.running = TRUE;
1641     res = dlg_run (hotlist_dlg);
1642     hotlist_state.running = FALSE;
1643     save_hotlist ();
1644
1645     if (res == B_ENTER)
1646     {
1647         char *text = NULL;
1648         struct hotlist *hlp = NULL;
1649
1650         listbox_get_current (l_hotlist, &text, (void **) &hlp);
1651         target = g_strdup (hlp != NULL ? hlp->directory : text);
1652     }
1653
1654     hotlist_done ();
1655     return target;
1656 }
1657
1658 /* --------------------------------------------------------------------------------------------- */
1659
1660 gboolean
1661 save_hotlist (void)
1662 {
1663     gboolean saved = FALSE;
1664     struct stat stat_buf;
1665
1666     if (!hotlist_state.readonly && hotlist_state.modified && hotlist_file_name != NULL)
1667     {
1668         mc_util_make_backup_if_possible (hotlist_file_name, ".bak");
1669
1670         hotlist_file = fopen (hotlist_file_name, "w");
1671         if (hotlist_file == NULL)
1672             mc_util_restore_from_backup_if_possible (hotlist_file_name, ".bak");
1673         else
1674         {
1675             hot_save_group (hotlist);
1676             fclose (hotlist_file);
1677             stat (hotlist_file_name, &stat_buf);
1678             hotlist_file_mtime = stat_buf.st_mtime;
1679             hotlist_state.modified = FALSE;
1680             saved = TRUE;
1681         }
1682     }
1683
1684     return saved;
1685 }
1686
1687 /* --------------------------------------------------------------------------------------------- */
1688 /**
1689  * Unload list from memory.
1690  * Don't confuse with hotlist_done() for GUI.
1691  */
1692
1693 void
1694 done_hotlist (void)
1695 {
1696     if (hotlist != NULL)
1697     {
1698         remove_group (hotlist);
1699         g_free (hotlist->label);
1700         g_free (hotlist->directory);
1701         MC_PTR_FREE (hotlist);
1702     }
1703
1704     hotlist_state.loaded = FALSE;
1705
1706     MC_PTR_FREE (hotlist_file_name);
1707     l_hotlist = NULL;
1708     current_group = NULL;
1709
1710     if (tkn_buf != NULL)
1711     {
1712         g_string_free (tkn_buf, TRUE);
1713         tkn_buf = NULL;
1714     }
1715 }
1716
1717 /* --------------------------------------------------------------------------------------------- */