Ticket #4165: MultiSearch_v5.7.patch

File MultiSearch_v5.7.patch, 79.0 KB (added by psprint, 15 months ago)

use options dialogs

  • lib/keybind.c

    From 042dd9c5e7b19b2de52bb90e74cf5e47c0b25ba0 Mon Sep 17 00:00:00 2001
    From: Sebastian Gniazdowski <sgniazdowski@gmail.com>
    Date: Tue, 26 Jan 2021 15:08:58 -0600
    Subject: =?UTF-8?q?MultiSearch=20=E2=80=93=20an=20AND-chained=20filtering?=
     =?UTF-8?q?=20of=20any=20listbox.?=
    MIME-Version: 1.0
    Content-Type: text/plain; charset=UTF-8
    Content-Transfer-Encoding: 8bit
    
    ---
     lib/keybind.c                  |   1 +
     lib/keybind.h                  |   1 +
     lib/widget.h                   |   2 +
     lib/widget/Makefile.am         |   2 +
     lib/widget/dialog-switch.c     |   3 +-
     lib/widget/dialog.c            |  49 +--
     lib/widget/dialog.h            |   1 +
     lib/widget/filtering_listbox.c | 533 +++++++++++++++++++++++++++++++++
     lib/widget/filtering_listbox.h |  46 +++
     lib/widget/forwarding_input.c  | 163 ++++++++++
     lib/widget/forwarding_input.h  |  36 +++
     lib/widget/group.c             |  11 +-
     lib/widget/history.c           |  97 +++---
     lib/widget/history.h           |   4 +-
     lib/widget/input.c             |  60 +++-
     lib/widget/input.h             |   2 +
     lib/widget/input_complete.c    |  73 +++--
     lib/widget/listbox-window.c    |  24 +-
     lib/widget/listbox-window.h    |   4 +-
     lib/widget/listbox.c           |  75 ++++-
     lib/widget/listbox.h           |   8 +
     lib/widget/widget-common.c     |   2 +
     lib/widget/widget-common.h     |  15 +-
     src/editor/choosesyntax.c      |   2 +-
     src/editor/editcmd_dialogs.c   |  14 +-
     src/editor/editoptions.c       |   2 +
     src/editor/editwidget.c        |   8 +-
     src/file_history.c             |   3 +-
     src/filemanager/boxes.c        |   1 +
     src/keybind-defaults.c         |   5 +-
     src/selcodepage.c              |   2 +-
     src/setup.c                    |   4 +
     src/setup.h                    |   1 +
     src/usermenu.c                 |   2 +-
     34 files changed, 1111 insertions(+), 145 deletions(-)
     create mode 100644 lib/widget/filtering_listbox.c
     create mode 100644 lib/widget/filtering_listbox.h
     create mode 100644 lib/widget/forwarding_input.c
     create mode 100644 lib/widget/forwarding_input.h
    
    diff --git a/lib/keybind.c b/lib/keybind.c
    index abd44d3e2..df3cbf110 100644
    a b static name_keymap_t command_names[] = { 
    9393    ADD_KEYMAP_NAME (SearchContinue), 
    9494    ADD_KEYMAP_NAME (Replace), 
    9595    ADD_KEYMAP_NAME (ReplaceContinue), 
     96    ADD_KEYMAP_NAME (MultiSearch), 
    9697    ADD_KEYMAP_NAME (Help), 
    9798    ADD_KEYMAP_NAME (Shell), 
    9899    ADD_KEYMAP_NAME (Edit), 
  • lib/keybind.h

    diff --git a/lib/keybind.h b/lib/keybind.h
    index af019df09..817158412 100644
    a b enum 
    8282    CK_SearchContinue, 
    8383    CK_Replace, 
    8484    CK_ReplaceContinue, 
     85    CK_MultiSearch, 
    8586    CK_SearchStop, 
    8687    CK_Help, 
    8788    CK_Edit, 
  • lib/widget.h

    diff --git a/lib/widget.h b/lib/widget.h
    index e3bb5cac2..cfe556891 100644
    a b typedef struct WGroup WGroup; 
    3030#include "lib/widget/groupbox.h" 
    3131#include "lib/widget/label.h" 
    3232#include "lib/widget/listbox.h" 
     33#include "lib/widget/filtering_listbox.h" 
    3334#include "lib/widget/menu.h" 
    3435#include "lib/widget/radio.h" 
    3536#include "lib/widget/input.h" 
     37#include "lib/widget/forwarding_input.h" 
    3638#include "lib/widget/listbox-window.h" 
    3739#include "lib/widget/quick.h" 
    3840#include "lib/widget/wtools.h" 
  • lib/widget/Makefile.am

    diff --git a/lib/widget/Makefile.am b/lib/widget/Makefile.am
    index 90f023bbc..9a4616c38 100644
    a b libmcwidget_la_SOURCES = \ 
    1616        history.c history.h \ 
    1717        input.c input.h \ 
    1818        input_complete.c \ 
     19        forwarding_input.c forwarding_input.h \ 
    1920        listbox-window.c listbox-window.h \ 
    2021        listbox.c listbox.h \ 
     22        filtering_listbox.c filtering_listbox.h \ 
    2123        label.c label.h \ 
    2224        menu.c menu.h \ 
    2325        mouse.c mouse.h \ 
  • lib/widget/dialog-switch.c

    diff --git a/lib/widget/dialog-switch.c b/lib/widget/dialog-switch.c
    index 93868b19d..a9a51ce0d 100644
    a b dialog_switch_list (void) 
    241241        else 
    242242            title = g_strdup (""); 
    243243 
    244         listbox_add_item (listbox->list, LISTBOX_APPEND_BEFORE, get_hotkey (i++), title, h, FALSE); 
     244        listbox_add_item (LISTBOX (listbox->list), LISTBOX_APPEND_BEFORE, get_hotkey (i++), title, 
     245                          h, FALSE); 
    245246 
    246247        g_free (title); 
    247248    } 
  • lib/widget/dialog.c

    diff --git a/lib/widget/dialog.c b/lib/widget/dialog.c
    index b8a08f029..c8d940be9 100644
    a b dlg_default_get_colors (const Widget * w) 
    8787    return CONST_DIALOG (w)->colors; 
    8888} 
    8989 
    90 /* --------------------------------------------------------------------------------------------- */ 
    91 /** 
    92   * Read histories from the ${XDG_CACHE_HOME}/mc/history file 
    93   */ 
    94 static void 
    95 dlg_read_history (WDialog * h) 
    96 { 
    97     char *profile; 
    98     ev_history_load_save_t event_data; 
    99  
    100     if (num_history_items_recorded == 0)        /* this is how to disable */ 
    101         return; 
    102  
    103     profile = mc_config_get_full_path (MC_HISTORY_FILE); 
    104     event_data.cfg = mc_config_init (profile, TRUE); 
    105     event_data.receiver = NULL; 
    106  
    107     /* create all histories in dialog */ 
    108     mc_event_raise (h->event_group, MCEVENT_HISTORY_LOAD, &event_data); 
    109  
    110     mc_config_deinit (event_data.cfg); 
    111     g_free (profile); 
    112 } 
    113  
    11490/* --------------------------------------------------------------------------------------------- */ 
    11591 
    11692static void 
    do_refresh (void) 
    473449 
    474450/* --------------------------------------------------------------------------------------------- */ 
    475451 
     452/** 
     453  * Read histories from the ${XDG_CACHE_HOME}/mc/history file 
     454  */ 
     455void 
     456dlg_read_history (WDialog * h) 
     457{ 
     458    char *profile; 
     459    ev_history_load_save_t event_data; 
     460 
     461    if (num_history_items_recorded == 0)        /* this is how to disable */ 
     462        return; 
     463 
     464    profile = mc_config_get_full_path (MC_HISTORY_FILE); 
     465    event_data.cfg = mc_config_init (profile, TRUE); 
     466    event_data.receiver = NULL; 
     467 
     468    /* create all histories in dialog */ 
     469    mc_event_raise (h->event_group, MCEVENT_HISTORY_LOAD, &event_data); 
     470 
     471    mc_config_deinit (event_data.cfg); 
     472    g_free (profile); 
     473} 
     474 
     475/* --------------------------------------------------------------------------------------------- */ 
     476 
    476477void 
    477478dlg_stop (WDialog * h) 
    478479{ 
  • lib/widget/dialog.h

    diff --git a/lib/widget/dialog.h b/lib/widget/dialog.h
    index 1d08b8e1a..d67735e71 100644
    a b int dlg_run (WDialog * d); 
    109109void dlg_destroy (WDialog * h); 
    110110 
    111111void dlg_run_done (WDialog * h); 
     112void dlg_read_history (WDialog * h); 
    112113void dlg_save_history (WDialog * h); 
    113114void dlg_process_event (WDialog * h, int key, Gpm_Event * event); 
    114115 
  • new file lib/widget/filtering_listbox.c

    diff --git a/lib/widget/filtering_listbox.c b/lib/widget/filtering_listbox.c
    new file mode 100644
    index 000000000..d075561cb
    - +  
     1/* 
     2   A class extending WListbox with dynamic filtering (i.e.: removal) of entries. 
     3 
     4   Copyright (C) <2021> 
     5   Free Software Foundation, Inc. 
     6 
     7   Written by: 
     8   Sebastian Gniazdowski <sgniazdowski@gmail.com>, 2021. 
     9 
     10   This file is part of the Midnight Commander. 
     11 
     12   The Midnight Commander is free software: you can redistribute it 
     13   and/or modify it under the terms of the GNU General Public License as 
     14   published by the Free Software Foundation, either version 3 of the License, 
     15   or (at your option) any later version. 
     16 
     17   The Midnight Commander 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, see <http://www.gnu.org/licenses/>. 
     24 */ 
     25 
     26/** \file filtering_listbox.c 
     27 *  \brief A WListbox inheriting class that adds dynamic filtering of entries. 
     28 *  \author Sebastian Gniazdowski 
     29 *  \date 2021 
     30 * 
     31 * In order to enable/disable (i.e.: toggle) MultiSearch on an listbox you can send a message: 
     32 *      send_message (listbox, NULL, MSG_ACTION, CK_MultiSearch, NULL); 
     33 * 
     34 * It'll extend owning dialog with a new MultiSearch input and pair it up with the listbox, so that 
     35 * some of keys (basically all that aren't in input's keymap) are forwarded to listbox. 
     36 */ 
     37 
     38#include <config.h> 
     39 
     40#include "lib/global.h" 
     41#include "src/setup.h" 
     42#include "lib/widget.h" 
     43#include "lib/tty/tty.h" 
     44 
     45/*** global variables ****************************************************************************/ 
     46 
     47/*** file scope macro definitions ****************************************************************/ 
     48 
     49/*** file scope type declarations ****************************************************************/ 
     50 
     51/*** file scope variables ************************************************************************/ 
     52 
     53/*** file scope functions ************************************************************************/ 
     54/* --------------------------------------------------------------------------------------------- */ 
     55 
     56static WLEntry * 
     57filt_listbox_shallow_copy_entry (WLEntry * src, gboolean take_ownership) 
     58{ 
     59    WLEntry *copy; 
     60    copy = g_new (WLEntry, 1); 
     61    *copy = *src; 
     62 
     63    /* Who has the ownership of the data? */ 
     64    src->free_text = src->free_text && !take_ownership; 
     65    src->free_data = src->free_data && !take_ownership; 
     66    copy->free_text = copy->free_text && take_ownership; 
     67    copy->free_data = copy->free_data && take_ownership; 
     68 
     69    return copy; 
     70} 
     71 
     72/* --------------------------------------------------------------------------------------------- */ 
     73 
     74static void 
     75filt_listbox_make_one_line_room (WFilteringListbox * sl, gboolean should_add_free_room) 
     76{ 
     77    WListbox *l = LISTBOX (sl); 
     78    Widget *w = WIDGET (l), *owner = WIDGET (WIDGET (w)->owner); 
     79    WRect r_dialog, r_listbox; 
     80    int new_dialog_height, new_dialog_ypos, new_listbox_height, take_give_from_to_owner = 1; 
     81 
     82    /* 
     83     * IF the enlarged dialog won't fit the screen, don't resize it but the listbox instead. 
     84     * Do it also when requested if the listbox is large (for small listboxes always try to 
     85     * enlarge the dialog). 
     86     */ 
     87    if ((sl->resize_strategy == FILT_LIST_DIALOG_AUTO_RESIZE && LINES <= owner->lines + 2) || 
     88        (sl->resize_strategy == FILT_LIST_KEEP_DIALOG_SIZE && owner->lines > 7)) 
     89        take_give_from_to_owner = 0; 
     90 
     91    /* Increase the height of the dialog by 1, so that the new input fits. */ 
     92    if (should_add_free_room) 
     93    { 
     94        new_dialog_height = owner->lines + take_give_from_to_owner; 
     95        new_listbox_height = w->lines + (-1 + take_give_from_to_owner); 
     96        new_dialog_ypos = owner->y - take_give_from_to_owner; 
     97    } 
     98    else 
     99    { 
     100        new_dialog_height = owner->lines - take_give_from_to_owner; 
     101        new_listbox_height = w->lines - (-1 + take_give_from_to_owner); 
     102        new_dialog_ypos = owner->y + take_give_from_to_owner; 
     103    } 
     104    rect_init (&r_dialog, new_dialog_ypos, owner->x, new_dialog_height, owner->cols); 
     105    rect_init (&r_listbox, w->y, w->x, new_listbox_height, w->cols); 
     106 
     107    /* 
     108     * Doing widget_set_size_rect(w, &r_listbox) causes problems as it invokes 
     109     * drawing of the widget owner. 
     110     */ 
     111    send_message (w, NULL, MSG_RESIZE, 0, &r_listbox); 
     112    send_message (owner, NULL, MSG_RESIZE, 0, &r_dialog); 
     113} 
     114 
     115/* --------------------------------------------------------------------------------------------- */ 
     116 
     117static void 
     118filt_listbox_show_multi_search_widget (WFilteringListbox * sl) 
     119{ 
     120    WListbox *l = LISTBOX (sl); 
     121    Widget *w = WIDGET (l), *owner = WIDGET (WIDGET (l)->owner); 
     122    WForwardingInput *multi_search_in; 
     123    int distance_y = owner->y + owner->lines - (w->y + w->lines) + 1; 
     124    int distance_x = w->cols > 40 ? 5 : 1, small = w->cols <= 15 ? 1 : 0; 
     125 
     126    filt_listbox_make_one_line_room (sl, 1); 
     127 
     128    /* Adjust active display. */ 
     129    if (l->pos < 0) 
     130        l->pos = 0; 
     131    if (l->pos < l->top || l->pos >= l->top + w->lines) 
     132        l->top = l->pos - w->lines/2 + 1; 
     133    if (l->top < 0) 
     134        l->top = 0; 
     135 
     136    multi_search_in = forwarding_input_new (owner->lines - distance_y, distance_x, 
     137                                            input_colors, w->cols - 2 - distance_x + small, "", 
     138                                            "multi_search", INPUT_COMPLETE_NONE, w); 
     139    group_add_widget_autopos (GROUP (owner), multi_search_in, WPOS_KEEP_TOP | WPOS_CENTER_HORZ, 
     140                              NULL); 
     141    /* Initialize input widget. */ 
     142    send_message (WIDGET (multi_search_in), w, MSG_INIT, 0, NULL); 
     143    dlg_read_history (DIALOG (w->owner)); 
     144 
     145    /* Draw dialog and listbox, and then input. */ 
     146    widget_draw (WIDGET (w->owner)); 
     147    widget_draw (w); 
     148    widget_draw (WIDGET (multi_search_in)); 
     149} 
     150 
     151/* --------------------------------------------------------------------------------------------- */ 
     152 
     153static void 
     154filt_listbox_hide_multi_search_widget (WFilteringListbox * sl) 
     155{ 
     156    WListbox *l = LISTBOX (sl); 
     157    Widget *w = WIDGET (sl); 
     158    Widget *in; 
     159    in = widget_find_by_type (WIDGET (WIDGET (l)->owner), forw_input_callback); 
     160    if (in != NULL) 
     161    { 
     162        group_remove_widget (in); 
     163        filt_listbox_make_one_line_room (sl, 0); 
     164        group_select_next_widget (WIDGET (l)->owner); 
     165 
     166        /* 
     167         * Repainting is needed because some part of the resized dialog can be left on the 
     168         * background. 
     169         */ 
     170        if (sl->resize_strategy != FILT_LIST_KEEP_DIALOG_SIZE || w->lines <= 7) 
     171            repaint_screen (); 
     172 
     173        widget_draw (WIDGET (w->owner)); 
     174        widget_draw (w); 
     175        widget_destroy (in); 
     176    } 
     177} 
     178 
     179/* --------------------------------------------------------------------------------------------- */ 
     180 
     181/* Return TRUE if given listbox is in WST_FILTER state. */ 
     182static gboolean 
     183filt_listbox_is_filter_state (WFilteringListbox * sl) 
     184{ 
     185    return widget_get_state (WIDGET (sl), WST_FILTER); 
     186} 
     187 
     188/* --------------------------------------------------------------------------------------------- */ 
     189 
     190static void 
     191filt_listbox_filter_list (WFilteringListbox * sl, const char *text) 
     192{ 
     193    WListbox *l = LISTBOX (sl); 
     194    int i, size; 
     195    GList *le; 
     196    char **query_terms; 
     197    gboolean has_c_files = FALSE, has_header_files = FALSE; 
     198    /* 
     199     * Remove the list and allocate a new one. The elements are only shallowly freed because the 
     200     * internal data is still used (and kept in list_keep field). 
     201     */ 
     202    if (l->list != NULL) 
     203        g_queue_free_full (l->list, g_free); 
     204    l->list = g_queue_new (); 
     205 
     206    /* Split the query into space delimeted strings. */ 
     207    query_terms = g_strsplit (text, " ", 10); 
     208 
     209 
     210    size = g_queue_get_length (sl->list_keep); 
     211    le = g_queue_peek_head_link (sl->list_keep); 
     212    for (i = 0; i < size; i++, le = g_list_next (le)) 
     213    { 
     214        WLEntry *e = LENTRY (le->data); 
     215        size_t e_len; 
     216 
     217        /* Compute lenght once, then use it. */ 
     218        e_len = e->text ? strlen (e->text) : 0; 
     219 
     220        if (g_strrstr (e->text, ".c") == e->text + e_len - 2 || 
     221            g_strrstr (e->text, ".c~") == e->text + e_len - 3) 
     222            has_c_files = TRUE; 
     223        if (g_strrstr (e->text, ".cpp") == e->text + e_len - 4 || 
     224            g_strrstr (e->text, ".cpp~") == e->text + e_len - 5) 
     225            has_c_files = TRUE; 
     226        if (g_strrstr (e->text, ".h") == e->text + e_len - 2 || 
     227            g_strrstr (e->text, ".h~") == e->text + e_len - 3) 
     228            has_header_files = TRUE; 
     229        if (has_c_files && has_header_files) 
     230            break; 
     231    } 
     232 
     233    /* 
     234     * Get the size of the listbox and iterate over it testing each element against «all» words in 
     235     * query_terms. 
     236     */ 
     237    le = g_queue_peek_head_link (sl->list_keep); 
     238    for (i = 0; i < size; i++, le = g_list_next (le)) 
     239    { 
     240        WLEntry *e = LENTRY (le->data); 
     241        size_t e_len; 
     242        gboolean match = TRUE; 
     243 
     244        e_len = e->text ? strlen (e->text) : 0; 
     245 
     246        /* Test the query against the list entry. */ 
     247        for (gchar ** p = query_terms; *p != NULL; p++) 
     248        { 
     249 
     250            gboolean is_p_special; 
     251 
     252            /* Is it a special, shorthand query ("c" or "h") ? */ 
     253            is_p_special = g_strcmp0 (*p, "h") == 0 || g_strcmp0 (*p, "c") == 0; 
     254 
     255            /* Use special meaning of c/h queries only, when files seem to include such files. */ 
     256            if (is_p_special && (has_c_files || has_header_files)) 
     257            { 
     258                if (has_header_files && **p == 'h' && (g_strrstr (e->text, ".h") == 
     259                                                       e->text + e_len - 2 
     260                                                       || g_strrstr (e->text, 
     261                                                                     ".h~") == e->text + e_len - 3)) 
     262                { 
     263                    /* The file name (...apparently) matches -> do nothing. */ 
     264                } 
     265                else if (has_c_files && **p == 'c' && (g_strrstr (e->text, ".c") == 
     266                                                       e->text + e_len - 2 
     267                                                       || g_strrstr (e->text, 
     268                                                                     ".c~") == e->text + e_len - 3 
     269                                                       || g_strrstr (e->text, 
     270                                                                     ".cpp") == e->text + e_len - 4 
     271                                                       || g_strrstr (e->text, 
     272                                                                     ".cpp~") == 
     273                                                       e->text + e_len - 5)) 
     274                { 
     275                    /* The file name (...apparently) matches -> do nothing. */ 
     276                } 
     277                else 
     278                { 
     279                    /* No matching of a special query -> filter element out. */ 
     280                    match = FALSE; 
     281                    break; 
     282                } 
     283            } 
     284            else if (**p != '\0' && !strcasestr (e->text, *p)) 
     285            { 
     286                /* 
     287                 * No match -> filter out this entry. */ 
     288                match = FALSE; 
     289                break; 
     290            } 
     291        } 
     292 
     293        /* If all the terms matched, then add the element to the list. */ 
     294        if (match) 
     295            g_queue_push_tail (l->list, filt_listbox_shallow_copy_entry (e, FALSE)); 
     296    } 
     297    if (listbox_is_empty (l)) 
     298    { 
     299        listbox_add_item (l, LISTBOX_APPEND_AT_END, 0, "<no search results>", NULL, FALSE); 
     300        LENTRY (g_queue_peek_head_link (l->list)->data)->index = -2; 
     301    } 
     302    size = g_queue_get_length (l->list); 
     303    if (l->pos >= size) 
     304        listbox_select_entry (l, size - 1); 
     305    else 
     306        listbox_select_entry (l, l->pos); 
     307 
     308    g_strfreev (query_terms); 
     309} 
     310 
     311/* --------------------------------------------------------------------------------------------- */ 
     312 
     313/* Restores original elements of the list (from sl->list_keep) and turns off the WST_FILTER state. */ 
     314static gboolean 
     315filt_listbox_set_to_normal_state (WFilteringListbox * sl) 
     316{ 
     317    WListbox *l = LISTBOX (sl); 
     318    /* The listbox is already in non-filter state? */ 
     319    if (!widget_get_state (WIDGET (l), WST_FILTER)) 
     320    { 
     321        /* Return doing no change, just signal the error. */ 
     322        return FALSE; 
     323    } 
     324 
     325    /* The keep-list must be allocated (even if it's empty). */ 
     326    g_assert (sl->list_keep != NULL); 
     327 
     328    /* Mark the new state. */ 
     329    widget_set_state (WIDGET (l), WST_FILTER, FALSE); 
     330 
     331    /* Release the filtered list and replace it with the original, complete list (it owns the 
     332     * internal data, hence the release is a shallow one). */ 
     333    g_queue_free_full (l->list, g_free); 
     334    l->list = sl->list_keep; 
     335    sl->list_keep = NULL; 
     336    return TRUE; 
     337} 
     338 
     339/* --------------------------------------------------------------------------------------------- */ 
     340 
     341/* 
     342 * Sets the listbox into «filter» state. In this state, there's a separate copy of all list 
     343 * entries, while the original (and displayed) field ->list is being a filtered version of the 
     344 * full copy. 
     345 */ 
     346static gboolean 
     347filt_listbox_set_to_filter_state (WFilteringListbox * sl) 
     348{ 
     349    WListbox *l = LISTBOX (sl); 
     350    GList *le; 
     351 
     352    /* The listbox is already in filter state? */ 
     353    if (widget_get_state (WIDGET (l), WST_FILTER)) 
     354    { 
     355        /* Return doing no change, just signal the error. */ 
     356        return FALSE; 
     357    } 
     358 
     359    /* Mark the new state. */ 
     360    widget_set_state (WIDGET (l), WST_FILTER, TRUE); 
     361 
     362    /* No list copy when entering filter mode. */ 
     363    g_assert (sl->list_keep == NULL); 
     364    sl->list_keep = g_queue_new (); 
     365 
     366    /* Skip empty lists. */ 
     367    if (listbox_is_empty (l)) 
     368        return TRUE; 
     369 
     370    /* 
     371     * Remember the original position in the list in the field. It'll be used to determine the 
     372     * virtual_pos field. 
     373     */ 
     374    listbox_init_indices (l); 
     375 
     376    /* Perform a shallow copy of the original list. */ 
     377    for (le = g_queue_peek_head_link (l->list); le != NULL; le = g_list_next (le)) 
     378    { 
     379        WLEntry *copy; 
     380        copy = filt_listbox_shallow_copy_entry (LENTRY (le->data), TRUE); 
     381        g_queue_push_tail (sl->list_keep, copy); 
     382    } 
     383 
     384    return TRUE; 
     385} 
     386 
     387/* --------------------------------------------------------------------------------------------- */ 
     388 
     389/* 
     390 * If the list is filtered it replaces from the back list (list_keep). It returns whether such 
     391 * change occurred – FALSE means that the list was already unfiltered. 
     392 */ 
     393gboolean 
     394filt_listbox_ensure_unfiltered_state (WFilteringListbox * sl) 
     395{ 
     396    gboolean ret = FALSE; 
     397    if (filt_listbox_is_filter_state (sl)) 
     398        ret = filt_listbox_set_to_normal_state (sl); 
     399    return ret; 
     400} 
     401 
     402/* --------------------------------------------------------------------------------------------- */ 
     403 
     404gboolean 
     405filt_listbox_conditionally_enable_multi_search_init (WFilteringListbox * sl) 
     406{ 
     407    gboolean start_with_multi_search_active; 
     408 
     409    /* Option of starting the listbox with MultiSearch pre-activated. */ 
     410    start_with_multi_search_active = option_multisearch; 
     411 
     412    /* CK_MultiSearch toggles the state. */ 
     413    if (start_with_multi_search_active) 
     414        send_message (WIDGET (sl), NULL, MSG_ACTION, CK_MultiSearch, NULL); 
     415    else 
     416        /* Only init embedded position indices. */ 
     417        listbox_init_indices (LISTBOX (sl)); 
     418 
     419    /* Return if did enable MultiSearch. */ 
     420    return start_with_multi_search_active; 
     421} 
     422 
     423/* --------------------------------------------------------------------------------------------- */ 
     424/*** public functions ****************************************************************************/ 
     425/* --------------------------------------------------------------------------------------------- */ 
     426 
     427WFilteringListbox * 
     428filtering_listbox_new (int y, int x, int height, int width, 
     429                       gboolean deletable, lcback_fn callback, 
     430                       filt_listbox_resize_strategy_t resize) 
     431{ 
     432    WFilteringListbox *object; 
     433    Widget *w_ref; 
     434 
     435    /* Allocate memory for the object body. */ 
     436    object = g_new (WFilteringListbox, 1); 
     437 
     438    /* Forward the call to construct the inherited object. */ 
     439    listbox_init (&object->base, y, x, height, width, deletable, callback); 
     440 
     441    /* Alter fields of base class. */ 
     442    w_ref = WIDGET (object); 
     443    w_ref->callback = filt_listbox_callback;    /* Set custom callback handler */ 
     444 
     445    /* Set extending fields of this class. */ 
     446    object->list_keep = NULL;   /* No back buffer at startup */ 
     447    object->resize_strategy = resize;   /* Save resize strategy */ 
     448    object->initialized = FALSE; 
     449 
     450    return object; 
     451} 
     452 
     453/* --------------------------------------------------------------------------------------------- */ 
     454 
     455cb_ret_t 
     456filt_listbox_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data) 
     457{ 
     458    WFilteringListbox *sl = FILT_LISTBOX (w);   /* s* - from `screen`, a "screened" listbox */ 
     459    cb_ret_t ret = MSG_NOT_HANDLED; 
     460    long activity; 
     461 
     462    switch (msg) 
     463    { 
     464    case MSG_INIT: 
     465        if (!sl->initialized) 
     466        { 
     467            filt_listbox_conditionally_enable_multi_search_init (sl); 
     468            sl->initialized = TRUE; 
     469        } 
     470        /* WListbox doesn't have MSG_INIT, so don't forward. */ 
     471        ret = MSG_HANDLED; 
     472        break; 
     473    case MSG_ACTION: 
     474        if (parm == CK_MultiSearch) 
     475        { 
     476            gboolean retval; 
     477            /* Toggle the multi term searching of any listbox. */ 
     478            if (filt_listbox_is_filter_state (sl)) 
     479            { 
     480                /* Remove the input widget from the dialog. */ 
     481                filt_listbox_hide_multi_search_widget (sl); 
     482                /* Restore original (unfiltered) listbox contents. */ 
     483                retval = filt_listbox_set_to_normal_state (sl); 
     484            } 
     485            else 
     486            { 
     487                /* Add input widget for the filter query at the bottom of the dialog window. */ 
     488                filt_listbox_show_multi_search_widget (sl); 
     489                /* ... and then turn on the filter state. */ 
     490                retval = filt_listbox_set_to_filter_state (sl); 
     491            } 
     492            if (!retval) 
     493                message (D_ERROR | D_CENTER, MSG_ERROR, 
     494                         "An internal error #3 occurred (filtered listbox support)."); 
     495 
     496            ret = MSG_HANDLED; 
     497        } 
     498        break; 
     499 
     500    case MSG_KEY: 
     501        activity = widget_lookup_key (WIDGET (sl), parm); 
     502        if (activity == CK_MultiSearch) 
     503            ret = send_message (w, NULL, MSG_ACTION, CK_MultiSearch, NULL); 
     504        break; 
     505 
     506    case MSG_NOTIFY: 
     507        if (widget_get_state (w, WST_FILTER)) 
     508        { 
     509            filt_listbox_filter_list (sl, (char *) data); 
     510            ret = MSG_HANDLED; 
     511        } 
     512        widget_draw (w); 
     513        /* Protect against normal, non ForwardingInput messages, which might not have sender set. */ 
     514        if (sender) 
     515            widget_draw (sender); 
     516        break; 
     517 
     518    case MSG_DESTROY: 
     519        filt_listbox_ensure_unfiltered_state (sl); 
     520        /* ret is unhandled -> the message will be forwarded to base class. */ 
     521        break; 
     522    default: 
     523        break; 
     524    } 
     525 
     526    /* Forward action to base class in case it's not yet handled. */ 
     527    if (ret == MSG_NOT_HANDLED) 
     528        ret = listbox_callback (w, sender, msg, parm, data); 
     529 
     530    return ret; 
     531} 
     532 
     533/* --------------------------------------------------------------------------------------------- */ 
  • new file lib/widget/filtering_listbox.h

    diff --git a/lib/widget/filtering_listbox.h b/lib/widget/filtering_listbox.h
    new file mode 100644
    index 000000000..636e75819
    - +  
     1#ifndef MC__FILTERING_LISTBOX_H 
     2#define MC__FILTERING_LISTBOX_H 
     3 
     4/*** typedefs(not structures) and defined constants **********************************************/ 
     5 
     6/* Casting macros. */ 
     7#define FILT_LISTBOX(x) ((WFilteringListbox *)(x)) 
     8#define CONST_FILT_LISTBOX(x) ((const WFilteringListbox *)(x)) 
     9 
     10/*** enums ***************************************************************************************/ 
     11 
     12typedef enum filt_listbox_resize_strategy_e 
     13{ 
     14    FILT_LIST_EXTEND_DIALOG = 0, 
     15    FILT_LIST_KEEP_DIALOG_SIZE, 
     16    FILT_LIST_DIALOG_AUTO_RESIZE 
     17} filt_listbox_resize_strategy_t; 
     18 
     19/*** structures declarations (and typedefs of structures)*****************************************/ 
     20 
     21typedef struct WFilteringListbox_s 
     22{ 
     23    WListbox base; 
     24    gboolean initialized;       /* Whether MSG_INIT has been received. */ 
     25 
     26    /* Fields for new logic. */ 
     27    GQueue *list_keep;          /* Unfiltered list (used in  WST_FILTER state). */ 
     28    filt_listbox_resize_strategy_t resize_strategy; 
     29} WFilteringListbox; 
     30 
     31/*** global variables defined in .c file *********************************************************/ 
     32 
     33/*** declarations of public functions ************************************************************/ 
     34 
     35WFilteringListbox *filtering_listbox_new (int y, int x, int height, int width, 
     36                                          gboolean deletable, lcback_fn callback, 
     37                                          filt_listbox_resize_strategy_t resize); 
     38gboolean filt_listbox_ensure_unfiltered_state (WFilteringListbox * l); 
     39gboolean filt_listbox_conditionally_enable_multi_search_init (WFilteringListbox * l); 
     40void filt_listbox_select_entry (WFilteringListbox * sl, int dest); 
     41cb_ret_t filt_listbox_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, 
     42                                void *data); 
     43 
     44/*** inline functions ****************************************************************************/ 
     45 
     46#endif /* MC__FILTERING_LISTBOX_H */ 
  • new file lib/widget/forwarding_input.c

    diff --git a/lib/widget/forwarding_input.c b/lib/widget/forwarding_input.c
    new file mode 100644
    index 000000000..30a96f3d9
    - +  
     1/* 
     2   A key forwarding extended input class. 
     3 
     4   Copyright (C) 2021 
     5   Free Software Foundation, Inc. 
     6 
     7   Written by: 
     8   Sebastian Gniazdowski <sgniazdowski@gmail.com>, 2021. 
     9 
     10   This file is part of the Midnight Commander. 
     11 
     12   The Midnight Commander is free software: you can redistribute it 
     13   and/or modify it under the terms of the GNU General Public License as 
     14   published by the Free Software Foundation, either version 3 of the License, 
     15   or (at your option) any later version. 
     16 
     17   The Midnight Commander 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, see <http://www.gnu.org/licenses/>. 
     24 */ 
     25 
     26/** \file forwarding-input.c 
     27 *  \brief This input class has a feature of forwarding unrecognized keys to a widget passed at 
     28 *         creation. 
     29 *  \author Sebastian Gniazdowski 
     30 *  \date 2021 
     31 * 
     32 *  It's being used by MultiSearch to allow moving across listbox while typing to the input. 
     33 */ 
     34 
     35#include <config.h> 
     36 
     37#include "lib/global.h" 
     38#include "lib/widget.h" 
     39 
     40/*** global variables ****************************************************************************/ 
     41 
     42/*** file scope macro definitions ****************************************************************/ 
     43 
     44/*** file scope type declarations ****************************************************************/ 
     45 
     46/*** file scope variables ************************************************************************/ 
     47 
     48/*** file scope functions ************************************************************************/ 
     49/* --------------------------------------------------------------------------------------------- */ 
     50 
     51/* --------------------------------------------------------------------------------------------- */ 
     52/*** public functions ****************************************************************************/ 
     53/* --------------------------------------------------------------------------------------------- */ 
     54 
     55WForwardingInput * 
     56forwarding_input_new (int y, int x, const int *colors, 
     57                      int len, const char *text, const char *histname, 
     58                      input_complete_t completion_flags, Widget * forward_to_widget) 
     59{ 
     60    WForwardingInput *object; 
     61    Widget *w_ref; 
     62 
     63    /* Allocate memory for the object body. */ 
     64    object = g_new (WForwardingInput, 1); 
     65 
     66    /* Call upper constructor to initialize the inherited object. */ 
     67    input_init (&object->base, y, x, colors, len, text, histname, completion_flags); 
     68 
     69    /* Alter fields of base class. */ 
     70    w_ref = WIDGET (object); 
     71    w_ref->callback = forw_input_callback;      /* Set custom callback handler */ 
     72 
     73    /* Set  extending fields of this class. */ 
     74    object->forward_to_widget = forward_to_widget; 
     75    return object; 
     76} 
     77 
     78/* --------------------------------------------------------------------------------------------- */ 
     79 
     80cb_ret_t 
     81forw_input_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data) 
     82{ 
     83    WForwardingInput *in = FORW_INPUT (w); 
     84    gboolean key_message = FALSE; 
     85    cb_ret_t ret; 
     86 
     87    switch (msg) 
     88    { 
     89    case MSG_KEY: 
     90        ret = forw_input_handle_char (in, parm); 
     91        key_message = TRUE; 
     92        break; 
     93    default: 
     94        break; 
     95    } 
     96 
     97    /* 
     98     * Simply pass on all messages to the base class (except for MSG_KEY, which might have 
     99     * been possibly already sent from forw_input_handle_char() function). 
     100     */ 
     101 
     102    if (!key_message) 
     103        ret = input_callback (WIDGET (in), sender, msg, parm, data); 
     104 
     105    return ret; 
     106} 
     107 
     108/* --------------------------------------------------------------------------------------------- */ 
     109 
     110cb_ret_t 
     111forw_input_handle_char (WForwardingInput * in, int key) 
     112{ 
     113    cb_ret_t ret = MSG_NOT_HANDLED; 
     114    gboolean sent_to_base = FALSE; 
     115    long activity; 
     116    char *str_cp; 
     117 
     118    /* Save to detect if a change happened. */ 
     119    str_cp = g_strdup (in->base.buffer); 
     120 
     121    /* Is this key recognized by the base object? */ 
     122    activity = widget_lookup_key (WIDGET (in), key); 
     123    if (activity != CK_IgnoreKey && activity != CK_Complete) 
     124    { 
     125        /* Yes -> send the key to the upper class. */ 
     126        ret = input_callback (WIDGET (in), WIDGET (in), MSG_KEY, key, NULL); 
     127        sent_to_base = TRUE; 
     128    } 
     129    /* Should we try to forward the key to any paired widget? */ 
     130    if (in->forward_to_widget != NULL && ret == MSG_NOT_HANDLED) 
     131    { 
     132        /* Is it maybe recognized by forward_to_widget paired object? */ 
     133        activity = widget_lookup_key (WIDGET (in->forward_to_widget), key); 
     134        if (activity != CK_IgnoreKey) 
     135        { 
     136            /* Yes - forward the key to the paired widget (most probably WListbox). */ 
     137            ret = send_message (WIDGET (in->forward_to_widget), NULL, MSG_KEY, key, NULL); 
     138        } 
     139        /* Abort as this widget is probably released */ 
     140        if (activity == CK_MultiSearch && ret == MSG_HANDLED) 
     141            return ret; 
     142    } 
     143 
     144    /* 
     145     * If not handled yet, then send the key to the base object for general recognition (if 
     146     * not already done that). 
     147     */ 
     148 
     149    if (!sent_to_base && ret == MSG_NOT_HANDLED) 
     150    { 
     151        ret = input_callback (WIDGET (in), WIDGET (in), MSG_KEY, key, NULL); 
     152        sent_to_base = TRUE;    /* currently unused */ 
     153    } 
     154 
     155    /* Send update signal to paired widget «iff» input's text has changed. */ 
     156    if (in->forward_to_widget != NULL && g_strcmp0 (str_cp, in->base.buffer) != 0) 
     157        send_message (WIDGET (in->forward_to_widget), NULL, MSG_NOTIFY, key, in->base.buffer); 
     158    g_free (str_cp); 
     159 
     160    return ret; 
     161} 
     162 
     163/* --------------------------------------------------------------------------------------------- */ 
  • new file lib/widget/forwarding_input.h

    diff --git a/lib/widget/forwarding_input.h b/lib/widget/forwarding_input.h
    new file mode 100644
    index 000000000..dc4e49423
    - +  
     1#ifndef MC__FORWARDING_INPUT_H 
     2#define MC__FORWARDING_INPUT_H 
     3 
     4/*** typedefs(not structures) and defined constants **********************************************/ 
     5 
     6/* Casting macros. */ 
     7#define FORW_INPUT(x) ((WForwardingInput *)(x)) 
     8#define CONST_FORW_INPUT(x) ((const WForwardingInput *)(x)) 
     9 
     10typedef struct 
     11{ 
     12    WInput base; 
     13 
     14    /* Fields for new logic. */ 
     15    Widget *forward_to_widget;  /* The paired widget to receive unhandled keys */ 
     16} WForwardingInput; 
     17 
     18/*** enums ***************************************************************************************/ 
     19 
     20/*** structures declarations (and typedefs of structures)*****************************************/ 
     21 
     22/*** global variables defined in .c file *********************************************************/ 
     23 
     24/*** declarations of public functions ************************************************************/ 
     25 
     26WForwardingInput *forwarding_input_new (int y, int x, const int *colors, 
     27                                        int len, const char *text, const char *histname, 
     28                                        input_complete_t completion_flags, 
     29                                        Widget * forward_to_widget); 
     30 
     31cb_ret_t forw_input_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data); 
     32cb_ret_t forw_input_handle_char (WForwardingInput * in, int key); 
     33 
     34/*** inline functions ****************************************************************************/ 
     35 
     36#endif /* MC__FORWARDING_INPUT_H */ 
  • lib/widget/group.c

    diff --git a/lib/widget/group.c b/lib/widget/group.c
    index f8e318bd9..f16de833f 100644
    a b group_add_widget_autopos (WGroup * g, void *w, widget_pos_flags_t pos_flags, con 
    749749 * @param w Widget object 
    750750 */ 
    751751void 
    752 group_remove_widget (void *w) 
     752group_remove_widget (void *wid) 
    753753{ 
     754    Widget *w = WIDGET (wid); 
    754755    WGroup *g; 
    755756    GList *d; 
    756757 
    757758    /* Don't accept NULL widget. This shouldn't happen */ 
    758759    assert (w != NULL); 
    759760 
    760     g = WIDGET (w)->owner; 
     761    /* Invoke widget's pre unlink callback. */ 
     762    if (w->pre_unlink_func != NULL) 
     763        w->pre_unlink_func (w); 
     764 
     765    g = w->owner; 
    761766 
    762767    d = g_list_find (g->widgets, w); 
    763768    if (d == g->current) 
    group_remove_widget (void *w) 
    774779        group_select_current_widget (g); 
    775780    } 
    776781 
    777     WIDGET (w)->owner = NULL; 
     782    w->owner = NULL; 
    778783} 
    779784 
    780785/* --------------------------------------------------------------------------------------------- */ 
  • lib/widget/history.c

    diff --git a/lib/widget/history.c b/lib/widget/history.c
    index 775d02b1b..2ee719ca7 100644
    a b typedef struct 
    6666/*** file scope functions ************************************************************************/ 
    6767 
    6868static cb_ret_t 
    69 history_dlg_reposition (WDialog * dlg_head) 
     69history_dlg_reposition (WDialog * dlg_head, WRect * resize) 
    7070{ 
    71     history_dlg_data *data; 
    72     int x = 0, y, he, wi; 
    7371    WRect r; 
    7472 
    75     /* guard checks */ 
    76     if ((dlg_head == NULL) || (dlg_head->data == NULL)) 
    77         return MSG_NOT_HANDLED; 
    78  
    79     data = (history_dlg_data *) dlg_head->data; 
    80  
    81     y = data->y; 
    82     he = data->count + 2; 
    83  
    84     if (he <= y || y > (LINES - 6)) 
     73    if (resize == NULL) 
    8574    { 
    86         he = MIN (he, y - 1); 
    87         y -= he; 
     75        history_dlg_data *data; 
     76        int x = 0, y, he, wi; 
     77 
     78        /* guard checks */ 
     79        if ((dlg_head == NULL) || (dlg_head->data == NULL)) 
     80            return MSG_NOT_HANDLED; 
     81 
     82        data = (history_dlg_data *) dlg_head->data; 
     83 
     84        y = data->y; 
     85        he = data->count + 2; 
     86 
     87        if (he <= y || y > (LINES - 6)) 
     88        { 
     89            he = MIN (he, y - 1); 
     90            y -= he; 
     91        } 
     92        else 
     93        { 
     94            y++; 
     95            he = MIN (he, LINES - y); 
     96        } 
     97 
     98        if (data->x > 2) 
     99            x = data->x - 2; 
     100 
     101        wi = data->max_width + 4; 
     102 
     103        if ((wi + x) > COLS) 
     104        { 
     105            wi = MIN (wi, COLS); 
     106            x = COLS - wi; 
     107        } 
     108        rect_init (&r, y, x, he, wi); 
    88109    } 
    89110    else 
    90111    { 
    91         y++; 
    92         he = MIN (he, LINES - y); 
     112        /* A resize from some other code (currently from the listbox filter). */ 
     113        r = *resize; 
    93114    } 
    94115 
    95     if (data->x > 2) 
    96         x = data->x - 2; 
    97  
    98     wi = data->max_width + 4; 
    99  
    100     if ((wi + x) > COLS) 
    101     { 
    102         wi = MIN (wi, COLS); 
    103         x = COLS - wi; 
    104     } 
    105  
    106     rect_init (&r, y, x, he, wi); 
    107116 
    108117    return dlg_default_callback (WIDGET (dlg_head), NULL, MSG_RESIZE, 0, &r); 
    109118} 
    history_dlg_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, v 
    116125    switch (msg) 
    117126    { 
    118127    case MSG_RESIZE: 
    119         return history_dlg_reposition (DIALOG (w)); 
     128        return history_dlg_reposition (DIALOG (w), data); 
    120129 
    121130    case MSG_NOTIFY: 
    122131        { 
    history_create_item (history_descriptor_t * hd, void *data) 
    158167    width = str_term_width1 (text); 
    159168    hd->max_width = MAX (width, hd->max_width); 
    160169 
    161     listbox_add_item (hd->listbox, LISTBOX_APPEND_AT_END, 0, text, NULL, TRUE); 
     170    listbox_add_item (LISTBOX (hd->listbox), LISTBOX_APPEND_AT_END, 0, text, NULL, TRUE); 
    162171} 
    163172 
    164173/* --------------------------------------------------------------------------------------------- */ 
    history_descriptor_init (history_descriptor_t * hd, int y, int x, GList * histor 
    190199    hd->action = CK_IgnoreKey; 
    191200    hd->text = NULL; 
    192201    hd->max_width = 0; 
    193     hd->listbox = listbox_new (1, 1, 2, 2, TRUE, NULL); 
     202    hd->listbox = filtering_listbox_new (1, 1, 2, 2, TRUE, NULL, FILT_LIST_KEEP_DIALOG_SIZE); 
    194203    /* in most cases history list contains string only and no any other data */ 
    195204    hd->create = history_create_item; 
    196205    hd->release = history_release_item; 
    history_show (history_descriptor_t * hd) 
    205214    GList *z, *hi; 
    206215    size_t count; 
    207216    WDialog *query_dlg; 
     217    WListbox *lw; 
    208218    history_dlg_data hist_data; 
    209219    int dlg_ret; 
    210220 
    history_show (history_descriptor_t * hd) 
    217227        hd->create (hd, z->data); 
    218228    /* after this, the order of history items is following: recent at begin, oldest at end */ 
    219229 
    220     count = listbox_get_length (hd->listbox); 
     230    /* Get the WListbox pointer for convenience. */ 
     231    lw = LISTBOX (hd->listbox); 
     232    count = listbox_get_length (lw); 
    221233 
    222234    hist_data.y = hd->y; 
    223235    hist_data.x = hd->x; 
    history_show (history_descriptor_t * hd) 
    244256    { 
    245257        /* history is above base widget -- revert order to place recent item at bottom */ 
    246258        /* revert history direction */ 
    247         g_queue_reverse (hd->listbox->list); 
     259        g_queue_reverse (lw->list); 
    248260        if (hd->current < 0 || (size_t) hd->current >= count) 
    249             listbox_select_last (hd->listbox); 
     261            listbox_select_last (lw); 
    250262        else 
    251             listbox_select_entry (hd->listbox, count - 1 - (size_t) hd->current); 
     263            listbox_select_entry (lw, count - 1 - (size_t) hd->current); 
    252264    } 
    253265    else 
    254266    { 
    255267        /* history is below base widget -- keep order to place recent item on top  */ 
    256268        if (hd->current > 0) 
    257             listbox_select_entry (hd->listbox, hd->current); 
     269            listbox_select_entry (lw, hd->current); 
    258270    } 
    259271 
    260272    dlg_ret = dlg_run (query_dlg); 
    history_show (history_descriptor_t * hd) 
    274286            hd->action = CK_Enter; 
    275287        } 
    276288 
    277         listbox_get_current (hd->listbox, &q, NULL); 
    278         hd->text = g_strdup (q); 
     289        listbox_get_current (lw, &q, NULL); 
     290        /* Can still be 0 if special entry "<no search results>" will be selected. */ 
     291        if (q != NULL) 
     292            hd->text = g_strdup (q); 
    279293    } 
    280294 
     295    /* If needed, restore normal listbox state, with no backlist (list_keep). */ 
     296    filt_listbox_ensure_unfiltered_state (hd->listbox); 
     297 
    281298    /* get modified history from dialog */ 
    282299    z = NULL; 
    283     for (hi = listbox_get_first_link (hd->listbox); hi != NULL; hi = g_list_next (hi)) 
     300    for (hi = listbox_get_first_link (lw); hi != NULL; hi = g_list_next (hi)) 
    284301        /* history is being reverted here again */ 
    285302        z = g_list_prepend (z, hd->release (hd, LENTRY (hi->data))); 
    286303 
  • lib/widget/history.h

    diff --git a/lib/widget/history.h b/lib/widget/history.h
    index 9c4b403d1..23f4d403d 100644
    a b  
    1111/* forward declarations */ 
    1212struct history_descriptor_t; 
    1313struct WLEntry; 
    14 struct WListbox; 
     14typedef struct WFilteringListbox_s WFilteringListbox; 
    1515 
    1616typedef void (*history_create_item_func) (struct history_descriptor_t * hd, void *data); 
    1717typedef void *(*history_release_item_func) (struct history_descriptor_t * hd, struct WLEntry * le); 
    typedef struct history_descriptor_t 
    3030    char *text;                 /**< return text of selected item */ 
    3131 
    3232    size_t max_width;           /**< maximum width of sring in history */ 
    33     struct WListbox *listbox;   /**< listbox widget to draw history */ 
     33    WFilteringListbox *listbox;   /**< listbox widget to draw history */ 
    3434 
    3535    history_create_item_func create;    /**< function to create item of @list */ 
    3636    history_release_item_func release;  /**< function to release item of @list */ 
  • lib/widget/input.c

    diff --git a/lib/widget/input.c b/lib/widget/input.c
    index 471715c25..0069a765f 100644
    a b input_save_history (const gchar * event_group_name, const gchar * event_name, 
    871871    (void) event_group_name; 
    872872    (void) event_name; 
    873873 
    874     if (!in->is_password && (DIALOG (WIDGET (in)->owner)->ret_value != B_CANCEL)) 
     874    if (!in->is_password && WIDGET (in)->owner != NULL 
     875        && (DIALOG (WIDGET (in)->owner)->ret_value != B_CANCEL)) 
    875876    { 
    876877        ev_history_load_save_t *ev = (ev_history_load_save_t *) data; 
    877878 
    input_mouse_callback (Widget * w, mouse_msg_t msg, mouse_event_t * event) 
    970971    } 
    971972} 
    972973 
     974/* --------------------------------------------------------------------------------------------- */ 
     975/* a callback used when removing the widget from its WGroup */ 
     976 
     977static void 
     978input_unregister_history_events_cb (Widget * wid_ptr) 
     979{ 
     980    WDialog *h = DIALOG (wid_ptr->owner); 
     981 
     982    /* unsubscribe from "history_load" event */ 
     983    mc_event_del (h->event_group, MCEVENT_HISTORY_LOAD, input_load_history, wid_ptr); 
     984    /* unsubscribe from "history_save" event */ 
     985    mc_event_del (h->event_group, MCEVENT_HISTORY_SAVE, input_save_history, wid_ptr); 
     986} 
     987 
    973988/* --------------------------------------------------------------------------------------------- */ 
    974989/*** public functions ****************************************************************************/ 
    975990/* --------------------------------------------------------------------------------------------- */ 
    976991 
     992WInput * 
     993input_new (int y, int x, const int *colors, int width, const char *def_text, 
     994           const char *histname, input_complete_t completion_flags) 
     995{ 
     996    WInput *in; 
     997 
     998    in = g_new (WInput, 1); 
     999    input_init (in, y, x, colors, width, def_text, histname, completion_flags); 
     1000    return in; 
     1001} 
     1002 
     1003/* --------------------------------------------------------------------------------------------- */ 
     1004 
    9771005/** Create new instance of WInput object. 
    9781006  * @param y                    Y coordinate 
    9791007  * @param x                    X coordinate 
    input_mouse_callback (Widget * w, mouse_msg_t msg, mouse_event_t * event) 
    9841012  * @param completion_flags     Flags for specify type of completions 
    9851013  * @return                     WInput object 
    9861014  */ 
    987 WInput * 
    988 input_new (int y, int x, const int *colors, int width, const char *def_text, 
    989            const char *histname, input_complete_t completion_flags) 
     1015void 
     1016input_init (WInput * in, int y, int x, const int *colors, int width, const char *def_text, 
     1017            const char *histname, input_complete_t completion_flags) 
    9901018{ 
    991     WInput *in; 
    992     Widget *w; 
     1019    Widget *w = WIDGET (in); 
    9931020 
    994     in = g_new (WInput, 1); 
    995     w = WIDGET (in); 
    9961021    widget_init (w, y, x, 1, width, input_callback, input_mouse_callback); 
    9971022    w->options |= WOP_SELECTABLE | WOP_IS_INPUT | WOP_WANT_CURSOR; 
    9981023    w->keymap = input_map; 
    input_new (int y, int x, const int *colors, int width, const char *def_text, 
    10281053    if ((histname != NULL) && (*histname != '\0')) 
    10291054        in->history.name = g_strdup (histname); 
    10301055    /* history will be loaded later */ 
    1031  
    10321056    in->label = NULL; 
    1033  
    1034     return in; 
    10351057} 
    10361058 
    10371059/* --------------------------------------------------------------------------------------------- */ 
    input_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *d 
    10501072        mc_event_add (h->event_group, MCEVENT_HISTORY_LOAD, input_load_history, w, NULL); 
    10511073        /* subscribe to "history_save" event */ 
    10521074        mc_event_add (h->event_group, MCEVENT_HISTORY_SAVE, input_save_history, w, NULL); 
     1075        /* unregister (via the func) above events in case of removal from dialog */ 
     1076        w->pre_unlink_func = input_unregister_history_events_cb; 
    10531077        if (in->label != NULL) 
    10541078            widget_set_state (WIDGET (in->label), WST_DISABLED, widget_get_state (w, WST_DISABLED)); 
    10551079        return MSG_HANDLED; 
    input_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *d 
    10631087            return v; 
    10641088        } 
    10651089 
    1066         /* Keys we want others to handle */ 
     1090        /* Keys we want others to handle. */ 
    10671091        if (parm == KEY_UP || parm == KEY_DOWN || parm == ESC_CHAR 
    10681092            || parm == KEY_F (10) || parm == '\n') 
    10691093            return MSG_NOT_HANDLED; 
    input_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *d 
    10971121        return MSG_HANDLED; 
    10981122 
    10991123    case MSG_DESTROY: 
    1100         /* unsubscribe from "history_load" event */ 
    1101         mc_event_del (h->event_group, MCEVENT_HISTORY_LOAD, input_load_history, w); 
    1102         /* unsubscribe from "history_save" event */ 
    1103         mc_event_del (h->event_group, MCEVENT_HISTORY_SAVE, input_save_history, w); 
     1124        /* Only, if there is an owner WGroup. */ 
     1125        if (h != NULL) 
     1126        { 
     1127            /* unsubscribe from "history_load" event */ 
     1128            mc_event_del (h->event_group, MCEVENT_HISTORY_LOAD, input_load_history, w); 
     1129            /* unsubscribe from "history_save" event */ 
     1130            mc_event_del (h->event_group, MCEVENT_HISTORY_SAVE, input_save_history, w); 
     1131        } 
    11041132        input_destroy (in); 
    11051133        return MSG_HANDLED; 
    11061134 
  • lib/widget/input.h

    diff --git a/lib/widget/input.h b/lib/widget/input.h
    index a753e6160..792bb7f28 100644
    a b extern input_colors_t input_colors; 
    8383 
    8484/*** declarations of public functions ************************************************************/ 
    8585 
     86void input_init (WInput * in, int y, int x, const int *colors, int width, const char *def_text, 
     87                 const char *histname, input_complete_t completion_flags); 
    8688WInput *input_new (int y, int x, const int *colors, 
    8789                   int len, const char *text, const char *histname, 
    8890                   input_complete_t completion_flags); 
  • lib/widget/input_complete.c

    diff --git a/lib/widget/input_complete.c b/lib/widget/input_complete.c
    index c23fe6063..d4f9c423a 100644
    a b complete_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void 
    10171017{ 
    10181018    static int bl = 0; 
    10191019 
    1020     WGroup *g = GROUP (w); 
    10211020    WDialog *h = DIALOG (w); 
     1021    WFilteringListbox *slw; 
     1022    cb_ret_t ret = MSG_NOT_HANDLED; 
     1023 
     1024    /* Find the listbox in dialog's group. */ 
     1025    slw = FILT_LISTBOX (WIDGET (h)->find_by_type (WIDGET (h), filt_listbox_callback)); 
    10221026 
    10231027    switch (msg) 
    10241028    { 
    complete_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void 
    10271031        { 
    10281032        case KEY_LEFT: 
    10291033        case KEY_RIGHT: 
     1034            /* MultiSearch (list filtering) is allowing for left/right movement in query input. */ 
     1035            if (widget_get_state (WIDGET (slw), WST_FILTER)) 
     1036                break; 
    10301037            bl = 0; 
    10311038            h->ret_value = 0; 
    10321039            dlg_stop (h); 
    1033             return MSG_HANDLED; 
     1040            ret = MSG_HANDLED; 
     1041            break; 
    10341042 
    10351043        case KEY_BACKSPACE: 
     1044            /* MultiSearch is exclusive with completion widening. */ 
     1045            if (widget_get_state (WIDGET (slw), WST_FILTER)) 
     1046                break; 
    10361047            bl = 0; 
    10371048            /* exit from completion list if input line is empty */ 
    10381049            if (end == 0) 
    complete_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void 
    10561067 
    10571068                new_end = str_get_prev_char (&input->buffer[end]) - input->buffer; 
    10581069 
    1059                 for (i = 0, e = listbox_get_first_link (LISTBOX (g->current->data)); 
     1070                for (i = 0, e = listbox_get_first_link (LISTBOX (slw)); 
    10601071                     e != NULL; i++, e = g_list_next (e)) 
    10611072                { 
    10621073                    WLEntry *le = LENTRY (e->data); 
    10631074 
    10641075                    if (strncmp (input->buffer + start, le->text, new_end - start) == 0) 
    10651076                    { 
    1066                         listbox_select_entry (LISTBOX (g->current->data), i); 
     1077                        listbox_select_entry (LISTBOX (slw), i); 
    10671078                        end = new_end; 
    10681079                        input_handle_char (input, parm); 
    1069                         widget_draw (WIDGET (g->current->data)); 
     1080                        widget_draw (WIDGET (slw)); 
    10701081                        break; 
    10711082                    } 
    10721083                } 
    10731084            } 
    1074             return MSG_HANDLED; 
     1085            ret = MSG_HANDLED; 
     1086            break; 
    10751087 
    10761088        default: 
    10771089            if (parm < 32 || parm > 255) 
    10781090            { 
    10791091                bl = 0; 
    1080                 if (widget_lookup_key (WIDGET (input), parm) != CK_Complete) 
    1081                     return MSG_NOT_HANDLED; 
    1082  
    1083                 if (end == min_end) 
    1084                     return MSG_HANDLED; 
    1085  
    1086                 /* This means we want to refill the list box and start again */ 
    1087                 h->ret_value = B_USER; 
    1088                 dlg_stop (h); 
     1092                /* CK_Complete -> Is completion up to date? */ 
     1093                if ((widget_lookup_key (WIDGET (input), parm) == CK_Complete) && (end != min_end)) 
     1094                { 
     1095                    /* This means we want to refill the list box and start again. */ 
     1096                    h->ret_value = B_USER; 
     1097                    dlg_stop (h); 
     1098                } 
     1099                /* 
     1100                 * else - key will be ignored by this function, so leave ret unchanged - allow other 
     1101                 * widgets to process it. 
     1102                 */ 
    10891103            } 
    1090             else 
     1104 
     1105            /* 
     1106             * Do standard live entry lookup only when not filtering list via MultiSearch – it is 
     1107             * a feature that to a great extent replaces old engine. It can be still used as MultiSearch 
     1108             * can be dynamically enabled and disabled (by default with: Alt-space and Ctrl-space). 
     1109             */ 
     1110            else if (!widget_get_state (WIDGET (slw), WST_FILTER)) 
    10911111            { 
    10921112                static char buff[MB_LEN_MAX] = ""; 
    10931113                GList *e; 
    complete_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void 
    11101130                    break; 
    11111131                } 
    11121132 
    1113                 for (i = 0, e = listbox_get_first_link (LISTBOX (g->current->data)); 
     1133                for (i = 0, e = listbox_get_first_link (LISTBOX (slw)); 
    11141134                     e != NULL; i++, e = g_list_next (e)) 
    11151135                { 
    11161136                    WLEntry *le = LENTRY (e->data); 
    complete_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void 
    11211141                        if (need_redraw == 0) 
    11221142                        { 
    11231143                            need_redraw = 1; 
    1124                             listbox_select_entry (LISTBOX (g->current->data), i); 
     1144                            listbox_select_entry (LISTBOX (slw), i); 
    11251145                            last_text = le->text; 
    11261146                        } 
    11271147                        else 
    complete_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void 
    11721192                if (need_redraw == 2) 
    11731193                { 
    11741194                    insert_text (input, last_text, low); 
    1175                     widget_draw (WIDGET (g->current->data)); 
     1195                    widget_draw (WIDGET (slw)); 
    11761196                } 
    11771197                else if (need_redraw == 1) 
    11781198                { 
    complete_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void 
    11801200                    dlg_stop (h); 
    11811201                } 
    11821202                bl = 0; 
     1203                ret = MSG_HANDLED; 
    11831204            } 
    11841205        } 
    1185         return MSG_HANDLED; 
     1206        break; 
    11861207 
    11871208    default: 
    11881209        return dlg_default_callback (w, sender, msg, parm, data); 
    11891210    } 
     1211    return ret; 
    11901212} 
    11911213 
    11921214/* --------------------------------------------------------------------------------------------- */ 
    complete_engine (WInput * in, int what_to_do) 
    12231245            int start_x, start_y; 
    12241246            char **p, *q; 
    12251247            WDialog *complete_dlg; 
    1226             WListbox *complete_list; 
     1248            WFilteringListbox *complete_list; 
    12271249 
    12281250            for (p = in->completions + 1; *p != NULL; count++, p++) 
    12291251            { 
    complete_engine (WInput * in, int what_to_do) 
    12661288            complete_dlg = 
    12671289                dlg_create (TRUE, y, x, complete_height, complete_width, WPOS_KEEP_DEFAULT, TRUE, 
    12681290                            dialog_colors, complete_callback, NULL, "[Completion]", NULL); 
    1269             complete_list = listbox_new (1, 1, h - 2, w - 2, FALSE, NULL); 
     1291            complete_list = filtering_listbox_new (1, 1, h - 2, w - 2, FALSE, NULL, 
     1292                                                   FILT_LIST_KEEP_DIALOG_SIZE); 
    12701293            group_add_widget (GROUP (complete_dlg), complete_list); 
    12711294 
    12721295            for (p = in->completions + 1; *p != NULL; p++) 
    1273                 listbox_add_item (complete_list, LISTBOX_APPEND_AT_END, 0, *p, NULL, FALSE); 
     1296                listbox_add_item (LISTBOX (complete_list), LISTBOX_APPEND_AT_END, 0, *p, NULL, 
     1297                                  FALSE); 
    12741298 
    12751299            i = dlg_run (complete_dlg); 
    12761300            q = NULL; 
    12771301            if (i == B_ENTER) 
    12781302            { 
    1279                 listbox_get_current (complete_list, &q, NULL); 
     1303                listbox_get_current (LISTBOX (complete_list), &q, NULL); 
    12801304                if (q != NULL) 
    12811305                    insert_text (in, q, strlen (q)); 
    12821306            } 
    12831307            if (q != NULL || end != min_end) 
    12841308                input_complete_free (in); 
     1309 
    12851310            dlg_destroy (complete_dlg); 
    12861311 
    12871312            /* B_USER if user wants to start over again */ 
  • lib/widget/listbox-window.c

    diff --git a/lib/widget/listbox-window.c b/lib/widget/listbox-window.c
    index 44548b485..447ba1328 100644
    a b create_listbox_window_centered (int center_y, int center_x, int lines, int cols, 
    108108        dlg_create (TRUE, ypos, xpos, lines + space, cols + space, pos_flags, FALSE, listbox_colors, 
    109109                    NULL, NULL, help, title); 
    110110 
    111     listbox->list = listbox_new (2, 2, lines, cols, FALSE, NULL); 
    112     group_add_widget (GROUP (listbox->dlg), listbox->list); 
     111    listbox->list = 
     112        filtering_listbox_new (2, 2, lines, cols, FALSE, NULL, FILT_LIST_DIALOG_AUTO_RESIZE); 
     113    group_add_widget (GROUP (listbox->dlg), WIDGET (listbox->list)); 
    113114 
    114115    return listbox; 
    115116} 
    create_listbox_window (int lines, int cols, const char *title, const char *help) 
    128129int 
    129130run_listbox (Listbox * l) 
    130131{ 
     132    WListbox *lw = LISTBOX (l->list); 
    131133    int val = -1; 
    132134 
    133135    if (dlg_run (l->dlg) != B_CANCEL) 
    134         val = l->list->pos; 
     136    { 
     137        /* Get the virtual index first, to support filtered listboxes. */ 
     138        val = lw->virtual_pos; 
     139 
     140        /* No virtual position -> get pos. */ 
     141        if (val == -1) 
     142            val = lw->pos; 
     143    } 
     144 
    135145    dlg_destroy (l->dlg); 
    136146    g_free (l); 
    137147    return val; 
    run_listbox (Listbox * l) 
    149159void * 
    150160run_listbox_with_data (Listbox * l, const void *select) 
    151161{ 
     162    WListbox *lw = LISTBOX (l->list); 
    152163    void *val = NULL; 
    153164 
    154165    if (select != NULL) 
    155         listbox_select_entry (l->list, listbox_search_data (l->list, select)); 
     166        listbox_select_entry (lw, listbox_search_data (lw, select)); 
    156167 
    157168    if (dlg_run (l->dlg) != B_CANCEL) 
    158169    { 
    159170        WLEntry *e; 
    160         e = listbox_get_nth_item (l->list, l->list->pos); 
    161         if (e != NULL) 
     171        e = listbox_get_nth_item (lw, lw->pos); 
     172        /* -2 means that "<no search results>" has been selected. */ 
     173        if (e != NULL && e->index != -2) 
    162174        { 
    163175            /* The assert guards against returning a soon-to-be deallocated 
    164176             * pointer (as in listbox_add_item(..., TRUE)). */ 
  • lib/widget/listbox-window.h

    diff --git a/lib/widget/listbox-window.h b/lib/widget/listbox-window.h
    index 5a6082956..dc20cee13 100644
    a b  
    88/*** typedefs(not structures) and defined constants **********************************************/ 
    99 
    1010#define LISTBOX_APPEND_TEXT(l,h,t,d,f) \ 
    11     listbox_add_item (l->list, LISTBOX_APPEND_AT_END, h, t, d, f) 
     11    listbox_add_item (LISTBOX(l->list), LISTBOX_APPEND_AT_END, h, t, d, f) 
    1212 
    1313/*** enums ***************************************************************************************/ 
    1414 
     
    1717typedef struct 
    1818{ 
    1919    WDialog *dlg; 
    20     WListbox *list; 
     20    WFilteringListbox *list; 
    2121} Listbox; 
    2222 
    2323/*** global variables defined in .c file *********************************************************/ 
  • lib/widget/listbox.c

    diff --git a/lib/widget/listbox.c b/lib/widget/listbox.c
    index e20c1a82d..a284cc2e4 100644
    a b listbox_entry_free (void *data) 
    7777{ 
    7878    WLEntry *e = data; 
    7979 
    80     g_free (e->text); 
     80    if (e->free_text) 
     81        g_free (e->text); 
    8182    if (e->free_data) 
    8283        g_free (e->data); 
    8384    g_free (e); 
    listbox_key (WListbox * l, int key) 
    358359 
    359360/* --------------------------------------------------------------------------------------------- */ 
    360361 
     362/* When called via g_queue_foreach it assigns the index field with an incremented int. */ 
     363static void 
     364listbox_foreach_apply_index (gpointer data, gpointer user_data) 
     365{ 
     366    WLEntry *e = data; 
     367    int *cur_idx = user_data; 
     368 
     369    /* Set the index and increment it. */ 
     370    e->index = *cur_idx; 
     371    *cur_idx = *cur_idx + 1; 
     372} 
     373 
     374/* --------------------------------------------------------------------------------------------- */ 
     375 
    361376/* Listbox item adding function */ 
    362377static inline void 
    363378listbox_append_item (WListbox * l, WLEntry * e, listbox_append_t pos) 
    listbox_destroy (WListbox * l) 
    445460 
    446461/* --------------------------------------------------------------------------------------------- */ 
    447462 
    448 static cb_ret_t 
     463cb_ret_t 
    449464listbox_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data) 
    450465{ 
    451466    WListbox *l = LISTBOX (w); 
    listbox_mouse_callback (Widget * w, mouse_msg_t msg, mouse_event_t * event) 
    544559/*** public functions ****************************************************************************/ 
    545560/* --------------------------------------------------------------------------------------------- */ 
    546561 
    547 WListbox * 
    548 listbox_new (int y, int x, int height, int width, gboolean deletable, lcback_fn callback) 
     562void 
     563listbox_init (WListbox * l, int y, int x, int height, int width, gboolean deletable, 
     564              lcback_fn callback) 
    549565{ 
    550     WListbox *l; 
    551     Widget *w; 
     566    Widget *w = WIDGET (l); 
    552567 
    553568    if (height <= 0) 
    554569        height = 1; 
    555570 
    556     l = g_new (WListbox, 1); 
    557     w = WIDGET (l); 
    558571    widget_init (w, y, x, height, width, listbox_callback, listbox_mouse_callback); 
    559     w->options |= WOP_SELECTABLE | WOP_WANT_HOTKEY; 
     572    w->options |= WOP_SELECTABLE; 
    560573    w->keymap = listbox_map; 
    561574 
    562575    l->list = NULL; 
    563     l->top = l->pos = 0; 
     576    l->top = l->pos = l->virtual_pos = 0; 
    564577    l->deletable = deletable; 
    565578    l->callback = callback; 
    566579    l->allow_duplicates = TRUE; 
    567580    l->scrollbar = !mc_global.tty.slow_terminal; 
     581} 
    568582 
     583/* --------------------------------------------------------------------------------------------- */ 
     584 
     585WListbox * 
     586listbox_new (int y, int x, int height, int width, gboolean deletable, lcback_fn callback) 
     587{ 
     588    WListbox *l; 
     589 
     590    l = g_new (WListbox, 1); 
     591    listbox_init (l, y, x, height, width, deletable, callback); 
    569592    return l; 
    570593} 
    571594 
    listbox_select_last (WListbox * l) 
    648671void 
    649672listbox_select_entry (WListbox * l, int dest) 
    650673{ 
     674    WLEntry *e; 
    651675    GList *le; 
    652676    int pos; 
    653677    gboolean top_seen = FALSE; 
    654678 
    655679    if (listbox_is_empty (l) || dest < 0) 
     680    { 
     681        /* Reset position to a minimal one. */ 
     682        l->pos = 0; 
     683        l->virtual_pos = 0; 
    656684        return; 
     685    } 
    657686 
    658687    /* Special case */ 
    659688    for (pos = 0, le = g_queue_peek_head_link (l->list); le != NULL; pos++, le = g_list_next (le)) 
    listbox_select_entry (WListbox * l, int dest) 
    673702                if (l->pos - l->top >= lines) 
    674703                    l->top = l->pos - lines + 1; 
    675704            } 
     705            /* 
     706             * Set the virtual position, i.e.: a position in the initial, unfiltered list if the 
     707             * same element would be selected. 
     708             */ 
     709            e = LENTRY (le->data); 
     710            l->virtual_pos = e->index; 
    676711            return; 
    677712        } 
    678713    } 
    listbox_get_current (WListbox * l, char **string, void **extra) 
    701736    if (l != NULL) 
    702737        e = listbox_get_nth_item (l, l->pos); 
    703738 
    704     ok = (e != NULL); 
     739    ok = (e != NULL && e->index != -2); 
    705740 
    706741    if (string != NULL) 
    707742        *string = ok ? e->text : NULL; 
    listbox_get_nth_item (const WListbox * l, int pos) 
    720755        GList *item; 
    721756 
    722757        item = g_queue_peek_nth_link (l->list, (guint) pos); 
    723         if (item != NULL) 
     758        if (item != NULL && LENTRY (item->data)->index != -2) 
    724759            return LENTRY (item->data); 
    725760    } 
    726761 
    listbox_remove_list (WListbox * l) 
    802837 
    803838/* --------------------------------------------------------------------------------------------- */ 
    804839 
     840/* 
     841 * Initializes the listbox elements with their position index. This allows to alter (filter, in 
     842 * particular) the listbox elements order and still get the original index (when selecting an 
     843 * element). 
     844 */ 
     845void 
     846listbox_init_indices (WListbox * l) 
     847{ 
     848    int index = 0; 
     849    g_queue_foreach (l->list, listbox_foreach_apply_index, &index); 
     850} 
     851 
     852/* --------------------------------------------------------------------------------------------- */ 
     853 
    805854char * 
    806855listbox_add_item (WListbox * l, listbox_append_t pos, int hotkey, const char *text, void *data, 
    807856                  gboolean free_data) 
    listbox_add_item (WListbox * l, listbox_append_t pos, int hotkey, const char *te 
    815864        return NULL; 
    816865 
    817866    entry = g_new (WLEntry, 1); 
     867    entry->index = -1;          /* Will be initialized when switching to the filter state */ 
    818868    entry->text = g_strdup (text); 
     869    entry->free_text = 1; 
    819870    entry->data = data; 
    820871    entry->free_data = free_data; 
    821872    entry->hotkey = hotkey; 
  • lib/widget/listbox.h

    diff --git a/lib/widget/listbox.h b/lib/widget/listbox.h
    index 8b2236eff..263d2c06e 100644
    a b typedef lcback_ret_t (*lcback_fn) (struct WListbox * l); 
    3535 
    3636typedef struct WLEntry 
    3737{ 
     38    int index;                  /* The location in the list (used when it's filtered) */ 
    3839    char *text;                 /* Text to display */ 
     40    gboolean free_text;         /* Whether to free the text on entry's removal */ 
    3941    int hotkey; 
    4042    void *data;                 /* Client information */ 
    4143    gboolean free_data;         /* Whether to free the data on entry's removal */ 
    typedef struct WListbox 
    4648    Widget widget; 
    4749    GQueue *list;               /* Pointer to the list of WLEntry */ 
    4850    int pos;                    /* The current element displayed */ 
     51    int virtual_pos;            /* The initial index of the current element, works also for filtered listbox */ 
    4952    int top;                    /* The first element displayed */ 
    5053    gboolean allow_duplicates;  /* Do we allow duplicates on the list? */ 
    5154    gboolean scrollbar;         /* Draw a scrollbar? */ 
    extern const global_keymap_t *listbox_map; 
    6063 
    6164/*** declarations of public functions ************************************************************/ 
    6265 
     66void listbox_init (WListbox * l, int y, int x, int height, int width, gboolean deletable, 
     67                   lcback_fn callback); 
    6368WListbox *listbox_new (int y, int x, int height, int width, gboolean deletable, lcback_fn callback); 
     69cb_ret_t listbox_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data); 
     70 
    6471int listbox_search_text (WListbox * l, const char *text); 
    6572int listbox_search_data (WListbox * l, const void *data); 
    6673void listbox_select_first (WListbox * l); 
    void listbox_remove_current (WListbox * l); 
    7481gboolean listbox_is_empty (const WListbox * l); 
    7582void listbox_set_list (WListbox * l, GQueue * list); 
    7683void listbox_remove_list (WListbox * l); 
     84void listbox_init_indices (WListbox * l); 
    7785char *listbox_add_item (WListbox * l, listbox_append_t pos, int hotkey, const char *text, 
    7886                        void *data, gboolean free_data); 
    7987 
  • lib/widget/widget-common.c

    diff --git a/lib/widget/widget-common.c b/lib/widget/widget-common.c
    index e2fcd1222..8dd4a0d30 100644
    a b widget_init (Widget * w, int y, int x, int lines, int cols, 
    338338    w->find_by_type = widget_default_find_by_type; 
    339339    w->find_by_id = widget_default_find_by_id; 
    340340 
     341    w->pre_unlink_func = NULL; 
     342 
    341343    w->set_state = widget_default_set_state; 
    342344    w->get_colors = widget_default_get_colors; 
    343345} 
  • lib/widget/widget-common.h

    diff --git a/lib/widget/widget-common.h b/lib/widget/widget-common.h
    index a20bcd671..28abfba39 100644
    a b typedef enum 
    4242    MSG_POST_KEY,               /* The key has been handled */ 
    4343    MSG_ACTION,                 /* Send to widget to handle command */ 
    4444    MSG_NOTIFY,                 /* Typically sent to dialog to inform it of state-change 
    45                                  * of listboxes, check- and radiobuttons. */ 
     45                                 * of listboxes, check- and radiobuttons. Also from input 
     46                                 * to paired listbox when query of MultiSearch changes. */ 
    4647    MSG_CURSOR,                 /* Sent to widget to position the cursor */ 
    4748    MSG_IDLE,                   /* The idle state is active */ 
    4849    MSG_RESIZE,                 /* Screen size has changed */ 
    typedef enum 
    8889    WST_CONSTRUCT = (1 << 15),  /* Widget has been constructed but not run yet */ 
    8990    WST_ACTIVE = (1 << 16),     /* Dialog is visible and active */ 
    9091    WST_SUSPENDED = (1 << 17),  /* Dialog is suspended */ 
    91     WST_CLOSED = (1 << 18)      /* Dialog is closed */ 
     92    WST_CLOSED = (1 << 18),     /* Dialog is closed */ 
     93 
     94    WST_FILTER = (1 << 19)      /* Listbox is filtering its contents */ 
    9295} widget_state_t; 
    9396 
    9497/* Flags for widget repositioning on dialog resize */ 
    typedef cb_ret_t (*widget_cb_fn) (Widget * widget, Widget * sender, widget_msg_t 
    125128typedef void (*widget_mouse_cb_fn) (Widget * w, mouse_msg_t msg, mouse_event_t * event); 
    126129/* translate mouse event and process it */ 
    127130typedef int (*widget_mouse_handle_fn) (Widget * w, Gpm_Event * event); 
     131/* Pre unlinking (removing from a WGroup) callback. */ 
     132typedef void (*pre_widget_unlink_cb) (Widget * w); 
    128133 
    129134/* Every Widget must have this as its first element */ 
    130135struct Widget 
    struct Widget 
    165170    cb_ret_t (*set_state) (Widget * w, widget_state_t state, gboolean enable); 
    166171    /* *INDENT-ON* */ 
    167172 
     173    pre_widget_unlink_cb pre_unlink_func;       /* a function invoked right before removing from a WGroup by 
     174                                                 * group_remove_widget; it can unregister any events, which 
     175                                                 * is an operation that depends on the `event_group` field of 
     176                                                 * the group, so it cannot be done «after» widget has been 
     177                                                 * removed from it (i.e.: when w.owner has been set to 0) */ 
     178 
    168179    const int *(*get_colors) (const Widget * w); 
    169180}; 
    170181 
  • src/editor/choosesyntax.c

    diff --git a/src/editor/choosesyntax.c b/src/editor/choosesyntax.c
    index 09b6d75d5..71ec44e12 100644
    a b exec_edit_syntax_dialog (const GPtrArray * names, const char *current_syntax) 
    8484        name = g_ptr_array_index (names, i); 
    8585        LISTBOX_APPEND_TEXT (syntaxlist, 0, name, NULL, FALSE); 
    8686        if (current_syntax != NULL && strcmp (name, current_syntax) == 0) 
    87             listbox_select_entry (syntaxlist->list, i + N_DFLT_ENTRIES); 
     87            listbox_select_entry (LISTBOX (syntaxlist->list), i + N_DFLT_ENTRIES); 
    8888    } 
    8989 
    9090    return run_listbox (syntaxlist); 
  • src/editor/editcmd_dialogs.c

    diff --git a/src/editor/editcmd_dialogs.c b/src/editor/editcmd_dialogs.c
    index 8b3634f23..2bfb71900 100644
    a b editcmd_dialog_completion_show (const WEdit * edit, int max_len, GString ** comp 
    351351    int start_x, start_y, offset, i; 
    352352    char *curr = NULL; 
    353353    WDialog *compl_dlg; 
    354     WListbox *compl_list; 
     354    WFilteringListbox *compl_list; 
     355    WListbox *lw; 
    355356    int compl_dlg_h;            /* completion dialog height */ 
    356357    int compl_dlg_w;            /* completion dialog width */ 
    357358 
    editcmd_dialog_completion_show (const WEdit * edit, int max_len, GString ** comp 
    384385                    dialog_colors, NULL, NULL, "[Completion]", NULL); 
    385386 
    386387    /* create the listbox */ 
    387     compl_list = listbox_new (1, 1, compl_dlg_h - 2, compl_dlg_w - 2, FALSE, NULL); 
     388    compl_list = filtering_listbox_new (1, 1, compl_dlg_h - 2, compl_dlg_w - 2, FALSE, NULL, 
     389                                        FILT_LIST_DIALOG_AUTO_RESIZE); 
     390 
     391    /* Save WListbox pointer for convenience. */ 
     392    lw = LISTBOX (compl_list); 
    388393 
    389394    /* add the dialog */ 
    390395    group_add_widget (GROUP (compl_dlg), compl_list); 
    391396 
    392397    /* fill the listbox with the completions */ 
    393398    for (i = num_compl - 1; i >= 0; i--)        /* reverse order */ 
    394         listbox_add_item (compl_list, LISTBOX_APPEND_AT_END, 0, (char *) compl[i]->str, NULL, 
    395                           FALSE); 
     399        listbox_add_item (lw, LISTBOX_APPEND_AT_END, 0, (char *) compl[i]->str, NULL, FALSE); 
    396400 
    397401    /* pop up the dialog and apply the chosen completion */ 
    398402    if (dlg_run (compl_dlg) == B_ENTER) 
    399403    { 
    400         listbox_get_current (compl_list, &curr, NULL); 
     404        listbox_get_current (lw, &curr, NULL); 
    401405        curr = g_strdup (curr); 
    402406    } 
    403407 
  • src/editor/editoptions.c

    diff --git a/src/editor/editoptions.c b/src/editor/editoptions.c
    index bbd4d7521..77a793862 100644
    a b edit_options_dialog (WDialog * h) 
    175175                    QUICK_CHECKBOX (N_("Cursor be&yond end of line"), &option_cursor_beyond_eol, 
    176176                                     NULL), 
    177177                    QUICK_CHECKBOX (N_("&Group undo"), &option_group_undo, NULL), 
     178                    QUICK_CHECKBOX (N_("Default use MultiS&earch"), &option_multisearch, 
     179                                     NULL), 
    178180                    QUICK_LABELED_INPUT (N_("Word wrap line length:"), input_label_left, wrap_length, 
    179181                                         "edit-word-wrap", &p, NULL, FALSE, FALSE, INPUT_COMPLETE_NONE), 
    180182                QUICK_STOP_GROUPBOX, 
  • src/editor/editwidget.c

    diff --git a/src/editor/editwidget.c b/src/editor/editwidget.c
    index 18ac00e66..f1989114a 100644
    a b edit_window_list (const WDialog * h) 
    302302    Listbox *listbox; 
    303303    GList *w; 
    304304    WEdit *selected; 
     305    WListbox *lw; 
    305306    int i = 0; 
    306307 
    307308    lines = MIN ((size_t) (LINES * 2 / 3), dlg_num); 
    edit_window_list (const WDialog * h) 
    309310 
    310311    listbox = create_listbox_window (lines, cols, _("Open files"), "[Open files]"); 
    311312 
     313    /* Convenience variable. */ 
     314    lw = LISTBOX (listbox->list); 
     315 
    312316    for (w = g->widgets; w != NULL; w = g_list_next (w)) 
    313317        if (edit_widget_is_editor (CONST_WIDGET (w->data))) 
    314318        { 
    edit_window_list (const WDialog * h) 
    322326                    g_strdup_printf ("%c%s", e->modified ? '*' : ' ', 
    323327                                     vfs_path_as_str (e->filename_vpath)); 
    324328 
    325             listbox_add_item (listbox->list, LISTBOX_APPEND_AT_END, get_hotkey (i++), 
    326                               str_term_trim (fname, WIDGET (listbox->list)->cols - 2), e, FALSE); 
     329            listbox_add_item (lw, LISTBOX_APPEND_AT_END, get_hotkey (i++), 
     330                              str_term_trim (fname, WIDGET (lw)->cols - 2), e, FALSE); 
    327331            g_free (fname); 
    328332        } 
    329333 
  • src/file_history.c

    diff --git a/src/file_history.c b/src/file_history.c
    index 4304655aa..e5751ab8a 100644
    a b file_history_create_item (history_descriptor_t * hd, void *data) 
    155155    width = str_term_width1 (fhd->file_name); 
    156156    hd->max_width = MAX (width, hd->max_width); 
    157157 
    158     listbox_add_item (hd->listbox, LISTBOX_APPEND_AT_END, 0, fhd->file_name, fhd->file_pos, TRUE); 
     158    listbox_add_item (LISTBOX (hd->listbox), LISTBOX_APPEND_AT_END, 0, fhd->file_name, 
     159                      fhd->file_pos, TRUE); 
    159160    /* fhd->file_pos is not copied, NULLize it to prevent double free */ 
    160161    fhd->file_pos = NULL; 
    161162} 
  • src/filemanager/boxes.c

    diff --git a/src/filemanager/boxes.c b/src/filemanager/boxes.c
    index ed16d04dd..218736206 100644
    a b configure_box (void) 
    571571                QUICK_START_GROUPBOX (N_("Other options")), 
    572572                    QUICK_CHECKBOX (N_("Use internal edi&t"), &use_internal_edit, NULL), 
    573573                    QUICK_CHECKBOX (N_("Use internal vie&w"), &use_internal_view, NULL), 
     574                    QUICK_CHECKBOX (N_("Default use MultiSearch"), &option_multisearch, NULL), 
    574575                    QUICK_CHECKBOX (N_("A&sk new file name"), 
    575576                                    &editor_ask_filename_before_edit, NULL), 
    576577                    QUICK_CHECKBOX (N_("Auto m&enus"), &auto_menu, NULL), 
  • src/keybind-defaults.c

    diff --git a/src/keybind-defaults.c b/src/keybind-defaults.c
    index 7b87c2f5a..2972e5bbf 100644
    a b static const global_keymap_ini_t default_listbox_keymap[] = { 
    293293    {"Bottom", "end; alt-gt; c1"}, 
    294294    {"PageUp", "pgup; alt-v"}, 
    295295    {"PageDown", "pgdn; ctrl-v"}, 
    296     {"Delete", "delete; d"}, 
    297     {"Clear", "shift-delete; shift-d"}, 
     296    {"Delete", "delete"}, 
     297    {"Clear", "shift-delete"}, 
    298298    {"View", "f3"}, 
    299299    {"Edit", "f4"}, 
     300    {"MultiSearch", "alt-space; ctrl-space"}, 
    300301    {"Enter", "enter"}, 
    301302    {NULL, NULL} 
    302303}; 
  • src/selcodepage.c

    diff --git a/src/selcodepage.c b/src/selcodepage.c
    index eba9d25bb..9ce48325b 100644
    a b select_charset (int center_y, int center_x, int current_charset, gboolean seldis 
    107107        ? ((current_charset < 0) ? codepages->len : (size_t) current_charset) 
    108108        : ((size_t) current_charset + 1); 
    109109 
    110     listbox_select_entry (listbox->list, i); 
     110    listbox_select_entry (LISTBOX (listbox->list), i); 
    111111 
    112112    listbox_result = run_listbox (listbox); 
    113113 
  • src/setup.c

    diff --git a/src/setup.c b/src/setup.c
    index 77c07649d..b539e5014 100644
    a b gboolean drop_menus = FALSE; 
    113113   are tagged files */ 
    114114gboolean confirm_view_dir = FALSE; 
    115115 
     116/* Should MultiSearch listbox grepping be enabled by default on all lists */ 
     117gboolean option_multisearch = FALSE; 
     118 
    116119/* Ask file name before start the editor */ 
    117120gboolean editor_ask_filename_before_edit = FALSE; 
    118121 
    static const struct 
    295298    { "use_internal_view", &use_internal_view }, 
    296299    { "use_internal_edit", &use_internal_edit }, 
    297300    { "clear_before_exec", &clear_before_exec }, 
     301    { "multi_search_active_by_default", &option_multisearch }, 
    298302    { "confirm_delete", &confirm_delete }, 
    299303    { "confirm_overwrite", &confirm_overwrite }, 
    300304    { "confirm_execute", &confirm_execute }, 
  • src/setup.h

    diff --git a/src/setup.h b/src/setup.h
    index 5a430a6c8..de49abbb2 100644
    a b extern gboolean auto_fill_mkdir_name; 
    9898extern gboolean output_starts_shell; 
    9999extern gboolean use_file_to_check_type; 
    100100extern gboolean file_op_compute_totals; 
     101extern gboolean option_multisearch; 
    101102extern gboolean editor_ask_filename_before_edit; 
    102103 
    103104extern panels_options_t panels_options; 
  • src/usermenu.c

    diff --git a/src/usermenu.c b/src/usermenu.c
    index 1fecbeaac..ba10634ab 100644
    a b user_menu_cmd (const WEdit * edit_widget, const char *menu_file, int selected_en 
    11221122                                     extract_line (p, p + MAX_ENTRY_LEN), p, FALSE); 
    11231123            } 
    11241124            /* Select the default entry */ 
    1125             listbox_select_entry (listbox->list, selected); 
     1125            listbox_select_entry (LISTBOX (listbox->list), selected); 
    11261126 
    11271127            selected = run_listbox (listbox); 
    11281128        }