lib/widget/listbox.c

   1 /*
   2    Widgets for the Midnight Commander
   3
   4    Copyright (C) 1994-2016
   5    Free Software Foundation, Inc.
   6
   7    Authors:
   8    Radek Doulik, 1994, 1995
   9    Miguel de Icaza, 1994, 1995
  10    Jakub Jelinek, 1995
  11    Andrej Borsenkow, 1996
  12    Norbert Warmuth, 1997
  13    Andrew Borodin <aborodin@vmail.ru>, 2009, 2010, 2013, 2016
  14
  15    This file is part of the Midnight Commander.
  16
  17    The Midnight Commander is free software: you can redistribute it
  18    and/or modify it under the terms of the GNU General Public License as
  19    published by the Free Software Foundation, either version 3 of the License,
  20    or (at your option) any later version.
  21
  22    The Midnight Commander is distributed in the hope that it will be useful,
  23    but WITHOUT ANY WARRANTY; without even the implied warranty of
  24    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25    GNU General Public License for more details.
  26
  27    You should have received a copy of the GNU General Public License
  28    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  29  */
  30
  31 /** \file listbox.c
  32  *  \brief Source: WListbox widget
  33  */
  34
  35 #include <config.h>
  36
  37 #include <stdlib.h>
  38
  39 #include "lib/global.h"
  40
  41 #include "lib/tty/tty.h"
  42 #include "lib/skin.h"
  43 #include "lib/strutil.h"
  44 #include "lib/util.h"           /* Q_() */
  45 #include "lib/keybind.h"        /* global_keymap_t */
  46 #include "lib/widget.h"
  47
  48 /*** global variables ****************************************************************************/
  49
  50 const global_keymap_t *listbox_map = NULL;
  51
  52 /*** file scope macro definitions ****************************************************************/
  53
  54 /* Gives the position of the last item. */
  55 #define LISTBOX_LAST(l) (g_queue_is_empty ((l)->list) ? 0 : (int) g_queue_get_length ((l)->list) - 1)
  56
  57 /*** file scope type declarations ****************************************************************/
  58
  59 /*** file scope variables ************************************************************************/
  60
  61 /*** file scope functions ************************************************************************/
  62
  63 static int
  64 listbox_entry_cmp (const void *a, const void *b, void *user_data)
  65 {
  66     const WLEntry *ea = (const WLEntry *) a;
  67     const WLEntry *eb = (const WLEntry *) b;
  68
  69     (void) user_data;
  70
  71     return strcmp (ea->text, eb->text);
  72 }
  73
  74 /* --------------------------------------------------------------------------------------------- */
  75
  76 static void
  77 listbox_entry_free (void *data)
  78 {
  79     WLEntry *e = data;
  80
  81     g_free (e->text);
  82     if (e->free_data)
  83         g_free (e->data);
  84     g_free (e);
  85 }
  86
  87 /* --------------------------------------------------------------------------------------------- */
  88
  89 static void
  90 listbox_drawscroll (WListbox * l)
  91 {
  92     Widget *w = WIDGET (l);
  93     int max_line = w->lines - 1;
  94     int line = 0;
  95     int i;
  96     int length;
  97
  98     /* Are we at the top? */
  99     widget_move (w, 0, w->cols);
 100     if (l->top == 0)
 101         tty_print_one_vline (TRUE);
 102     else
 103         tty_print_char ('^');
 104
 105     length = g_queue_get_length (l->list);
 106
 107     /* Are we at the bottom? */
 108     widget_move (w, max_line, w->cols);
 109     if (l->top + w->lines == length || w->lines >= length)
 110         tty_print_one_vline (TRUE);
 111     else
 112         tty_print_char ('v');
 113
 114     /* Now draw the nice relative pointer */
 115     if (!g_queue_is_empty (l->list))
 116         line = 1 + ((l->pos * (w->lines - 2)) / length);
 117
 118     for (i = 1; i < max_line; i++)
 119     {
 120         widget_move (w, i, w->cols);
 121         if (i != line)
 122             tty_print_one_vline (TRUE);
 123         else
 124             tty_print_char ('*');
 125     }
 126 }
 127
 128 /* --------------------------------------------------------------------------------------------- */
 129
 130 static void
 131 listbox_draw (WListbox * l, gboolean focused)
 132 {
 133     Widget *w = WIDGET (l);
 134     const WDialog *h = w->owner;
 135     gboolean disabled;
 136     int normalc, selc;
 137     int length = 0;
 138     GList *le = NULL;
 139     int pos;
 140     int i;
 141     int sel_line = -1;
 142
 143     disabled = widget_get_state (w, WST_DISABLED);
 144     normalc = disabled ? DISABLED_COLOR : h->color[DLG_COLOR_NORMAL];
 145     /* *INDENT-OFF* */
 146     selc = disabled
 147         ? DISABLED_COLOR
 148         : focused
 149             ? h->color[DLG_COLOR_HOT_FOCUS]
 150             : h->color[DLG_COLOR_FOCUS];
 151     /* *INDENT-ON* */
 152
 153     if (l->list != NULL)
 154     {
 155         length = g_queue_get_length (l->list);
 156         le = g_queue_peek_nth_link (l->list, (guint) l->top);
 157     }
 158
 159     /*    pos = (le == NULL) ? 0 : g_list_position (l->list, le); */
 160     pos = (le == NULL) ? 0 : l->top;
 161
 162     for (i = 0; i < w->lines; i++)
 163     {
 164         const char *text = "";
 165
 166         /* Display the entry */
 167         if (pos == l->pos && sel_line == -1)
 168         {
 169             sel_line = i;
 170             tty_setcolor (selc);
 171         }
 172         else
 173             tty_setcolor (normalc);
 174
 175         widget_move (l, i, 1);
 176
 177         if (l->list != NULL && le != NULL && (i == 0 || pos < length))
 178         {
 179             WLEntry *e = LENTRY (le->data);
 180
 181             text = e->text;
 182             le = g_list_next (le);
 183             pos++;
 184         }
 185
 186         tty_print_string (str_fit_to_term (text, w->cols - 2, J_LEFT_FIT));
 187     }
 188
 189     l->cursor_y = sel_line;
 190
 191     if (l->scrollbar && length > w->lines)
 192     {
 193         tty_setcolor (normalc);
 194         listbox_drawscroll (l);
 195     }
 196 }
 197
 198 /* --------------------------------------------------------------------------------------------- */
 199
 200 static int
 201 listbox_check_hotkey (WListbox * l, int key)
 202 {
 203     if (!listbox_is_empty (l))
 204     {
 205         int i;
 206         GList *le;
 207
 208         for (i = 0, le = g_queue_peek_head_link (l->list); le != NULL; i++, le = g_list_next (le))
 209         {
 210             WLEntry *e = LENTRY (le->data);
 211
 212             if (e->hotkey == key)
 213                 return i;
 214         }
 215     }
 216
 217     return (-1);
 218 }
 219
 220 /* --------------------------------------------------------------------------------------------- */
 221
 222 /* Calculates the item displayed at screen row 'y' (y==0 being the widget's 1st row). */
 223 static int
 224 listbox_y_pos (WListbox * l, int y)
 225 {
 226     return MIN (l->top + y, LISTBOX_LAST (l));
 227 }
 228
 229 /* --------------------------------------------------------------------------------------------- */
 230
 231 static void
 232 listbox_fwd (WListbox * l, gboolean wrap)
 233 {
 234     if ((guint) l->pos + 1 < g_queue_get_length (l->list))
 235         listbox_select_entry (l, l->pos + 1);
 236     else if (wrap)
 237         listbox_select_first (l);
 238 }
 239
 240 /* --------------------------------------------------------------------------------------------- */
 241
 242 static void
 243 listbox_fwd_n (WListbox * l, int n)
 244 {
 245     listbox_select_entry (l, MIN (l->pos + n, LISTBOX_LAST (l)));
 246 }
 247
 248 /* --------------------------------------------------------------------------------------------- */
 249
 250 static void
 251 listbox_back (WListbox * l, gboolean wrap)
 252 {
 253     if (l->pos > 0)
 254         listbox_select_entry (l, l->pos - 1);
 255     else if (wrap)
 256         listbox_select_last (l);
 257 }
 258
 259 /* --------------------------------------------------------------------------------------------- */
 260
 261 static void
 262 listbox_back_n (WListbox * l, int n)
 263 {
 264     listbox_select_entry (l, MAX (l->pos - n, 0));
 265 }
 266
 267 /* --------------------------------------------------------------------------------------------- */
 268
 269 static cb_ret_t
 270 listbox_execute_cmd (WListbox * l, long command)
 271 {
 272     cb_ret_t ret = MSG_HANDLED;
 273     Widget *w = WIDGET (l);
 274
 275     if (l->list == NULL || g_queue_is_empty (l->list))
 276         return MSG_NOT_HANDLED;
 277
 278     switch (command)
 279     {
 280     case CK_Up:
 281         listbox_back (l, TRUE);
 282         break;
 283     case CK_Down:
 284         listbox_fwd (l, TRUE);
 285         break;
 286     case CK_Top:
 287         listbox_select_first (l);
 288         break;
 289     case CK_Bottom:
 290         listbox_select_last (l);
 291         break;
 292     case CK_PageUp:
 293         listbox_back_n (l, w->lines - 1);
 294         break;
 295     case CK_PageDown:
 296         listbox_fwd_n (l, w->lines - 1);
 297         break;
 298     case CK_Delete:
 299         if (l->deletable)
 300         {
 301             gboolean is_last, is_more;
 302             int length;
 303
 304             length = g_queue_get_length (l->list);
 305
 306             is_last = (l->pos + 1 >= length);
 307             is_more = (l->top + w->lines >= length);
 308
 309             listbox_remove_current (l);
 310             if ((l->top > 0) && (is_last || is_more))
 311                 l->top--;
 312         }
 313         break;
 314     case CK_Clear:
 315         if (l->deletable && mc_global.widget.confirm_history_cleanup
 316             /* TRANSLATORS: no need to translate 'DialogTitle', it's just a context prefix */
 317             && (query_dialog (Q_ ("DialogTitle|History cleanup"),
 318                               _("Do you want clean this history?"),
 319                               D_ERROR, 2, _("&Yes"), _("&No")) == 0))
 320             listbox_remove_list (l);
 321         break;
 322     default:
 323         ret = MSG_NOT_HANDLED;
 324     }
 325
 326     return ret;
 327 }
 328
 329 /* --------------------------------------------------------------------------------------------- */
 330
 331 /* Return MSG_HANDLED if we want a redraw */
 332 static cb_ret_t
 333 listbox_key (WListbox * l, int key)
 334 {
 335     long command;
 336
 337     if (l->list == NULL)
 338         return MSG_NOT_HANDLED;
 339
 340     /* focus on listbox item N by '0'..'9' keys */
 341     if (key >= '0' && key <= '9')
 342     {
 343         listbox_select_entry (l, key - '0');
 344         return MSG_HANDLED;
 345     }
 346
 347     command = keybind_lookup_keymap_command (listbox_map, key);
 348     if (command == CK_IgnoreKey)
 349         return MSG_NOT_HANDLED;
 350     return listbox_execute_cmd (l, command);
 351 }
 352
 353 /* --------------------------------------------------------------------------------------------- */
 354
 355 /* Listbox item adding function */
 356 static inline void
 357 listbox_append_item (WListbox * l, WLEntry * e, listbox_append_t pos)
 358 {
 359     if (l->list == NULL)
 360     {
 361         l->list = g_queue_new ();
 362         pos = LISTBOX_APPEND_AT_END;
 363     }
 364
 365     switch (pos)
 366     {
 367     case LISTBOX_APPEND_AT_END:
 368         g_queue_push_tail (l->list, e);
 369         break;
 370
 371     case LISTBOX_APPEND_BEFORE:
 372         g_queue_insert_before (l->list, g_queue_peek_nth_link (l->list, (guint) l->pos), e);
 373         break;
 374
 375     case LISTBOX_APPEND_AFTER:
 376         g_queue_insert_after (l->list, g_queue_peek_nth_link (l->list, (guint) l->pos), e);
 377         break;
 378
 379     case LISTBOX_APPEND_SORTED:
 380         g_queue_insert_sorted (l->list, e, (GCompareDataFunc) listbox_entry_cmp, NULL);
 381         break;
 382
 383     default:
 384         break;
 385     }
 386 }
 387
 388 /* --------------------------------------------------------------------------------------------- */
 389
 390 /* Call this whenever the user changes the selected item. */
 391 static void
 392 listbox_on_change (WListbox * l)
 393 {
 394     listbox_draw (l, TRUE);
 395     send_message (WIDGET (l)->owner, l, MSG_NOTIFY, l->pos, NULL);
 396 }
 397
 398 /* --------------------------------------------------------------------------------------------- */
 399
 400 static void
 401 listbox_do_action (WListbox * l)
 402 {
 403     int action;
 404
 405     if (l->callback != NULL)
 406         action = l->callback (l);
 407     else
 408         action = LISTBOX_DONE;
 409
 410     if (action == LISTBOX_DONE)
 411     {
 412         WDialog *h = WIDGET (l)->owner;
 413
 414         h->ret_value = B_ENTER;
 415         dlg_stop (h);
 416     }
 417 }
 418
 419 /* --------------------------------------------------------------------------------------------- */
 420
 421 static void
 422 listbox_run_hotkey (WListbox * l, int pos)
 423 {
 424     listbox_select_entry (l, pos);
 425     listbox_on_change (l);
 426     listbox_do_action (l);
 427 }
 428
 429 /* --------------------------------------------------------------------------------------------- */
 430
 431 static inline void
 432 listbox_destroy (WListbox * l)
 433 {
 434     listbox_remove_list (l);
 435 }
 436
 437 /* --------------------------------------------------------------------------------------------- */
 438
 439 static cb_ret_t
 440 listbox_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
 441 {
 442     WListbox *l = LISTBOX (w);
 443     cb_ret_t ret_code;
 444
 445     switch (msg)
 446     {
 447     case MSG_INIT:
 448         return MSG_HANDLED;
 449
 450     case MSG_HOTKEY:
 451         {
 452             int pos;
 453
 454             pos = listbox_check_hotkey (l, parm);
 455             if (pos < 0)
 456                 return MSG_NOT_HANDLED;
 457
 458             listbox_run_hotkey (l, pos);
 459
 460             return MSG_HANDLED;
 461         }
 462
 463     case MSG_KEY:
 464         ret_code = listbox_key (l, parm);
 465         if (ret_code != MSG_NOT_HANDLED)
 466             listbox_on_change (l);
 467         return ret_code;
 468
 469     case MSG_ACTION:
 470         return listbox_execute_cmd (l, parm);
 471
 472     case MSG_CURSOR:
 473         widget_move (l, l->cursor_y, 0);
 474         return MSG_HANDLED;
 475
 476     case MSG_FOCUS:
 477     case MSG_UNFOCUS:
 478         l->focused = msg == MSG_FOCUS;
 479         /* fall through */
 480     case MSG_DRAW:
 481         listbox_draw (l, l->focused);
 482         return MSG_HANDLED;
 483
 484     case MSG_DESTROY:
 485         listbox_destroy (l);
 486         return MSG_HANDLED;
 487
 488     case MSG_RESIZE:
 489         return MSG_HANDLED;
 490
 491     default:
 492         return widget_default_callback (w, sender, msg, parm, data);
 493     }
 494 }
 495
 496 /* --------------------------------------------------------------------------------------------- */
 497
 498 static void
 499 listbox_mouse_callback (Widget * w, mouse_msg_t msg, mouse_event_t * event)
 500 {
 501     WListbox *l = LISTBOX (w);
 502     int old_pos;
 503
 504     old_pos = l->pos;
 505
 506     switch (msg)
 507     {
 508     case MSG_MOUSE_DOWN:
 509         dlg_select_widget (l);
 510         listbox_select_entry (l, listbox_y_pos (l, event->y));
 511         break;
 512
 513     case MSG_MOUSE_SCROLL_UP:
 514         listbox_back (l, FALSE);
 515         break;
 516
 517     case MSG_MOUSE_SCROLL_DOWN:
 518         listbox_fwd (l, FALSE);
 519         break;
 520
 521     case MSG_MOUSE_DRAG:
 522         event->result.repeat = TRUE;    /* It'd be functional even without this. */
 523         listbox_select_entry (l, listbox_y_pos (l, event->y));
 524         break;
 525
 526     case MSG_MOUSE_CLICK:
 527         /* We don't call listbox_select_entry() here: MSG_MOUSE_DOWN/DRAG did this already. */
 528         if (event->count == GPM_DOUBLE) /* Double click */
 529             listbox_do_action (l);
 530         break;
 531
 532     default:
 533         break;
 534     }
 535
 536     /* If the selection has changed, we redraw the widget and notify the dialog. */
 537     if (l->pos != old_pos)
 538         listbox_on_change (l);
 539 }
 540
 541 /* --------------------------------------------------------------------------------------------- */
 542 /*** public functions ****************************************************************************/
 543 /* --------------------------------------------------------------------------------------------- */
 544
 545 WListbox *
 546 listbox_new (int y, int x, int height, int width, gboolean deletable, lcback_fn callback)
 547 {
 548     WListbox *l;
 549     Widget *w;
 550
 551     if (height <= 0)
 552         height = 1;
 553
 554     l = g_new (WListbox, 1);
 555     w = WIDGET (l);
 556     widget_init (w, y, x, height, width, listbox_callback, listbox_mouse_callback);
 557
 558     l->list = NULL;
 559     l->top = l->pos = 0;
 560     l->deletable = deletable;
 561     l->callback = callback;
 562     l->allow_duplicates = TRUE;
 563     l->scrollbar = !mc_global.tty.slow_terminal;
 564     l->focused = FALSE;
 565     widget_want_hotkey (w, TRUE);
 566
 567     return l;
 568 }
 569
 570 /* --------------------------------------------------------------------------------------------- */
 571
 572 int
 573 listbox_search_text (WListbox * l, const char *text)
 574 {
 575     if (!listbox_is_empty (l))
 576     {
 577         int i;
 578         GList *le;
 579
 580         for (i = 0, le = g_queue_peek_head_link (l->list); le != NULL; i++, le = g_list_next (le))
 581         {
 582             WLEntry *e = LENTRY (le->data);
 583
 584             if (strcmp (e->text, text) == 0)
 585                 return i;
 586         }
 587     }
 588
 589     return (-1);
 590 }
 591
 592 /* --------------------------------------------------------------------------------------------- */
 593
 594 /* Selects the first entry and scrolls the list to the top */
 595 void
 596 listbox_select_first (WListbox * l)
 597 {
 598     l->pos = l->top = 0;
 599 }
 600
 601 /* --------------------------------------------------------------------------------------------- */
 602
 603 /* Selects the last entry and scrolls the list to the bottom */
 604 void
 605 listbox_select_last (WListbox * l)
 606 {
 607     int lines = WIDGET (l)->lines;
 608     int length = 0;
 609
 610     if (!listbox_is_empty (l))
 611         length = g_queue_get_length (l->list);
 612
 613     l->pos = length > 0 ? length - 1 : 0;
 614     l->top = length > lines ? length - lines : 0;
 615 }
 616
 617 /* --------------------------------------------------------------------------------------------- */
 618
 619 void
 620 listbox_select_entry (WListbox * l, int dest)
 621 {
 622     GList *le;
 623     int pos;
 624     gboolean top_seen = FALSE;
 625
 626     if (listbox_is_empty (l) || dest < 0)
 627         return;
 628
 629     /* Special case */
 630     for (pos = 0, le = g_queue_peek_head_link (l->list); le != NULL; pos++, le = g_list_next (le))
 631     {
 632         if (pos == l->top)
 633             top_seen = TRUE;
 634
 635         if (pos == dest)
 636         {
 637             l->pos = dest;
 638             if (!top_seen)
 639                 l->top = l->pos;
 640             else
 641             {
 642                 int lines = WIDGET (l)->lines;
 643
 644                 if (l->pos - l->top >= lines)
 645                     l->top = l->pos - lines + 1;
 646             }
 647             return;
 648         }
 649     }
 650
 651     /* If we are unable to find it, set decent values */
 652     l->pos = l->top = 0;
 653 }
 654
 655 /* --------------------------------------------------------------------------------------------- */
 656
 657 /* Returns the current string text as well as the associated extra data */
 658 void
 659 listbox_get_current (WListbox * l, char **string, void **extra)
 660 {
 661     WLEntry *e = NULL;
 662     gboolean ok;
 663
 664     if (l != NULL)
 665         e = listbox_get_nth_item (l, l->pos);
 666
 667     ok = (e != NULL);
 668
 669     if (string != NULL)
 670         *string = ok ? e->text : NULL;
 671
 672     if (extra != NULL)
 673         *extra = ok ? e->data : NULL;
 674 }
 675
 676 /* --------------------------------------------------------------------------------------------- */
 677
 678 WLEntry *
 679 listbox_get_nth_item (const WListbox * l, int pos)
 680 {
 681     if (!listbox_is_empty (l) && pos >= 0)
 682     {
 683         GList *item;
 684
 685         item = g_queue_peek_nth_link (l->list, (guint) pos);
 686         if (item != NULL)
 687             return LENTRY (item->data);
 688     }
 689
 690     return NULL;
 691 }
 692
 693 /* --------------------------------------------------------------------------------------------- */
 694
 695 GList *
 696 listbox_get_first_link (const WListbox * l)
 697 {
 698     return (l == NULL || l->list == NULL) ? NULL : g_queue_peek_head_link (l->list);
 699 }
 700
 701 /* --------------------------------------------------------------------------------------------- */
 702
 703 void
 704 listbox_remove_current (WListbox * l)
 705 {
 706     if (!listbox_is_empty (l))
 707     {
 708         GList *current;
 709         int length;
 710
 711         current = g_queue_peek_nth_link (l->list, (guint) l->pos);
 712         listbox_entry_free (LENTRY (current->data));
 713         g_queue_delete_link (l->list, current);
 714
 715         length = g_queue_get_length (l->list);
 716
 717         if (length == 0)
 718             l->top = l->pos = 0;
 719         else if (l->pos >= length)
 720             l->pos = length - 1;
 721     }
 722 }
 723
 724 /* --------------------------------------------------------------------------------------------- */
 725
 726 gboolean
 727 listbox_is_empty (const WListbox * l)
 728 {
 729     return (l == NULL || l->list == NULL || g_queue_is_empty (l->list));
 730 }
 731
 732 /* --------------------------------------------------------------------------------------------- */
 733
 734 void
 735 listbox_set_list (WListbox * l, GList * list)
 736 {
 737     listbox_remove_list (l);
 738
 739     if (l != NULL)
 740     {
 741         GList *ll;
 742
 743         l->list = g_queue_new ();
 744
 745         for (ll = list; ll != NULL; ll = g_list_next (ll))
 746             g_queue_push_tail (l->list, ll->data);
 747
 748         g_list_free (list);
 749     }
 750 }
 751
 752 /* --------------------------------------------------------------------------------------------- */
 753
 754 void
 755 listbox_remove_list (WListbox * l)
 756 {
 757     if (l != NULL)
 758     {
 759         if (l->list != NULL)
 760         {
 761             g_queue_foreach (l->list, (GFunc) listbox_entry_free, NULL);
 762             g_queue_free (l->list);
 763         }
 764
 765         l->list = NULL;
 766         l->pos = l->top = 0;
 767     }
 768 }
 769
 770 /* --------------------------------------------------------------------------------------------- */
 771
 772 char *
 773 listbox_add_item (WListbox * l, listbox_append_t pos, int hotkey, const char *text, void *data,
 774                   gboolean free_data)
 775 {
 776     WLEntry *entry;
 777
 778     if (l == NULL)
 779         return NULL;
 780
 781     if (!l->allow_duplicates && (listbox_search_text (l, text) >= 0))
 782         return NULL;
 783
 784     entry = g_new (WLEntry, 1);
 785     entry->text = g_strdup (text);
 786     entry->data = data;
 787     entry->free_data = free_data;
 788     entry->hotkey = hotkey;
 789
 790     listbox_append_item (l, entry, pos);
 791
 792     return entry->text;
 793 }
 794
 795 /* --------------------------------------------------------------------------------------------- */