src/widget.c

   1 /* Widgets for the Midnight Commander
   2
   3    Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003,
   4    2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
   5
   6    Authors: 1994, 1995 Radek Doulik
   7             1994, 1995 Miguel de Icaza
   8             1995 Jakub Jelinek
   9             1996 Andrej Borsenkow
  10             1997 Norbert Warmuth
  11
  12    This program is free software; you can redistribute it and/or modify
  13    it under the terms of the GNU General Public License as published by
  14    the Free Software Foundation; either version 2 of the License, or
  15    (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program; if not, write to the Free Software
  24    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  25
  26  */
  27
  28 /** \file widget.c
  29  *  \brief Source: widgets
  30  */
  31
  32 #include <config.h>
  33
  34 #include <assert.h>
  35 #include <ctype.h>
  36 #include <errno.h>
  37 #include <stdlib.h>
  38 #include <stdio.h>
  39 #include <string.h>
  40 #include <fcntl.h>
  41 #include <sys/types.h>
  42
  43 #include "global.h"
  44
  45 #include "../src/tty/tty.h"
  46 #include "../src/skin/skin.h"
  47 #include "../src/tty/mouse.h"
  48 #include "../src/tty/key.h"     /* XCTRL and ALT macros  */
  49 #include "../src/mcconfig/mcconfig.h"   /* for history loading and saving */
  50
  51 #include "../vfs/vfs.h"
  52
  53 #include "dialog.h"
  54 #include "widget.h"
  55 #include "wtools.h"
  56 #include "strutil.h"
  57
  58 #include "cmddef.h"             /* CK_ cmd name const */
  59 #include "keybind.h"            /* global_keymap_t */
  60 #include "fileloc.h"
  61 #include "panel.h"              /* current_panel */
  62
  63 const global_keymap_t *input_map;
  64
  65 static void
  66 widget_selectcolor (Widget *w, gboolean focused, gboolean hotkey)
  67 {
  68     Dlg_head *h = w->parent;
  69
  70     tty_setcolor (hotkey
  71         ? (focused
  72             ? DLG_HOT_FOCUSC (h)
  73             : DLG_HOT_NORMALC (h))
  74         : (focused
  75             ? DLG_FOCUSC (h)
  76             : DLG_NORMALC (h)));
  77 }
  78
  79 struct hotkey_t
  80 parse_hotkey (const char *text)
  81 {
  82     struct hotkey_t result;
  83     const char *cp, *p;
  84
  85     /* search for '&', that is not on the of text */
  86     cp = strchr (text, '&');
  87     if (cp != NULL && cp[1] != '\0') {
  88         result.start = g_strndup (text, cp - text);
  89
  90         /* skip '&' */
  91         cp++;
  92         p = str_cget_next_char (cp);
  93         result.hotkey = g_strndup (cp, p - cp);
  94
  95         cp = p;
  96         result.end = g_strdup (cp);
  97     } else {
  98         result.start = g_strdup (text);
  99         result.hotkey = NULL;
 100         result.end = NULL;
 101     }
 102
 103     return result;
 104 }
 105 void
 106 release_hotkey (const struct hotkey_t hotkey)
 107 {
 108     g_free (hotkey.start);
 109     g_free (hotkey.hotkey);
 110     g_free (hotkey.end);
 111 }
 112
 113 int
 114 hotkey_width (const struct hotkey_t hotkey)
 115 {
 116     int result;
 117
 118     result = str_term_width1 (hotkey.start);
 119     result+= (hotkey.hotkey != NULL) ? str_term_width1 (hotkey.hotkey) : 0;
 120     result+= (hotkey.end != NULL) ? str_term_width1 (hotkey.end) : 0;
 121     return result;
 122 }
 123
 124 static void
 125 draw_hotkey (Widget *w, const struct hotkey_t hotkey, gboolean focused)
 126 {
 127     widget_selectcolor (w, focused, FALSE);
 128     tty_print_string (hotkey.start);
 129
 130     if (hotkey.hotkey != NULL) {
 131         widget_selectcolor (w, focused, TRUE);
 132         tty_print_string (hotkey.hotkey);
 133         widget_selectcolor (w, focused, FALSE);
 134     }
 135
 136     if (hotkey.end != NULL)
 137         tty_print_string (hotkey.end);
 138 }
 139
 140
 141 /* Default callback for widgets */
 142 cb_ret_t
 143 default_proc (widget_msg_t msg, int parm)
 144 {
 145     (void) parm;
 146
 147     switch (msg) {
 148     case WIDGET_INIT:
 149     case WIDGET_FOCUS:
 150     case WIDGET_UNFOCUS:
 151     case WIDGET_DRAW:
 152     case WIDGET_DESTROY:
 153     case WIDGET_CURSOR:
 154     case WIDGET_IDLE:
 155         return MSG_HANDLED;
 156
 157     default:
 158         return MSG_NOT_HANDLED;
 159     }
 160 }
 161
 162 static int button_event (Gpm_Event *event, void *);
 163
 164 int quote = 0;
 165
 166 static cb_ret_t
 167 button_callback (Widget *w, widget_msg_t msg, int parm)
 168 {
 169     WButton *b = (WButton *) w;
 170     int stop = 0;
 171     int off = 0;
 172     Dlg_head *h = b->widget.parent;
 173
 174     switch (msg) {
 175     case WIDGET_HOTKEY:
 176         /*
 177          * Don't let the default button steal Enter from the current
 178          * button.  This is a workaround for the flawed event model
 179          * when hotkeys are sent to all widgets before the key is
 180          * handled by the current widget.
 181          */
 182         if (parm == '\n' && h->current == &b->widget) {
 183             button_callback (w, WIDGET_KEY, ' ');
 184             return MSG_HANDLED;
 185         }
 186
 187         if (parm == '\n' && b->flags == DEFPUSH_BUTTON) {
 188             button_callback (w, WIDGET_KEY, ' ');
 189             return MSG_HANDLED;
 190         }
 191
 192         if (b->text.hotkey != NULL) {
 193             if (g_ascii_tolower ((gchar)b->text.hotkey[0]) ==
 194                 g_ascii_tolower ((gchar)parm)) {
 195                 button_callback (w, WIDGET_KEY, ' ');
 196                 return MSG_HANDLED;
 197             }
 198         }
 199         return MSG_NOT_HANDLED;
 200
 201     case WIDGET_KEY:
 202         if (parm != ' ' && parm != '\n')
 203             return MSG_NOT_HANDLED;
 204
 205         if (b->callback)
 206             stop = (*b->callback) (b->action);
 207         if (!b->callback || stop) {
 208             h->ret_value = b->action;
 209             dlg_stop (h);
 210         }
 211         return MSG_HANDLED;
 212
 213     case WIDGET_CURSOR:
 214         switch (b->flags) {
 215         case DEFPUSH_BUTTON:
 216             off = 3;
 217             break;
 218         case NORMAL_BUTTON:
 219             off = 2;
 220             break;
 221         case NARROW_BUTTON:
 222             off = 1;
 223             break;
 224         case HIDDEN_BUTTON:
 225         default:
 226             off = 0;
 227             break;
 228         }
 229         widget_move (&b->widget, 0, b->hotpos + off);
 230         return MSG_HANDLED;
 231
 232     case WIDGET_UNFOCUS:
 233     case WIDGET_FOCUS:
 234     case WIDGET_DRAW:
 235         if (msg == WIDGET_UNFOCUS)
 236             b->selected = 0;
 237         else if (msg == WIDGET_FOCUS)
 238             b->selected = 1;
 239
 240         widget_selectcolor (w, b->selected, FALSE);
 241         widget_move (w, 0, 0);
 242
 243         switch (b->flags) {
 244         case DEFPUSH_BUTTON:
 245                 tty_print_string ("[< ");
 246             break;
 247         case NORMAL_BUTTON:
 248                 tty_print_string ("[ ");
 249             break;
 250         case NARROW_BUTTON:
 251                 tty_print_string ("[");
 252             break;
 253         case HIDDEN_BUTTON:
 254         default:
 255                 return MSG_HANDLED;
 256         }
 257
 258         draw_hotkey (w, b->text, b->selected);
 259
 260         switch (b->flags) {
 261             case DEFPUSH_BUTTON:
 262                 tty_print_string (" >]");
 263                 break;
 264             case NORMAL_BUTTON:
 265                 tty_print_string (" ]");
 266                 break;
 267             case NARROW_BUTTON:
 268                 tty_print_string ("]");
 269                 break;
 270         }
 271         return MSG_HANDLED;
 272
 273     case WIDGET_DESTROY:
 274         release_hotkey (b->text);
 275         return MSG_HANDLED;
 276
 277     default:
 278         return default_proc (msg, parm);
 279     }
 280 }
 281
 282 static int
 283 button_event (Gpm_Event *event, void *data)
 284 {
 285     WButton *b = data;
 286
 287     if (event->type & (GPM_DOWN|GPM_UP)){
 288         Dlg_head *h = b->widget.parent;
 289         dlg_select_widget (b);
 290         if (event->type & GPM_UP){
 291             button_callback ((Widget *) data, WIDGET_KEY, ' ');
 292             h->callback (h, &b->widget, DLG_POST_KEY, ' ', NULL);
 293             return MOU_NORMAL;
 294         }
 295     }
 296     return MOU_NORMAL;
 297 }
 298
 299 int
 300 button_get_len (const WButton *b)
 301 {
 302     int ret = hotkey_width (b->text);
 303     switch (b->flags) {
 304         case DEFPUSH_BUTTON:
 305             ret += 6;
 306             break;
 307         case NORMAL_BUTTON:
 308             ret += 4;
 309             break;
 310         case NARROW_BUTTON:
 311             ret += 2;
 312             break;
 313         case HIDDEN_BUTTON:
 314         default:
 315             return 0;
 316     }
 317     return ret;
 318 }
 319
 320 WButton *
 321 button_new (int y, int x, int action, int flags, const char *text,
 322             bcback callback)
 323 {
 324     WButton *b = g_new (WButton, 1);
 325
 326     b->action = action;
 327     b->flags  = flags;
 328     b->text = parse_hotkey (text);
 329
 330     init_widget (&b->widget, y, x, 1, button_get_len (b),
 331                  button_callback, button_event);
 332
 333     b->selected = 0;
 334     b->callback = callback;
 335     widget_want_hotkey (b->widget, 1);
 336     b->hotpos = (b->text.hotkey != NULL) ? str_term_width1 (b->text.start) : -1;
 337
 338     return b;
 339 }
 340
 341 const char *
 342 button_get_text (const WButton *b)
 343 {
 344     if (b->text.hotkey != NULL)
 345         return g_strconcat (b->text.start, "&", b->text.hotkey,
 346                             b->text.end, (char *) NULL);
 347     else
 348         return g_strdup (b->text.start);
 349 }
 350
 351 void
 352 button_set_text (WButton *b, const char *text)
 353 {
 354     release_hotkey (b->text);
 355     b->text = parse_hotkey (text);
 356     b->widget.cols = button_get_len (b);
 357     dlg_redraw (b->widget.parent);
 358 }
 359
 360
 361 /* Radio button widget */
 362 static int radio_event (Gpm_Event *event, void *);
 363
 364 static cb_ret_t
 365 radio_callback (Widget *w, widget_msg_t msg, int parm)
 366 {
 367     WRadio *r = (WRadio *) w;
 368     int i;
 369     Dlg_head *h = r->widget.parent;
 370
 371     switch (msg) {
 372     case WIDGET_HOTKEY:
 373         {
 374             int lp = g_ascii_tolower ((gchar)parm);
 375
 376             for (i = 0; i < r->count; i++) {
 377                 if (r->texts[i].hotkey != NULL) {
 378                     int c = g_ascii_tolower ((gchar)r->texts[i].hotkey[0]);
 379
 380                     if (c != lp)
 381                         continue;
 382                     r->pos = i;
 383
 384                     /* Take action */
 385                     radio_callback (w, WIDGET_KEY, ' ');
 386                     return MSG_HANDLED;
 387                 }
 388             }
 389         }
 390         return MSG_NOT_HANDLED;
 391
 392     case WIDGET_KEY:
 393         switch (parm) {
 394         case ' ':
 395             r->sel = r->pos;
 396             h->callback (h, w, DLG_ACTION, 0, NULL);
 397             radio_callback (w, WIDGET_FOCUS, ' ');
 398             return MSG_HANDLED;
 399
 400         case KEY_UP:
 401         case KEY_LEFT:
 402             if (r->pos > 0) {
 403                 r->pos--;
 404                 return MSG_HANDLED;
 405             }
 406             return MSG_NOT_HANDLED;
 407
 408         case KEY_DOWN:
 409         case KEY_RIGHT:
 410             if (r->count - 1 > r->pos) {
 411                 r->pos++;
 412                 return MSG_HANDLED;
 413             }
 414         }
 415         return MSG_NOT_HANDLED;
 416
 417     case WIDGET_CURSOR:
 418         h->callback (h, w, DLG_ACTION, 0, NULL);
 419         radio_callback (w, WIDGET_FOCUS, ' ');
 420         widget_move (&r->widget, r->pos, 1);
 421         return MSG_HANDLED;
 422
 423     case WIDGET_UNFOCUS:
 424     case WIDGET_FOCUS:
 425     case WIDGET_DRAW:
 426         for (i = 0; i < r->count; i++) {
 427             const gboolean focused = (i == r->pos && msg == WIDGET_FOCUS);
 428             widget_selectcolor (w, focused, FALSE);
 429             widget_move (&r->widget, i, 0);
 430             tty_print_string ((r->sel == i) ? "(*) " : "( ) ");
 431             draw_hotkey (w, r->texts[i], focused);
 432         }
 433         return MSG_HANDLED;
 434
 435     case WIDGET_DESTROY:
 436         for (i = 0; i < r->count; i++) {
 437             release_hotkey (r->texts[i]);
 438         }
 439         g_free (r->texts);
 440         return MSG_HANDLED;
 441
 442     default:
 443         return default_proc (msg, parm);
 444     }
 445 }
 446
 447 static int
 448 radio_event (Gpm_Event *event, void *data)
 449 {
 450     WRadio *r = data;
 451     Widget *w = data;
 452
 453     if (event->type & (GPM_DOWN|GPM_UP)){
 454         Dlg_head *h = r->widget.parent;
 455
 456         r->pos = event->y - 1;
 457         dlg_select_widget (r);
 458         if (event->type & GPM_UP){
 459             radio_callback (w, WIDGET_KEY, ' ');
 460             radio_callback (w, WIDGET_FOCUS, 0);
 461             h->callback (h, w, DLG_POST_KEY, ' ', NULL);
 462             return MOU_NORMAL;
 463         }
 464     }
 465     return MOU_NORMAL;
 466 }
 467
 468 WRadio *
 469 radio_new (int y, int x, int count, const char **texts)
 470 {
 471     WRadio *result = g_new (WRadio, 1);
 472     int i, max, m;
 473
 474     /* Compute the longest string */
 475     result->texts = g_new (struct hotkey_t, count);
 476
 477     max = 0;
 478     for (i = 0; i < count; i++){
 479         result->texts[i] = parse_hotkey (texts[i]);
 480         m = hotkey_width (result->texts[i]);
 481         if (m > max)
 482             max = m;
 483     }
 484
 485     init_widget (&result->widget, y, x, count, max, radio_callback, radio_event);
 486     result->state = 1;
 487     result->pos = 0;
 488     result->sel = 0;
 489     result->count = count;
 490     widget_want_hotkey (result->widget, 1);
 491
 492     return result;
 493 }
 494
 495 \f
 496 /* Checkbutton widget */
 497
 498 static int check_event (Gpm_Event *event, void *);
 499
 500 static cb_ret_t
 501 check_callback (Widget *w, widget_msg_t msg, int parm)
 502 {
 503     WCheck *c = (WCheck *) w;
 504     Dlg_head *h = c->widget.parent;
 505
 506     switch (msg) {
 507     case WIDGET_HOTKEY:
 508         if (c->text.hotkey != NULL) {
 509             if (g_ascii_tolower ((gchar)c->text.hotkey[0]) ==
 510                 g_ascii_tolower ((gchar)parm)) {
 511
 512                 check_callback (w, WIDGET_KEY, ' ');    /* make action */
 513                 return MSG_HANDLED;
 514             }
 515         }
 516         return MSG_NOT_HANDLED;
 517
 518     case WIDGET_KEY:
 519         if (parm != ' ')
 520             return MSG_NOT_HANDLED;
 521         c->state ^= C_BOOL;
 522         c->state ^= C_CHANGE;
 523         h->callback (h, w, DLG_ACTION, 0, NULL);
 524         check_callback (w, WIDGET_FOCUS, ' ');
 525         return MSG_HANDLED;
 526
 527     case WIDGET_CURSOR:
 528         widget_move (&c->widget, 0, 1);
 529         return MSG_HANDLED;
 530
 531     case WIDGET_FOCUS:
 532     case WIDGET_UNFOCUS:
 533     case WIDGET_DRAW:
 534         widget_selectcolor (w, msg == WIDGET_FOCUS, FALSE);
 535         widget_move (&c->widget, 0, 0);
 536         tty_print_string ((c->state & C_BOOL) ? "[x] " : "[ ] ");
 537         draw_hotkey (w, c->text, msg == WIDGET_FOCUS);
 538         return MSG_HANDLED;
 539
 540     case WIDGET_DESTROY:
 541         release_hotkey (c->text);
 542         return MSG_HANDLED;
 543
 544     default:
 545         return default_proc (msg, parm);
 546     }
 547 }
 548
 549 static int
 550 check_event (Gpm_Event *event, void *data)
 551 {
 552     WCheck *c = data;
 553     Widget *w = data;
 554
 555     if (event->type & (GPM_DOWN|GPM_UP)){
 556         Dlg_head *h = c->widget.parent;
 557
 558         dlg_select_widget (c);
 559         if (event->type & GPM_UP){
 560             check_callback (w, WIDGET_KEY, ' ');
 561             check_callback (w, WIDGET_FOCUS, 0);
 562             h->callback (h, w, DLG_POST_KEY, ' ', NULL);
 563             return MOU_NORMAL;
 564         }
 565     }
 566     return MOU_NORMAL;
 567 }
 568
 569 WCheck *
 570 check_new (int y, int x, int state, const char *text)
 571 {
 572     WCheck *c =  g_new (WCheck, 1);
 573
 574     c->text = parse_hotkey (text);
 575
 576     init_widget (&c->widget, y, x, 1, hotkey_width (c->text),
 577         check_callback, check_event);
 578     c->state = state ? C_BOOL : 0;
 579     widget_want_hotkey (c->widget, 1);
 580
 581     return c;
 582 }
 583
 584 static gboolean
 585 save_text_to_clip_file (const char *text)
 586 {
 587     int file;
 588     char *fname = NULL;
 589
 590     fname = g_build_filename (home_dir, EDIT_CLIP_FILE, NULL);
 591     file = mc_open (fname, O_CREAT | O_WRONLY | O_TRUNC,
 592                         S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH | O_BINARY);
 593     g_free (fname);
 594
 595     if (file == -1)
 596         return FALSE;
 597
 598     mc_write (file, (char *) text, strlen (text));
 599     mc_close (file);
 600     return TRUE;
 601 }
 602
 603 static gboolean
 604 load_text_from_clip_file (char **text)
 605 {
 606     char buf[BUF_LARGE];
 607     FILE *f;
 608     char *fname = NULL;
 609     gboolean first = TRUE;
 610
 611     fname = g_build_filename (home_dir, EDIT_CLIP_FILE, NULL);
 612     f = fopen (fname, "r");
 613     g_free (fname);
 614
 615     if (f == NULL)
 616         return FALSE;
 617
 618     *text = NULL;
 619
 620     while (fgets (buf, sizeof (buf), f)) {
 621         size_t len;
 622
 623         len = strlen (buf);
 624         if ( len > 0 ) {
 625             if (buf[len - 1] == '\n')
 626                 buf[len - 1] = '\0';
 627
 628             if (first) {
 629                 first = FALSE;
 630                 *text = g_strdup (buf);
 631             } else {
 632                 /* remove \n on EOL */
 633                 char *tmp;
 634
 635                 tmp = g_strconcat (*text, " ", buf, (char *) NULL);
 636                 g_free (*text);
 637                 *text = tmp;
 638             }
 639         }
 640     }
 641
 642     fclose (f);
 643
 644     return (*text != NULL);
 645 }
 646
 647 static gboolean
 648 panel_save_curent_file_to_clip_file (void)
 649 {
 650     gboolean res;
 651
 652     if (current_panel->marked == 0)
 653         res = save_text_to_clip_file (selection (current_panel)->fname);
 654     else {
 655         int i;
 656         gboolean first = TRUE;
 657         char *flist = NULL;
 658
 659         for (i = 0; i < current_panel->count; i++)
 660             if (current_panel->dir.list[i].f.marked != 0) { /* Skip the unmarked ones */
 661                 if (first) {
 662                     flist = g_strdup (current_panel->dir.list[i].fname);
 663                     first = FALSE;
 664                 } else {
 665                     /* Add empty lines after the file */
 666                     char *tmp;
 667
 668                     tmp = g_strconcat (flist, "\n", current_panel->dir.list[i].fname, (char *) NULL);
 669                     g_free (flist);
 670                     flist = tmp;
 671                 }
 672             }
 673
 674         if (flist != NULL) {
 675             res = save_text_to_clip_file (flist);
 676             g_free (flist);
 677         }
 678     }
 679     return res;
 680 }
 681
 682 \f
 683 /* Label widget */
 684
 685 static cb_ret_t
 686 label_callback (Widget *w, widget_msg_t msg, int parm)
 687 {
 688     WLabel *l = (WLabel *) w;
 689     Dlg_head *h = l->widget.parent;
 690
 691     switch (msg) {
 692     case WIDGET_INIT:
 693         return MSG_HANDLED;
 694
 695         /* We don't want to get the focus */
 696     case WIDGET_FOCUS:
 697         return MSG_NOT_HANDLED;
 698
 699     case WIDGET_DRAW:
 700         {
 701             char *p = l->text, *q, c = 0;
 702             int y = 0;
 703
 704             if (!l->text)
 705                 return MSG_HANDLED;
 706
 707             if (l->transparent)
 708                 tty_setcolor (DEFAULT_COLOR);
 709             else
 710                 tty_setcolor (DLG_NORMALC (h));
 711
 712             for (;;) {
 713                 q = strchr (p, '\n');
 714                 if (q != NULL) {
 715                     c = q[0];
 716                     q[0] = '\0';
 717                 }
 718
 719                 widget_move (&l->widget, y, 0);
 720                 tty_print_string (str_fit_to_term (p, l->widget.cols, J_LEFT));
 721
 722                 if (q == NULL)
 723                     break;
 724                 q[0] = c;
 725                 p = q + 1;
 726                 y++;
 727             }
 728             return MSG_HANDLED;
 729         }
 730
 731     case WIDGET_DESTROY:
 732         g_free (l->text);
 733         return MSG_HANDLED;
 734
 735     default:
 736         return default_proc (msg, parm);
 737     }
 738 }
 739
 740 void
 741 label_set_text (WLabel *label, const char *text)
 742 {
 743     int newcols = label->widget.cols;
 744     int newlines;
 745
 746     if (label->text && text && !strcmp (label->text, text))
 747         return; /* Flickering is not nice */
 748
 749     g_free (label->text);
 750
 751     if (text != NULL) {
 752         label->text = g_strdup (text);
 753         if (label->auto_adjust_cols) {
 754             str_msg_term_size (text, &newlines, &newcols);
 755             if (newcols > label->widget.cols)
 756             label->widget.cols = newcols;
 757             if (newlines > label->widget.lines)
 758                 label->widget.lines = newlines;
 759         }
 760     } else label->text = NULL;
 761
 762     if (label->widget.parent)
 763         label_callback ((Widget *) label, WIDGET_DRAW, 0);
 764
 765     if (newcols < label->widget.cols)
 766         label->widget.cols = newcols;
 767 }
 768
 769 WLabel *
 770 label_new (int y, int x, const char *text)
 771 {
 772     WLabel *l;
 773     int cols = 1;
 774     int lines = 1;
 775
 776     if (text != NULL)
 777         str_msg_term_size (text, &lines, &cols);
 778
 779     l = g_new (WLabel, 1);
 780     init_widget (&l->widget, y, x, lines, cols, label_callback, NULL);
 781     l->text = (text != NULL) ? g_strdup (text) : NULL;
 782     l->auto_adjust_cols = 1;
 783     l->transparent = 0;
 784     widget_want_cursor (l->widget, 0);
 785     return l;
 786 }
 787
 788 \f
 789 /* Gauge widget (progress indicator) */
 790 /* Currently width is hardcoded here for text mode */
 791 #define gauge_len 47
 792
 793 static cb_ret_t
 794 gauge_callback (Widget *w, widget_msg_t msg, int parm)
 795 {
 796     WGauge *g = (WGauge *) w;
 797     Dlg_head *h = g->widget.parent;
 798
 799     if (msg == WIDGET_INIT)
 800         return MSG_HANDLED;
 801
 802     /* We don't want to get the focus */
 803     if (msg == WIDGET_FOCUS)
 804         return MSG_NOT_HANDLED;
 805
 806     if (msg == WIDGET_DRAW){
 807         widget_move (&g->widget, 0, 0);
 808         tty_setcolor (DLG_NORMALC (h));
 809         if (!g->shown)
 810             tty_printf ("%*s", gauge_len, "");
 811         else {
 812             int percentage, columns;
 813             long total = g->max, done = g->current;
 814
 815             if (total <= 0 || done < 0) {
 816                 done = 0;
 817                 total = 100;
 818             }
 819             if (done > total)
 820                 done = total;
 821             while (total > 65535) {
 822                 total /= 256;
 823                 done /= 256;
 824             }
 825             percentage = (200 * done / total + 1) / 2;
 826             columns = (2 * (gauge_len - 7) * done / total + 1) / 2;
 827             tty_print_char ('[');
 828             tty_setcolor (GAUGE_COLOR);
 829             tty_printf ("%*s", (int) columns, "");
 830             tty_setcolor (DLG_NORMALC (h));
 831             tty_printf ("%*s] %3d%%", (int)(gauge_len - 7 - columns), "", (int) percentage);
 832         }
 833         return MSG_HANDLED;
 834     }
 835
 836     return default_proc (msg, parm);
 837 }
 838
 839 void
 840 gauge_set_value (WGauge *g, int max, int current)
 841 {
 842     if (g->current == current && g->max == max)
 843         return; /* Do not flicker */
 844     if (max == 0)
 845         max = 1; /* I do not like division by zero :) */
 846
 847     g->current = current;
 848     g->max = max;
 849     gauge_callback ((Widget *) g, WIDGET_DRAW, 0);
 850 }
 851
 852 void
 853 gauge_show (WGauge *g, int shown)
 854 {
 855     if (g->shown == shown)
 856         return;
 857     g->shown = shown;
 858     gauge_callback ((Widget *) g, WIDGET_DRAW, 0);
 859 }
 860
 861 WGauge *
 862 gauge_new (int y, int x, int shown, int max, int current)
 863 {
 864     WGauge *g = g_new (WGauge, 1);
 865
 866     init_widget (&g->widget, y, x, 1, gauge_len, gauge_callback, NULL);
 867     g->shown = shown;
 868     if (max == 0)
 869         max = 1; /* I do not like division by zero :) */
 870     g->max = max;
 871     g->current = current;
 872     widget_want_cursor (g->widget, 0);
 873     return g;
 874 }
 875
 876 \f
 877 /* Input widget */
 878
 879 /* {{{ history button */
 880
 881 #define LARGE_HISTORY_BUTTON 1
 882
 883 #ifdef LARGE_HISTORY_BUTTON
 884 #  define HISTORY_BUTTON_WIDTH 3
 885 #else
 886 #  define HISTORY_BUTTON_WIDTH 1
 887 #endif
 888
 889 #define should_show_history_button(in) \
 890 (in->history && in->field_width > HISTORY_BUTTON_WIDTH * 2 + 1 && in->widget.parent)
 891
 892 static void draw_history_button (WInput * in)
 893 {
 894     char c;
 895     c = in->history->next ? (in->history->prev ? '|' : 'v') : '^';
 896     widget_move (&in->widget, 0, in->field_width - HISTORY_BUTTON_WIDTH);
 897 #ifdef LARGE_HISTORY_BUTTON
 898     {
 899         Dlg_head *h;
 900         h = in->widget.parent;
 901         tty_setcolor (NORMAL_COLOR);
 902         tty_print_string ("[ ]");
 903         /* Too distracting: tty_setcolor (MARKED_COLOR); */
 904         widget_move (&in->widget, 0, in->field_width - HISTORY_BUTTON_WIDTH + 1);
 905         tty_print_char (c);
 906     }
 907 #else
 908     tty_setcolor (MARKED_COLOR);
 909     tty_print_char (c);
 910 #endif
 911 }
 912
 913 /* }}} history button */
 914
 915
 916 /* Input widgets now have a global kill ring */
 917 /* Pointer to killed data */
 918 static char *kill_buffer = 0;
 919
 920 void
 921 update_input (WInput *in, int clear_first)
 922 {
 923     int has_history = 0;
 924     int    i;
 925     int    buf_len = str_length (in->buffer);
 926     const char *cp;
 927     int pw;
 928
 929     if (should_show_history_button (in))
 930         has_history = HISTORY_BUTTON_WIDTH;
 931
 932     if (in->disable_update)
 933         return;
 934
 935     pw = str_term_width2 (in->buffer, in->point);
 936
 937     /* Make the point visible */
 938     if ((pw < in->term_first_shown) ||
 939          (pw >= in->term_first_shown + in->field_width - has_history)) {
 940
 941         in->term_first_shown = pw - (in->field_width / 3);
 942         if (in->term_first_shown < 0)
 943             in->term_first_shown = 0;
 944     }
 945
 946     /* Adjust the mark */
 947     if (in->mark > buf_len)
 948         in->mark = buf_len;
 949
 950     if (has_history)
 951         draw_history_button (in);
 952
 953     tty_setcolor (in->color);
 954
 955     widget_move (&in->widget, 0, 0);
 956
 957     if (!in->is_password) {
 958         tty_print_string (str_term_substring (in->buffer, in->term_first_shown,
 959                 in->field_width - has_history));
 960     } else {
 961         cp = in->buffer;
 962         for (i = -in->term_first_shown; i < in->field_width - has_history; i++){
 963             if (i >= 0) {
 964                 tty_print_char ((cp[0] != '\0') ? '*' : ' ');
 965             }
 966             if (cp[0] != '\0') str_cnext_char (&cp);
 967         }
 968     }
 969
 970     if (clear_first)
 971             in->first = 0;
 972 }
 973
 974 void
 975 winput_set_origin (WInput *in, int x, int field_width)
 976 {
 977     in->widget.x    = x;
 978     in->field_width = in->widget.cols = field_width;
 979     update_input (in, 0);
 980 }
 981
 982 /* {{{ history saving and loading */
 983
 984 int num_history_items_recorded = 60;
 985
 986 /*
 987    This loads and saves the history of an input line to and from the
 988    widget. It is called with the widgets history name on creation of the
 989    widget, and returns the GList list. It stores histories in the file
 990    ~/.mc/history in using the profile code.
 991
 992    If def_text is passed as INPUT_LAST_TEXT (to the input_new()
 993    function) then input_new assigns the default text to be the last text
 994    entered, or "" if not found.
 995  */
 996
 997 GList *
 998 history_get (const char *input_name)
 999 {
1000     size_t i;
1001     GList *hist = NULL;
1002     char *profile;
1003     mc_config_t *cfg;
1004     char **keys;
1005     size_t keys_num = 0;
1006     char *this_entry;
1007
1008     if (!num_history_items_recorded)    /* this is how to disable */
1009         return NULL;
1010     if (!input_name || !*input_name)
1011         return NULL;
1012
1013     profile = g_build_filename (home_dir, MC_USERCONF_DIR, MC_HISTORY_FILE, NULL);
1014     cfg = mc_config_init (profile);
1015
1016     /* get number of keys */
1017     keys = mc_config_get_keys (cfg, input_name, &keys_num);
1018     g_strfreev (keys);
1019
1020     for (i = 0; i < keys_num; i++) {
1021         char key_name[BUF_TINY];
1022         g_snprintf (key_name, sizeof (key_name), "%lu", (unsigned long)i);
1023         this_entry = mc_config_get_string (cfg, input_name, key_name, "");
1024
1025         if (this_entry != NULL)
1026             hist = list_append_unique (hist, this_entry);
1027     }
1028
1029     mc_config_deinit (cfg);
1030     g_free (profile);
1031
1032     /* return pointer to the last entry in the list */
1033     return g_list_last (hist);
1034 }
1035
1036 void
1037 history_put (const char *input_name, GList *h)
1038 {
1039     int i;
1040     char *profile;
1041     mc_config_t *cfg;
1042
1043     if (!input_name)
1044         return;
1045
1046     if (!*input_name)
1047         return;
1048
1049     if (!h)
1050         return;
1051
1052     if (!num_history_items_recorded)    /* this is how to disable */
1053         return;
1054
1055     profile = g_build_filename (home_dir, MC_USERCONF_DIR, MC_HISTORY_FILE, NULL);
1056
1057     if ((i = open (profile, O_CREAT | O_EXCL, S_IRUSR | S_IWUSR)) != -1)
1058         close (i);
1059
1060     /* Make sure the history is only readable by the user */
1061     if (chmod (profile, S_IRUSR | S_IWUSR) == -1 && errno != ENOENT) {
1062         g_free (profile);
1063         return;
1064     }
1065
1066     /* go to end of list */
1067     h = g_list_last (h);
1068
1069     /* go back 60 places */
1070     for (i = 0; i < num_history_items_recorded - 1 && h->prev; i++)
1071         h = g_list_previous (h);
1072
1073     cfg = mc_config_init(profile);
1074
1075     if (input_name)
1076         mc_config_del_group(cfg,input_name);
1077
1078     /* dump histories into profile */
1079     for (i = 0; h; h = g_list_next (h)) {
1080         char *text = (char *) h->data;
1081
1082         /* We shouldn't have null entries, but let's be sure */
1083         if (text != NULL) {
1084             char key_name[BUF_TINY];
1085             g_snprintf (key_name, sizeof (key_name), "%d", i++);
1086             mc_config_set_string(cfg,input_name, key_name, text);
1087         }
1088     }
1089
1090     mc_config_save_file (cfg, NULL);
1091     mc_config_deinit(cfg);
1092     g_free (profile);
1093 }
1094
1095 /* }}} history saving and loading */
1096
1097
1098 /* {{{ history display */
1099
1100 static const char *
1101 i18n_htitle (void)
1102 {
1103     return _(" History ");
1104 }
1105
1106 static void
1107 listbox_fwd (WListbox *l)
1108 {
1109     if (l->current != l->list->prev)
1110         listbox_select_entry (l, l->current->next);
1111     else
1112         listbox_select_first (l);
1113 }
1114
1115 typedef struct {
1116     Widget *widget;
1117     int count;
1118     size_t maxlen;
1119 } dlg_hist_data;
1120
1121 static cb_ret_t
1122 dlg_hist_reposition (Dlg_head *dlg_head)
1123 {
1124     dlg_hist_data *data;
1125     int x = 0, y, he, wi;
1126
1127     /* guard checks */
1128     if ((dlg_head == NULL)
1129         || (dlg_head->data == NULL))
1130         return MSG_NOT_HANDLED;
1131
1132     data = (dlg_hist_data *) dlg_head->data;
1133
1134     y = data->widget->y;
1135     he = data->count + 2;
1136
1137     if (he <= y || y > (LINES - 6)) {
1138         he = min (he, y - 1);
1139         y -= he;
1140     } else {
1141         y++;
1142         he = min (he, LINES - y);
1143     }
1144
1145     if (data->widget->x > 2)
1146         x = data->widget->x - 2;
1147
1148     wi = data->maxlen + 4;
1149
1150     if ((wi + x) > COLS) {
1151         wi = min (wi, COLS);
1152         x = COLS - wi;
1153     }
1154
1155     dlg_set_position (dlg_head, y, x, y + he, x + wi);
1156
1157     return MSG_HANDLED;
1158 }
1159
1160 static cb_ret_t
1161 dlg_hist_callback (Dlg_head *h, Widget *sender,
1162                     dlg_msg_t msg, int parm, void *data)
1163 {
1164     switch (msg) {
1165     case DLG_RESIZE:
1166         return dlg_hist_reposition (h);
1167
1168     default:
1169         return default_dlg_callback (h, sender, msg, parm, data);
1170     }
1171 }
1172
1173 char *
1174 show_hist (GList *history, Widget *widget)
1175 {
1176     GList *hi, *z;
1177     size_t maxlen, i, count = 0;
1178     char *q, *r = NULL;
1179     Dlg_head *query_dlg;
1180     WListbox *query_list;
1181     dlg_hist_data hist_data;
1182
1183     if (history == NULL)
1184         return NULL;
1185
1186     maxlen = str_term_width1 (i18n_htitle ());
1187
1188     z = g_list_first (history);
1189     hi = z;
1190     while (hi) {
1191         i = str_term_width1 ((char *) hi->data);
1192         maxlen = max (maxlen, i);
1193         count++;
1194         hi = g_list_next (hi);
1195     }
1196
1197     hist_data.maxlen = maxlen;
1198     hist_data.widget = widget;
1199     hist_data.count = count;
1200
1201     query_dlg =
1202         create_dlg (0, 0, 4, 4, dialog_colors, dlg_hist_callback,
1203                         "[History-query]", i18n_htitle (), DLG_COMPACT);
1204     query_dlg->data = &hist_data;
1205
1206     query_list = listbox_new (1, 1, 2, 2, NULL);
1207
1208     /* this call makes list stick to all sides of dialog, effectively make
1209        it be resized with dialog */
1210     add_widget_autopos (query_dlg, query_list, WPOS_KEEP_ALL);
1211
1212     /* to avoid diplicating of (calculating sizes in two places)
1213        code, call dlg_hist_callback function here, to set dialog and
1214        controls positions.
1215        The main idea - create 4x4 dialog and add 2x2 list in
1216        center of it, and let dialog function resize it to needed
1217        size. */
1218     dlg_hist_callback (query_dlg, NULL, DLG_RESIZE, 0, NULL);
1219
1220     if (query_dlg->y < widget->y) {
1221         /* traverse */
1222         hi = z;
1223         while (hi) {
1224             listbox_add_item (query_list, LISTBOX_APPEND_AT_END,
1225                                 0, (char *) hi->data, NULL);
1226             hi = g_list_next (hi);
1227         }
1228         listbox_select_last (query_list);
1229     } else {
1230         /* traverse backwards */
1231         hi = g_list_last (history);
1232         while (hi) {
1233             listbox_add_item (query_list, LISTBOX_APPEND_AT_END,
1234                                 0, (char *) hi->data, NULL);
1235             hi = g_list_previous (hi);
1236         }
1237     }
1238
1239     if (run_dlg (query_dlg) != B_CANCEL) {
1240         listbox_get_current (query_list, &q, NULL);
1241         if (q != NULL)
1242             r = g_strdup (q);
1243     }
1244     destroy_dlg (query_dlg);
1245     return r;
1246 }
1247
1248 static void
1249 do_show_hist (WInput *in)
1250 {
1251     char *r;
1252     r = show_hist (in->history, &in->widget);
1253     if (r) {
1254         assign_text (in, r);
1255         g_free (r);
1256     }
1257 }
1258
1259 /* }}} history display */
1260
1261 static void
1262 input_destroy (WInput *in)
1263 {
1264     if (!in){
1265         fprintf (stderr, "Internal error: null Input *\n");
1266         exit (1);
1267     }
1268
1269     new_input (in);
1270
1271     if (in->history){
1272         if (!in->is_password)   /* don't save passwords ;-) */
1273             history_put (in->history_name, in->history);
1274
1275         in->history = g_list_first (in->history);
1276         g_list_foreach (in->history, (GFunc) g_free, NULL);
1277         g_list_free (in->history);
1278     }
1279
1280     g_free (in->buffer);
1281     free_completions (in);
1282     g_free (in->history_name);
1283 }
1284
1285 void
1286 input_disable_update (WInput *in)
1287 {
1288     in->disable_update++;
1289 }
1290
1291 void
1292 input_enable_update (WInput *in)
1293 {
1294     in->disable_update--;
1295     update_input (in, 0);
1296 }
1297
1298
1299 static void
1300 push_history (WInput *in, const char *text)
1301 {
1302     /* input widget where urls with passwords are entered without any
1303        vfs prefix */
1304     const char *password_input_fields[] = {
1305         N_(" Link to a remote machine "),
1306         N_(" FTP to machine "),
1307         N_(" SMB link to machine ")
1308     };
1309     const size_t ELEMENTS = (sizeof (password_input_fields) /
1310                                 sizeof (password_input_fields[0]));
1311
1312     char *t;
1313     size_t i;
1314     gboolean empty;
1315
1316     if (text == NULL)
1317         return;
1318
1319 #ifdef ENABLE_NLS
1320     for (i = 0; i < ELEMENTS; i++)
1321         password_input_fields[i] = _(password_input_fields[i]);
1322 #endif
1323
1324     t = g_strstrip (g_strdup (text));
1325     empty = *t == '\0';
1326     g_free (t);
1327     t = g_strdup (empty ? "" : text);
1328
1329     if (in->history_name != NULL) {
1330         const char *p = in->history_name + 3;
1331
1332         for (i = 0; i < ELEMENTS; i++)
1333             if (strcmp (p, password_input_fields[i]) == 0)
1334                 break;
1335
1336         strip_password (t, i >= ELEMENTS);
1337     }
1338
1339     in->history = list_append_unique (in->history, t);
1340     in->need_push = 0;
1341 }
1342
1343 /* Cleans the input line and adds the current text to the history */
1344 void
1345 new_input (WInput *in)
1346 {
1347     push_history (in, in->buffer);
1348     in->need_push = 1;
1349     in->buffer[0] = '\0';
1350     in->point = 0;
1351     in->charpoint = 0;
1352     in->mark = 0;
1353     free_completions (in);
1354     update_input (in, 0);
1355 }
1356
1357 static void
1358 move_buffer_backward (WInput *in, int start, int end)
1359 {
1360     int i, pos, len;
1361     int str_len = str_length (in->buffer);
1362     if (start >= str_len || end > str_len + 1) return;
1363
1364     pos = str_offset_to_pos (in->buffer, start);
1365     len = str_offset_to_pos (in->buffer, end) - pos;
1366
1367     for (i = pos; in->buffer[i + len - 1]; i++)
1368         in->buffer[i] = in->buffer[i + len];
1369 }
1370
1371 static cb_ret_t
1372 insert_char (WInput *in, int c_code)
1373 {
1374     size_t i;
1375     int res;
1376
1377     if (c_code == -1)
1378         return MSG_NOT_HANDLED;
1379
1380     if (in->charpoint >= MB_LEN_MAX)
1381         return MSG_HANDLED;
1382
1383     in->charbuf[in->charpoint] = c_code;
1384     in->charpoint++;
1385
1386     res = str_is_valid_char (in->charbuf, in->charpoint);
1387     if (res < 0) {
1388         if (res != -2)
1389             in->charpoint = 0; /* broken multibyte char, skip */
1390         return MSG_HANDLED;
1391     }
1392
1393     in->need_push = 1;
1394     if (strlen (in->buffer) + 1 + in->charpoint >= in->current_max_size){
1395         /* Expand the buffer */
1396         size_t new_length = in->current_max_size +
1397                 in->field_width + in->charpoint;
1398         char *narea = g_try_renew (char, in->buffer, new_length);
1399         if (narea){
1400             in->buffer = narea;
1401             in->current_max_size = new_length;
1402         }
1403     }
1404
1405     if (strlen (in->buffer) + in->charpoint < in->current_max_size) {
1406         /* bytes from begin */
1407         size_t ins_point = str_offset_to_pos (in->buffer, in->point);
1408         /* move chars */
1409         size_t rest_bytes = strlen (in->buffer + ins_point);
1410
1411         for (i = rest_bytes + 1; i > 0; i--)
1412             in->buffer[ins_point + i + in->charpoint - 1] =
1413                     in->buffer[ins_point + i - 1];
1414
1415         memcpy(in->buffer + ins_point, in->charbuf, in->charpoint);
1416         in->point++;
1417     }
1418
1419     in->charpoint = 0;
1420     return MSG_HANDLED;
1421 }
1422
1423 static void
1424 beginning_of_line (WInput *in)
1425 {
1426     in->point = 0;
1427     in->charpoint = 0;
1428 }
1429
1430 static void
1431 end_of_line (WInput *in)
1432 {
1433     in->point = str_length (in->buffer);
1434     in->charpoint = 0;
1435 }
1436
1437 static void
1438 backward_char (WInput *in)
1439 {
1440     const char *act = in->buffer + str_offset_to_pos (in->buffer, in->point);
1441
1442     if (in->point > 0) {
1443         in->point-= str_cprev_noncomb_char (&act, in->buffer);
1444     }
1445     in->charpoint = 0;
1446 }
1447
1448 static void
1449 forward_char (WInput *in)
1450 {
1451     const char *act = in->buffer + str_offset_to_pos (in->buffer, in->point);
1452     if (act[0] != '\0') {
1453         in->point+= str_cnext_noncomb_char (&act);
1454     }
1455     in->charpoint = 0;
1456 }
1457
1458 static void
1459 forward_word (WInput * in)
1460 {
1461     const char *p = in->buffer + str_offset_to_pos (in->buffer, in->point);
1462
1463     while (p[0] != '\0' && (str_isspace (p) || str_ispunct (p))) {
1464         str_cnext_char (&p);
1465         in->point++;
1466     }
1467     while (p[0] != '\0' && !str_isspace (p) && !str_ispunct (p)) {
1468         str_cnext_char (&p);
1469         in->point++;
1470     }
1471 }
1472
1473 static void
1474 backward_word (WInput *in)
1475 {
1476     const char *p;
1477     const char *p_tmp;
1478
1479     for (
1480         p = in->buffer + str_offset_to_pos (in->buffer, in->point);
1481         (p != in->buffer) && (p[0] == '\0');
1482         str_cprev_char (&p), in->point--
1483     );
1484
1485     while (p != in->buffer) {
1486         p_tmp = p;
1487         str_cprev_char (&p);
1488         if (!str_isspace (p) && !str_ispunct (p)) {
1489             p = p_tmp;
1490             break;
1491         }
1492         in->point--;
1493     }
1494     while (p != in->buffer) {
1495         str_cprev_char (&p);
1496         if (str_isspace (p) || str_ispunct (p))
1497             break;
1498
1499         in->point--;
1500     }
1501 }
1502
1503 static void
1504 key_left (WInput *in)
1505 {
1506     backward_char (in);
1507 }
1508
1509 static void
1510 key_ctrl_left (WInput *in)
1511 {
1512     backward_word (in);
1513 }
1514
1515 static void
1516 key_right (WInput *in)
1517 {
1518     forward_char (in);
1519 }
1520
1521 static void
1522 key_ctrl_right (WInput *in)
1523 {
1524     forward_word (in);
1525 }
1526 static void
1527 backward_delete (WInput *in)
1528 {
1529     const char *act = in->buffer + str_offset_to_pos (in->buffer, in->point);
1530     int start;
1531
1532     if (in->point == 0)
1533         return;
1534
1535     start = in->point - str_cprev_noncomb_char (&act, in->buffer);
1536     move_buffer_backward(in, start, in->point);
1537     in->charpoint = 0;
1538     in->need_push = 1;
1539     in->point = start;
1540 }
1541
1542 static void
1543 delete_char (WInput *in)
1544 {
1545     const char *act = in->buffer + str_offset_to_pos (in->buffer, in->point);
1546     int end = in->point;
1547
1548     end+= str_cnext_noncomb_char (&act);
1549
1550     move_buffer_backward(in, in->point, end);
1551     in->charpoint = 0;
1552     in->need_push = 1;
1553 }
1554
1555 static void
1556 copy_region (WInput *in, int x_first, int x_last)
1557 {
1558     int first = min (x_first, x_last);
1559     int last  = max (x_first, x_last);
1560
1561     if (last == first) {
1562         /* Copy selected files to clipboard */
1563         panel_save_curent_file_to_clip_file ();
1564         return;
1565     }
1566
1567     g_free (kill_buffer);
1568
1569     first = str_offset_to_pos (in->buffer, first);
1570     last = str_offset_to_pos (in->buffer, last);
1571
1572     kill_buffer = g_strndup(in->buffer + first, last - first);
1573     save_text_to_clip_file (kill_buffer);
1574 }
1575
1576 static void
1577 delete_region (WInput *in, int x_first, int x_last)
1578 {
1579     int first = min (x_first, x_last);
1580     int last  = max (x_first, x_last);
1581     size_t len;
1582
1583     in->point = first;
1584     if (in->mark > first)
1585         in->mark  = first;
1586     last = str_offset_to_pos (in->buffer, last);
1587     first = str_offset_to_pos (in->buffer, first);
1588     len = strlen (&in->buffer[last]) + 1;
1589     memmove (&in->buffer[first], &in->buffer[last], len);
1590     in->charpoint = 0;
1591     in->need_push = 1;
1592 }
1593
1594 static void
1595 kill_word (WInput *in)
1596 {
1597     int old_point = in->point;
1598     int new_point;
1599
1600     forward_word (in);
1601     new_point = in->point;
1602     in->point = old_point;
1603
1604     copy_region (in, old_point, new_point);
1605     delete_region (in, old_point, new_point);
1606     in->need_push = 1;
1607     in->charpoint = 0;
1608     in->charpoint = 0;
1609 }
1610
1611 static void
1612 back_kill_word (WInput *in)
1613 {
1614     int old_point = in->point;
1615     int new_point;
1616
1617     backward_word (in);
1618     new_point = in->point;
1619     in->point = old_point;
1620
1621     copy_region (in, old_point, new_point);
1622     delete_region (in, old_point, new_point);
1623     in->need_push = 1;
1624 }
1625
1626 static void
1627 set_mark (WInput *in)
1628 {
1629     in->mark = in->point;
1630 }
1631
1632 static void
1633 kill_save (WInput *in)
1634 {
1635     copy_region (in, in->mark, in->point);
1636 }
1637
1638 static void
1639 kill_region (WInput *in)
1640 {
1641     kill_save (in);
1642     delete_region (in, in->point, in->mark);
1643 }
1644
1645 static void
1646 clear_region (WInput *in)
1647 {
1648     delete_region (in, in->point, in->mark);
1649 }
1650
1651 static void
1652 yank (WInput *in)
1653 {
1654     char *p;
1655
1656     if (!kill_buffer)
1657         return;
1658     in->charpoint = 0;
1659     for (p = kill_buffer; *p; p++)
1660         insert_char (in, *p);
1661     in->charpoint = 0;
1662 }
1663
1664 static void
1665 kill_line (WInput *in)
1666 {
1667     int chp = str_offset_to_pos (in->buffer, in->point);
1668     g_free (kill_buffer);
1669     kill_buffer = g_strdup (&in->buffer[chp]);
1670     in->buffer[chp] = '\0';
1671     in->charpoint = 0;
1672 }
1673
1674 static void
1675 ins_from_clip (WInput *in)
1676 {
1677     char *p = NULL;
1678
1679     if (load_text_from_clip_file (&p)) {
1680         char *pp;
1681
1682         for (pp = p; *pp != '\0'; pp++)
1683             insert_char (in, *pp);
1684
1685         g_free (p);
1686     }
1687 }
1688
1689 void
1690 assign_text (WInput *in, const char *text)
1691 {
1692     free_completions (in);
1693     g_free (in->buffer);
1694     in->buffer = g_strdup (text);       /* was in->buffer->text */
1695     in->current_max_size = strlen (in->buffer) + 1;
1696     in->point = str_length (in->buffer);
1697     in->mark = 0;
1698     in->need_push = 1;
1699     in->charpoint = 0;
1700 }
1701
1702 static void
1703 hist_prev (WInput *in)
1704 {
1705     GList *prev;
1706
1707     if (!in->history)
1708         return;
1709
1710     if (in->need_push)
1711         push_history (in, in->buffer);
1712
1713     prev = g_list_previous (in->history);
1714     if (prev != NULL) {
1715         in->history = prev;
1716         assign_text (in, (char *) prev->data);
1717         in->need_push = 0;
1718     }
1719 }
1720
1721 static void
1722 hist_next (WInput *in)
1723 {
1724     if (in->need_push) {
1725         push_history (in, in->buffer);
1726         assign_text (in, "");
1727         return;
1728     }
1729
1730     if (!in->history)
1731         return;
1732
1733     if (!in->history->next) {
1734         assign_text (in, "");
1735         return;
1736     }
1737
1738     in->history = g_list_next (in->history);
1739     assign_text (in, (char *) in->history->data);
1740     in->need_push = 0;
1741 }
1742
1743 static void
1744 port_region_marked_for_delete (WInput *in)
1745 {
1746     in->buffer[0] = '\0';
1747     in->point = 0;
1748     in->first = 0;
1749     in->charpoint = 0;
1750 }
1751
1752 static cb_ret_t
1753 input_execute_cmd (WInput *in, unsigned long command)
1754 {
1755     cb_ret_t res = MSG_HANDLED;
1756
1757     switch (command) {
1758     case CK_InputBol:
1759         beginning_of_line (in);
1760         break;
1761     case CK_InputEol:
1762         end_of_line (in);
1763         break;
1764     case CK_InputMoveLeft:
1765         key_left (in);
1766         break;
1767     case CK_InputWordLeft:
1768         key_ctrl_left (in);
1769         break;
1770     case CK_InputMoveRight:
1771         key_right (in);
1772         break;
1773     case CK_InputWordRight:
1774         key_ctrl_right (in);
1775         break;
1776     case CK_InputBackwardChar:
1777         backward_char (in);
1778         break;
1779     case CK_InputBackwardWord:
1780         backward_word (in);
1781         break;
1782     case CK_InputForwardChar:
1783         forward_char (in);
1784         break;
1785     case CK_InputForwardWord:
1786         forward_word (in);
1787         break;
1788     case CK_InputBackwardDelete:
1789         backward_delete (in);
1790         break;
1791     case CK_InputDeleteChar:
1792         delete_char (in);
1793         break;
1794     case CK_InputKillWord:
1795         kill_word (in);
1796         break;
1797     case CK_InputBackwardKillWord:
1798         back_kill_word (in);
1799         break;
1800     case CK_InputSetMark:
1801         set_mark (in);
1802         break;
1803     case CK_InputKillRegion:
1804         kill_region (in);
1805         break;
1806     case CK_InputClearLine:
1807         clear_region (in);
1808         break;
1809     case CK_InputKillSave:
1810         kill_save (in);
1811         break;
1812     case CK_InputYank:
1813         yank (in);
1814         break;
1815     case CK_InputPaste:
1816         ins_from_clip (in);
1817         break;
1818     case CK_InputKillLine:
1819         kill_line (in);
1820         break;
1821     case CK_InputHistoryPrev:
1822         hist_prev (in);
1823         break;
1824     case CK_InputHistoryNext:
1825         hist_next (in);
1826         break;
1827     case CK_InputHistoryShow:
1828         do_show_hist (in);
1829         break;
1830     case CK_InputComplete:
1831         complete (in);
1832         break;
1833     default:
1834         res = MSG_NOT_HANDLED;
1835     }
1836
1837     return res;
1838 }
1839
1840 /* This function is a test for a special input key used in complete.c */
1841 /* Returns 0 if it is not a special key, 1 if it is a non-complete key
1842    and 2 if it is a complete key */
1843 int
1844 is_in_input_map (WInput *in, int key)
1845 {
1846     size_t i;
1847     for (i = 0; input_map[i].key != 0; i++)
1848         if (key == input_map[i].key) {
1849             input_execute_cmd (in, input_map[i].command);
1850             return (input_map[i].command == CK_InputComplete) ? 2 : 1;
1851         }
1852     return 0;
1853 }
1854
1855 cb_ret_t
1856 handle_char (WInput *in, int key)
1857 {
1858     cb_ret_t v;
1859     int    i;
1860
1861     v = MSG_NOT_HANDLED;
1862
1863     if (quote) {
1864         free_completions (in);
1865         v = insert_char (in, key);
1866         update_input (in, 1);
1867         quote = 0;
1868         return v;
1869     }
1870     for (i = 0; input_map[i].key; i++) {
1871         if (key == input_map[i].key) {
1872             if (input_map[i].command != CK_InputComplete)
1873                 free_completions (in);
1874             input_execute_cmd (in, input_map[i].command);
1875             update_input (in, 1);
1876             v = MSG_HANDLED;
1877             break;
1878         }
1879     }
1880     if (input_map[i].command == 0) {
1881         if (key > 255)
1882             return MSG_NOT_HANDLED;
1883         if (in->first)
1884             port_region_marked_for_delete (in);
1885         free_completions (in);
1886         v = insert_char (in, key);
1887     }
1888     update_input (in, 1);
1889     return v;
1890 }
1891
1892 /* Inserts text in input line */
1893 void
1894 stuff (WInput *in, const char *text, int insert_extra_space)
1895 {
1896     input_disable_update (in);
1897     while (*text != '\0')
1898         handle_char (in, (unsigned char) *text++); /* unsigned extension char->int */
1899     if (insert_extra_space)
1900         handle_char (in, ' ');
1901     input_enable_update (in);
1902     update_input (in, 1);
1903 }
1904
1905 void
1906 input_set_point (WInput *in, int pos)
1907 {
1908     int max_pos = str_length (in->buffer);
1909
1910     if (pos > max_pos)
1911         pos = max_pos;
1912     if (pos != in->point)
1913         free_completions (in);
1914     in->point = pos;
1915     in->charpoint = 0;
1916     update_input (in, 1);
1917 }
1918
1919 cb_ret_t
1920 input_callback (Widget *w, widget_msg_t msg, int parm)
1921 {
1922     WInput *in = (WInput *) w;
1923     cb_ret_t v;
1924
1925     switch (msg) {
1926     case WIDGET_KEY:
1927         if (parm == XCTRL ('q')) {
1928             quote = 1;
1929             v = handle_char (in, ascii_alpha_to_cntrl (tty_getch ()));
1930             quote = 0;
1931             return v;
1932         }
1933
1934         /* Keys we want others to handle */
1935         if (parm == KEY_UP || parm == KEY_DOWN || parm == ESC_CHAR
1936             || parm == KEY_F (10) || parm == '\n')
1937             return MSG_NOT_HANDLED;
1938
1939         /* When pasting multiline text, insert literal Enter */
1940         if ((parm & ~KEY_M_MASK) == '\n') {
1941             quote = 1;
1942             v = handle_char (in, '\n');
1943             quote = 0;
1944             return v;
1945         }
1946
1947         return handle_char (in, parm);
1948
1949     case WIDGET_COMMAND:
1950         return input_execute_cmd (in, parm);
1951
1952     case WIDGET_FOCUS:
1953     case WIDGET_UNFOCUS:
1954     case WIDGET_DRAW:
1955         update_input (in, 0);
1956         return MSG_HANDLED;
1957
1958     case WIDGET_CURSOR:
1959             widget_move (&in->widget, 0, str_term_width2 (in->buffer, in->point)
1960                     - in->term_first_shown);
1961         return MSG_HANDLED;
1962
1963     case WIDGET_DESTROY:
1964         input_destroy (in);
1965         return MSG_HANDLED;
1966
1967     default:
1968         return default_proc (msg, parm);
1969     }
1970 }
1971
1972 static int
1973 input_event (Gpm_Event * event, void *data)
1974 {
1975     WInput *in = data;
1976
1977     if (event->type & (GPM_DOWN | GPM_DRAG)) {
1978         dlg_select_widget (in);
1979
1980         if (event->x >= in->field_width - HISTORY_BUTTON_WIDTH + 1
1981             && should_show_history_button (in)) {
1982             do_show_hist (in);
1983         } else {
1984             in->point = str_length (in->buffer);
1985             if (event->x + in->term_first_shown - 1 <
1986                 str_term_width1 (in->buffer))
1987
1988                 in->point = str_column_to_pos (in->buffer, event->x
1989                            + in->term_first_shown - 1);
1990
1991         }
1992         update_input (in, 1);
1993     }
1994     return MOU_NORMAL;
1995 }
1996
1997 WInput *
1998 input_new (int y, int x, int color, int width, const char *def_text,
1999            const char *histname, INPUT_COMPLETE_FLAGS completion_flags)
2000 {
2001     WInput *in = g_new (WInput, 1);
2002     int initial_buffer_len;
2003
2004     init_widget (&in->widget, y, x, 1, width, input_callback, input_event);
2005
2006     /* history setup */
2007     in->history = NULL;
2008     in->history_name = 0;
2009     if (histname) {
2010         if (*histname) {
2011             in->history_name = g_strdup (histname);
2012             in->history = history_get (histname);
2013         }
2014     }
2015
2016     if (def_text == NULL)
2017         def_text = "";
2018
2019     if (def_text == INPUT_LAST_TEXT) {
2020         def_text = "";
2021         if (in->history)
2022             if (in->history->data)
2023                 def_text = (char *) in->history->data;
2024     }
2025     initial_buffer_len = 1 + max ((size_t) width, strlen (def_text));
2026     in->widget.options |= W_IS_INPUT;
2027     in->completions = NULL;
2028     in->completion_flags = completion_flags;
2029     in->current_max_size = initial_buffer_len;
2030     in->buffer = g_new (char, initial_buffer_len);
2031     in->color = color;
2032     in->field_width = width;
2033     in->first = 1;
2034     in->term_first_shown = 0;
2035     in->disable_update = 0;
2036     in->mark = 0;
2037     in->need_push = 1;
2038     in->is_password = 0;
2039
2040     strcpy (in->buffer, def_text);
2041     in->point = str_length (in->buffer);
2042     in->charpoint = 0;
2043     return in;
2044 }
2045
2046 /* Listbox widget */
2047
2048 /* Should draw the scrollbar, but currently draws only
2049  * indications that there is more information
2050  */
2051 static int listbox_cdiff (WLEntry *s, WLEntry *e);
2052
2053 static void
2054 listbox_drawscroll (WListbox *l)
2055 {
2056     int line = 0;
2057     int i, top;
2058     int max_line = l->widget.lines - 1;
2059
2060     /* Are we at the top? */
2061     widget_move (&l->widget, 0, l->widget.cols);
2062     if (l->list == l->top)
2063         tty_print_one_vline ();
2064     else
2065         tty_print_char ('^');
2066
2067     /* Are we at the bottom? */
2068     widget_move (&l->widget, max_line, l->widget.cols);
2069     top = listbox_cdiff (l->list, l->top);
2070     if ((top + l->widget.lines == l->count) || l->widget.lines >= l->count)
2071         tty_print_one_vline ();
2072     else
2073         tty_print_char ('v');
2074
2075     /* Now draw the nice relative pointer */
2076     if (l->count != 0)
2077         line = 1+ ((l->pos * (l->widget.lines - 2)) / l->count);
2078
2079     for (i = 1; i < max_line; i++){
2080         widget_move (&l->widget, i, l->widget.cols);
2081         if (i != line)
2082             tty_print_one_vline ();
2083         else
2084             tty_print_char ('*');
2085     }
2086 }
2087
2088 static void
2089 listbox_draw (WListbox *l, gboolean focused)
2090 {
2091     const Dlg_head *h = l->widget.parent;
2092     const int normalc = DLG_NORMALC (h);
2093     int selc = focused ? DLG_HOT_FOCUSC (h) : DLG_FOCUSC (h);
2094
2095     WLEntry *e;
2096     int i;
2097     int sel_line = -1;
2098     const char *text;
2099
2100     for (e = l->top, i = 0; i < l->widget.lines; i++) {
2101         /* Display the entry */
2102         if (e == l->current && sel_line == -1) {
2103             sel_line = i;
2104             tty_setcolor (selc);
2105         } else
2106             tty_setcolor (normalc);
2107
2108         widget_move (&l->widget, i, 1);
2109
2110         if ((i > 0 && e == l->list) || !l->list)
2111             text = "";
2112         else {
2113             text = e->text;
2114             e = e->next;
2115         }
2116         tty_print_string (str_fit_to_term (text, l->widget.cols - 2, J_LEFT_FIT));
2117     }
2118     l->cursor_y = sel_line;
2119
2120     if (l->scrollbar && l->count > l->widget.lines) {
2121         tty_setcolor (normalc);
2122         listbox_drawscroll (l);
2123     }
2124 }
2125
2126 /* Returns the number of items between s and e,
2127    must be on the same linked list */
2128 static int
2129 listbox_cdiff (WLEntry *s, WLEntry *e)
2130 {
2131     int count;
2132
2133     for (count = 0; s != e; count++)
2134         s = s->next;
2135     return count;
2136 }
2137
2138 static WLEntry *
2139 listbox_check_hotkey (WListbox *l, int key)
2140 {
2141     int i;
2142     WLEntry *e;
2143
2144     i = 0;
2145     e = l->list;
2146     if (!e)
2147         return NULL;
2148
2149     while (1) {
2150
2151         /* If we didn't find anything, return */
2152         if (i && e == l->list)
2153             return NULL;
2154
2155         if (e->hotkey == key)
2156             return e;
2157
2158         i++;
2159         e = e->next;
2160     }
2161 }
2162
2163 /* Selects the last entry and scrolls the list to the bottom */
2164 void
2165 listbox_select_last (WListbox *l)
2166 {
2167     unsigned int i;
2168     l->current = l->top = l->list->prev;
2169     for (i = min (l->widget.lines, l->count) - 1; i; i--)
2170         l->top = l->top->prev;
2171     l->pos = l->count - 1;
2172 }
2173
2174 /* Selects the first entry and scrolls the list to the top */
2175 void
2176 listbox_select_first (WListbox *l)
2177 {
2178     l->current = l->top = l->list;
2179     l->pos = 0;
2180 }
2181
2182 void
2183 listbox_remove_list (WListbox *l)
2184 {
2185     WLEntry *p, *q;
2186
2187     if (!l->count)
2188         return;
2189
2190     p = l->list;
2191
2192     while (l->count--) {
2193         q = p->next;
2194         g_free (p->text);
2195         g_free (p);
2196         p = q;
2197     }
2198     l->pos = l->count = 0;
2199     l->list = l->top = l->current = 0;
2200 }
2201
2202 /*
2203  * bor 30.10.96: added force flag to remove *last* entry as well
2204  * bor 30.10.96: corrected selection bug if last entry was removed
2205  */
2206
2207 void
2208 listbox_remove_current (WListbox *l, int force)
2209 {
2210     WLEntry *p;
2211
2212     /* Ok, note: this won't allow for emtpy lists */
2213     if (!force && (!l->count || l->count == 1))
2214         return;
2215
2216     l->count--;
2217     p = l->current;
2218
2219     if (l->count) {
2220         l->current->next->prev = l->current->prev;
2221         l->current->prev->next = l->current->next;
2222         if (p->next == l->list) {
2223             l->current = p->prev;
2224             l->pos--;
2225         }
2226         else
2227             l->current = p->next;
2228
2229         if (p == l->list)
2230             l->list = l->top = p->next;
2231     } else {
2232         l->pos = 0;
2233         l->list = l->top = l->current = 0;
2234     }
2235
2236     g_free (p->text);
2237     g_free (p);
2238 }
2239
2240 /* Makes *e the selected entry (sets current and pos) */
2241 void
2242 listbox_select_entry (WListbox *l, WLEntry *dest)
2243 {
2244     WLEntry *e;
2245     int pos;
2246     int top_seen;
2247
2248     top_seen = 0;
2249
2250     /* Special case */
2251     for (pos = 0, e = l->list; pos < l->count; e = e->next, pos++){
2252
2253         if (e == l->top)
2254             top_seen = 1;
2255
2256         if (e == dest){
2257             l->current = e;
2258             if (top_seen){
2259                 while (listbox_cdiff (l->top, l->current) >= l->widget.lines)
2260                     l->top = l->top->next;
2261             } else {
2262                 l->top = l->current;
2263             }
2264             l->pos = pos;
2265             return;
2266         }
2267     }
2268     /* If we are unable to find it, set decent values */
2269     l->current = l->top = l->list;
2270     l->pos = 0;
2271 }
2272
2273 /* Selects from base the pos element */
2274 static WLEntry *
2275 listbox_select_pos (WListbox *l, WLEntry *base, int pos)
2276 {
2277     WLEntry *last = l->list->prev;
2278
2279     if (base == last)
2280         return last;
2281     while (pos--){
2282         base = base->next;
2283         if (base == last)
2284             break;
2285     }
2286     return base;
2287 }
2288
2289 static void
2290 listbox_back (WListbox *l)
2291 {
2292     if (l->pos != 0)
2293         listbox_select_entry (l, l->current->prev);
2294     else
2295         listbox_select_last (l);
2296 }
2297
2298 /* Return MSG_HANDLED if we want a redraw */
2299 static cb_ret_t
2300 listbox_key (WListbox *l, int key)
2301 {
2302     int i;
2303
2304     cb_ret_t j = MSG_NOT_HANDLED;
2305
2306     /* focus on listbox item N by '0'..'9' keys */
2307     if (key >= '0' && key <= '9') {
2308         int oldpos = l->pos;
2309         listbox_select_by_number(l, key - '0');
2310
2311         /* need scroll to item? */
2312         if (abs(oldpos - l->pos) > l->widget.lines)
2313             l->top = l->current;
2314
2315         return MSG_HANDLED;
2316     }
2317
2318     if (!l->list)
2319         return MSG_NOT_HANDLED;
2320
2321     switch (key){
2322     case KEY_HOME:
2323     case KEY_A1:
2324     case ALT ('<'):
2325         listbox_select_first (l);
2326         return MSG_HANDLED;
2327
2328     case KEY_END:
2329     case KEY_C1:
2330     case ALT ('>'):
2331         listbox_select_last (l);
2332         return MSG_HANDLED;
2333
2334     case XCTRL('p'):
2335     case KEY_UP:
2336         listbox_back (l);
2337         return MSG_HANDLED;
2338
2339     case XCTRL('n'):
2340     case KEY_DOWN:
2341         listbox_fwd (l);
2342         return MSG_HANDLED;
2343
2344     case KEY_NPAGE:
2345     case XCTRL('v'):
2346         for (i = 0; ((i < l->widget.lines - 1)
2347                     && (l->current != l->list->prev)); i++) {
2348             listbox_fwd (l);
2349             j = MSG_HANDLED;
2350         }
2351         return j;
2352
2353     case KEY_PPAGE:
2354     case ALT('v'):
2355         for (i = 0; ((i < l->widget.lines - 1)
2356                     && (l->current != l->list)); i++) {
2357             listbox_back (l);
2358             j = MSG_HANDLED;
2359         }
2360         return j;
2361     }
2362     return MSG_NOT_HANDLED;
2363 }
2364
2365 static void
2366 listbox_destroy (WListbox *l)
2367 {
2368     WLEntry *n, *p = l->list;
2369     int i;
2370
2371     for (i = 0; i < l->count; i++){
2372         n = p->next;
2373         g_free (p->text);
2374         g_free (p);
2375         p = n;
2376     }
2377 }
2378
2379 static cb_ret_t
2380 listbox_callback (Widget *w, widget_msg_t msg, int parm)
2381 {
2382     WListbox *l = (WListbox *) w;
2383     Dlg_head *h = l->widget.parent;
2384     WLEntry *e;
2385     cb_ret_t ret_code;
2386
2387     switch (msg) {
2388     case WIDGET_INIT:
2389         return MSG_HANDLED;
2390
2391     case WIDGET_HOTKEY:
2392         e = listbox_check_hotkey (l, parm);
2393         if (e != NULL) {
2394             int action;
2395
2396             listbox_select_entry (l, e);
2397             h->callback (h, w, DLG_ACTION, l->pos, NULL);
2398
2399             if (l->cback)
2400                 action = (*l->cback) (l);
2401             else
2402                 action = LISTBOX_DONE;
2403
2404             if (action == LISTBOX_DONE) {
2405                 h->ret_value = B_ENTER;
2406                 dlg_stop (h);
2407             }
2408             return MSG_HANDLED;
2409         }
2410         return MSG_NOT_HANDLED;
2411
2412     case WIDGET_KEY:
2413         ret_code = listbox_key (l, parm);
2414         if (ret_code != MSG_NOT_HANDLED) {
2415             listbox_draw (l, TRUE);
2416             h->callback (h, w, DLG_ACTION, l->pos, NULL);
2417         }
2418         return ret_code;
2419
2420     case WIDGET_CURSOR:
2421         widget_move (&l->widget, l->cursor_y, 0);
2422         h->callback (h, w, DLG_ACTION, l->pos, NULL);
2423         return MSG_HANDLED;
2424
2425     case WIDGET_FOCUS:
2426     case WIDGET_UNFOCUS:
2427     case WIDGET_DRAW:
2428         listbox_draw (l, msg != WIDGET_UNFOCUS);
2429         return MSG_HANDLED;
2430
2431     case WIDGET_DESTROY:
2432         listbox_destroy (l);
2433         return MSG_HANDLED;
2434
2435     case WIDGET_RESIZED:
2436         return MSG_HANDLED;
2437
2438     default:
2439         return default_proc (msg, parm);
2440     }
2441 }
2442
2443 static int
2444 listbox_event (Gpm_Event *event, void *data)
2445 {
2446     WListbox *l = data;
2447     int i;
2448
2449     Dlg_head *h = l->widget.parent;
2450
2451     /* Single click */
2452     if (event->type & GPM_DOWN)
2453         dlg_select_widget (l);
2454
2455     if (l->list == NULL)
2456         return MOU_NORMAL;
2457
2458     if (event->type & (GPM_DOWN | GPM_DRAG)) {
2459         int ret = MOU_REPEAT;
2460
2461         if (event->x < 0 || event->x > l->widget.cols)
2462             return ret;
2463
2464         if (event->y < 1)
2465             for (i = -event->y; i >= 0; i--)
2466                 listbox_back (l);
2467         else if (event->y > l->widget.lines)
2468             for (i = event->y - l->widget.lines; i > 0; i--)
2469                 listbox_fwd (l);
2470         else if (event->buttons & GPM_B_UP) {
2471                 listbox_back (l);
2472                 ret = MOU_NORMAL;
2473         } else if (event->buttons & GPM_B_DOWN) {
2474                 listbox_fwd (l);
2475                 ret = MOU_NORMAL;
2476         } else
2477             listbox_select_entry (l,
2478                                   listbox_select_pos (l, l->top,
2479                                                       event->y - 1));
2480
2481         /* We need to refresh ourselves since the dialog manager doesn't */
2482         /* know about this event */
2483         listbox_draw (l, TRUE);
2484         return ret;
2485     }
2486
2487     /* Double click */
2488     if ((event->type & (GPM_DOUBLE | GPM_UP)) == (GPM_UP | GPM_DOUBLE)) {
2489         int action;
2490
2491         if (event->x < 0 || event->x >= l->widget.cols
2492             || event->y < 1 || event->y > l->widget.lines)
2493             return MOU_NORMAL;
2494
2495         dlg_select_widget (l);
2496         listbox_select_entry (l,
2497                               listbox_select_pos (l, l->top,
2498                                                   event->y - 1));
2499
2500         if (l->cback)
2501             action = (*l->cback) (l);
2502         else
2503             action = LISTBOX_DONE;
2504
2505         if (action == LISTBOX_DONE) {
2506             h->ret_value = B_ENTER;
2507             dlg_stop (h);
2508             return MOU_NORMAL;
2509         }
2510     }
2511     return MOU_NORMAL;
2512 }
2513
2514 WListbox *
2515 listbox_new (int y, int x, int height, int width, lcback callback)
2516 {
2517     WListbox *l = g_new (WListbox, 1);
2518
2519     if (height <= 0)
2520         height = 1;
2521
2522     init_widget (&l->widget, y, x, height, width,
2523                  listbox_callback, listbox_event);
2524
2525     l->list = l->top = l->current = 0;
2526     l->pos = 0;
2527     l->count = 0;
2528     l->cback = callback;
2529     l->allow_duplicates = 1;
2530     l->scrollbar = !tty_is_slow ();
2531     widget_want_hotkey (l->widget, 1);
2532
2533     return l;
2534 }
2535
2536 /* Listbox item adding function.  They still lack a lot of functionality */
2537 /* any takers? */
2538 /* 1.11.96 bor: added pos argument to control placement of new entry */
2539 static void
2540 listbox_append_item (WListbox *l, WLEntry *e, enum append_pos pos)
2541 {
2542     if (!l->list){
2543         l->list = e;
2544         l->top = e;
2545         l->current = e;
2546         e->next = l->list;
2547         e->prev = l->list;
2548     } else if (pos == LISTBOX_APPEND_AT_END) {
2549         e->next = l->list;
2550         e->prev = l->list->prev;
2551         l->list->prev->next = e;
2552         l->list->prev = e;
2553     } else if (pos == LISTBOX_APPEND_BEFORE){
2554         e->next = l->current;
2555         e->prev = l->current->prev;
2556         l->current->prev->next = e;
2557         l->current->prev = e;
2558         if (l->list == l->current) {    /* move list one position down */
2559             l->list = e;
2560             l->top =  e;
2561         }
2562     } else if (pos == LISTBOX_APPEND_AFTER) {
2563         e->prev = l->current;
2564         e->next = l->current->next;
2565         l->current->next->prev = e;
2566         l->current->next = e;
2567     } else if (pos == LISTBOX_APPEND_SORTED) {
2568         WLEntry *w = l->list;
2569
2570         while (w->next != l->list && strcmp (e->text, w->text) > 0)
2571             w = w->next;
2572         if (w->next == l->list) {
2573             e->prev = w;
2574             e->next = l->list;
2575             w->next = e;
2576             l->list->prev = e;
2577         } else {
2578             e->next = w;
2579             e->prev = w->prev;
2580             w->prev->next = e;
2581             w->prev = e;
2582         }
2583     }
2584     l->count++;
2585 }
2586
2587 char *
2588 listbox_add_item (WListbox *l, enum append_pos pos, int hotkey,
2589                   const char *text, void *data)
2590 {
2591     WLEntry *entry;
2592
2593     if (!l)
2594         return NULL;
2595
2596     if (!l->allow_duplicates)
2597         if (listbox_search_text (l, text))
2598             return NULL;
2599
2600     entry = g_new (WLEntry, 1);
2601     entry->text = g_strdup (text);
2602     entry->data = data;
2603     entry->hotkey = hotkey;
2604
2605     listbox_append_item (l, entry, pos);
2606
2607     return entry->text;
2608 }
2609
2610 /* Selects the nth entry in the listbox */
2611 void
2612 listbox_select_by_number (WListbox *l, int n)
2613 {
2614     if (l->list != NULL)
2615         listbox_select_entry (l, listbox_select_pos (l, l->list, n));
2616 }
2617
2618 WLEntry *
2619 listbox_search_text (WListbox *l, const char *text)
2620 {
2621     WLEntry *e;
2622
2623     e = l->list;
2624     if (!e)
2625         return NULL;
2626
2627     do {
2628         if(!strcmp (e->text, text))
2629             return e;
2630         e = e->next;
2631     } while (e!=l->list);
2632
2633     return NULL;
2634 }
2635
2636 /* Returns the current string text as well as the associated extra data */
2637 void
2638 listbox_get_current (WListbox *l, char **string, char **extra)
2639 {
2640     if (!l->current){
2641         *string = 0;
2642         *extra  = 0;
2643     }
2644     if (string && l->current)
2645         *string = l->current->text;
2646     if (extra && l->current)
2647         *extra = l->current->data;
2648 }
2649
2650 /* returns TRUE if a function has been called, FALSE otherwise. */
2651 static gboolean
2652 buttonbar_call (WButtonBar *bb, int i)
2653 {
2654     cb_ret_t ret = MSG_NOT_HANDLED;
2655
2656     if (bb != NULL)
2657         ret = bb->widget.parent->callback (bb->widget.parent,
2658                                             (Widget *) bb, DLG_ACTION,
2659                                             bb->labels[i].command,
2660                                             bb->labels[i].receiver);
2661     return ret;
2662 }
2663
2664 /* calculate width of one button, width is never lesser than 7 */
2665 static int
2666 buttonbat_get_button_width (void)
2667 {
2668     int result = COLS / BUTTONBAR_LABELS_NUM;
2669     return (result >= 7) ? result : 7;
2670 }
2671
2672 static cb_ret_t
2673 buttonbar_callback (Widget *w, widget_msg_t msg, int parm)
2674 {
2675     WButtonBar *bb = (WButtonBar *) w;
2676     int i;
2677     const char *text;
2678
2679     switch (msg) {
2680     case WIDGET_FOCUS:
2681         return MSG_NOT_HANDLED;
2682
2683     case WIDGET_HOTKEY:
2684         for (i = 0; i < BUTTONBAR_LABELS_NUM; i++)
2685             if (parm == KEY_F (i + 1) && buttonbar_call (bb, i))
2686                 return MSG_HANDLED;
2687         return MSG_NOT_HANDLED;
2688
2689     case WIDGET_DRAW:
2690         if (bb->visible) {
2691             int offset = 0;
2692             int count_free_positions;
2693
2694             widget_move (&bb->widget, 0, 0);
2695             tty_setcolor (DEFAULT_COLOR);
2696             bb->btn_width = buttonbat_get_button_width ();
2697             tty_printf ("%-*s", bb->widget.cols, "");
2698             count_free_positions = COLS - bb->btn_width * BUTTONBAR_LABELS_NUM;
2699
2700             for (i = 0; i < COLS / bb->btn_width && i < BUTTONBAR_LABELS_NUM; i++) {
2701                 widget_move (&bb->widget, 0, (i * bb->btn_width) + offset);
2702                 tty_setcolor (BUTTONBAR_HOTKEY_COLOR);
2703                 tty_printf ("%2d", i + 1);
2704                 tty_setcolor (BUTTONBAR_BUTTON_COLOR);
2705                 text = (bb->labels[i].text != NULL) ? bb->labels[i].text : "";
2706                 tty_print_string (str_fit_to_term (
2707                         text,
2708                         bb->btn_width - 2 + (int)(offset < count_free_positions),
2709                         J_LEFT_FIT));
2710
2711                 if (count_free_positions != 0 && offset < count_free_positions)
2712                     offset++;
2713             }
2714         }
2715         return MSG_HANDLED;
2716
2717     case WIDGET_DESTROY:
2718         for (i = 0; i < BUTTONBAR_LABELS_NUM; i++)
2719             g_free (bb->labels[i].text);
2720         return MSG_HANDLED;
2721
2722     default:
2723         return default_proc (msg, parm);
2724     }
2725 }
2726
2727 static int
2728 buttonbar_event (Gpm_Event *event, void *data)
2729 {
2730     WButtonBar *bb = data;
2731     int button;
2732
2733     if (!(event->type & GPM_UP))
2734         return MOU_NORMAL;
2735     if (event->y == 2)
2736         return MOU_NORMAL;
2737     button = (event->x - 1) * BUTTONBAR_LABELS_NUM / COLS;
2738     if (button < BUTTONBAR_LABELS_NUM)
2739         buttonbar_call (bb, button);
2740     return MOU_NORMAL;
2741 }
2742
2743 WButtonBar *
2744 buttonbar_new (gboolean visible)
2745 {
2746     WButtonBar *bb;
2747
2748     bb = g_new0 (WButtonBar, 1);
2749
2750     init_widget (&bb->widget, LINES - 1, 0, 1, COLS,
2751                  buttonbar_callback, buttonbar_event);
2752     bb->widget.pos_flags = WPOS_KEEP_HORZ | WPOS_KEEP_BOTTOM;
2753     bb->visible = visible;
2754     widget_want_hotkey (bb->widget, 1);
2755     widget_want_cursor (bb->widget, 0);
2756     bb->btn_width = buttonbat_get_button_width ();
2757
2758     return bb;
2759 }
2760
2761 static void
2762 set_label_text (WButtonBar *bb, int lc_index, const char *text)
2763 {
2764     g_free (bb->labels[lc_index - 1].text);
2765     bb->labels[lc_index - 1].text = g_strdup (text);
2766 }
2767
2768 /* Find ButtonBar widget in the dialog */
2769 WButtonBar *
2770 find_buttonbar (const Dlg_head *h)
2771 {
2772     return (WButtonBar *) find_widget_type (h, buttonbar_callback);
2773 }
2774
2775 void
2776 buttonbar_set_label (WButtonBar *bb, int idx, const char *text,
2777                         const struct global_keymap_t *keymap, const Widget *receiver)
2778 {
2779     if ((bb != NULL)  && (idx >= 1) && (idx <= BUTTONBAR_LABELS_NUM)) {
2780         unsigned long command = CK_Ignore_Key;
2781
2782         if (keymap != NULL)
2783             command = lookup_keymap_command (keymap, KEY_F (idx));
2784
2785         if ((text == NULL) || (text[0] == '\0'))
2786             set_label_text (bb, idx, "");
2787         else
2788             set_label_text (bb, idx, text);
2789
2790         bb->labels[idx - 1].command = command;
2791         bb->labels[idx - 1].receiver = (Widget *) receiver;
2792     }
2793 }
2794
2795 void
2796 buttonbar_set_visible (WButtonBar *bb, gboolean visible)
2797 {
2798     bb->visible = visible;
2799 }
2800
2801 void
2802 buttonbar_redraw (WButtonBar *bb)
2803 {
2804     if (bb != NULL)
2805         send_message ((Widget *) bb, WIDGET_DRAW, 0);
2806 }
2807
2808 static cb_ret_t
2809 groupbox_callback (Widget *w, widget_msg_t msg, int parm)
2810 {
2811     WGroupbox *g = (WGroupbox *) w;
2812
2813     switch (msg) {
2814     case WIDGET_INIT:
2815         return MSG_HANDLED;
2816
2817     case WIDGET_FOCUS:
2818         return MSG_NOT_HANDLED;
2819
2820     case WIDGET_DRAW:
2821         tty_setcolor (COLOR_NORMAL);
2822         draw_box (g->widget.parent, g->widget.y - g->widget.parent->y,
2823                   g->widget.x - g->widget.parent->x, g->widget.lines,
2824                   g->widget.cols);
2825
2826         tty_setcolor (COLOR_HOT_NORMAL);
2827         dlg_move (g->widget.parent, g->widget.y - g->widget.parent->y,
2828                   g->widget.x - g->widget.parent->x + 1);
2829         tty_print_string (g->title);
2830         return MSG_HANDLED;
2831
2832     case WIDGET_DESTROY:
2833         g_free (g->title);
2834         return MSG_HANDLED;
2835
2836     default:
2837         return default_proc (msg, parm);
2838     }
2839 }
2840
2841 WGroupbox *
2842 groupbox_new (int y, int x, int height, int width, const char *title)
2843 {
2844     WGroupbox *g = g_new (WGroupbox, 1);
2845
2846     init_widget (&g->widget, y, x, height, width, groupbox_callback, NULL);
2847
2848     g->widget.options &= ~W_WANT_CURSOR;
2849     widget_want_hotkey (g->widget, 0);
2850
2851     /* Strip existing spaces, add one space before and after the title */
2852     if (title) {
2853         char *t;
2854         t = g_strstrip (g_strdup (title));
2855         g->title = g_strconcat (" ", t, " ", (char *) NULL);
2856         g_free (t);
2857     }
2858
2859     return g;
2860 }