forked from RepoMirrors/bemenu
186 lines
5.2 KiB
C
186 lines
5.2 KiB
C
#include "internal.h"
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
|
|
/**
|
|
* Shrink bmItem** list pointer.
|
|
*
|
|
* Useful helper function for filter functions.
|
|
*
|
|
* @param list Pointer to pointer to list of bmItem pointers.
|
|
* @param osize Current size of the list.
|
|
* @param nsize New size the list will be shrinked to.
|
|
* @return Pointer to list of bmItem pointers.
|
|
*/
|
|
static bmItem** _bmFilterShrinkList(bmItem ***inOutList, size_t osize, size_t nsize)
|
|
{
|
|
assert(inOutList);
|
|
|
|
if (nsize == 0) {
|
|
free(*inOutList);
|
|
return (*inOutList = NULL);
|
|
}
|
|
|
|
if (nsize >= osize)
|
|
return *inOutList;
|
|
|
|
void *tmp = malloc(sizeof(bmItem*) * nsize);
|
|
if (!tmp)
|
|
return *inOutList;
|
|
|
|
memcpy(tmp, *inOutList, sizeof(bmItem*) * nsize);
|
|
free(*inOutList);
|
|
return (*inOutList = tmp);
|
|
}
|
|
|
|
/**
|
|
* Text filter tokenizer helper.
|
|
*
|
|
* @param menu bmMenu instance which filter to tokenize.
|
|
* @param outTokv char pointer reference to list of tokens, this should be freed after use.
|
|
* @param outTokc unsigned int reference to number of tokens.
|
|
* @return Pointer to buffer that contains tokenized string, this should be freed after use.
|
|
*/
|
|
static char* _bmFilterTokenize(bmMenu *menu, char ***outTokv, unsigned int *outTokc)
|
|
{
|
|
assert(menu);
|
|
assert(outTokv);
|
|
assert(outTokc);
|
|
*outTokv = NULL;
|
|
*outTokc = 0;
|
|
|
|
char **tokv = NULL, *buffer = NULL;
|
|
if (!(buffer = _bmStrdup(menu->filter)))
|
|
goto fail;
|
|
|
|
size_t pos = 0, next;
|
|
unsigned int tokc = 0, tokn = 0;
|
|
char *s = buffer, **tmp = NULL;
|
|
while ((pos = _bmStripToken(s, " ", &next)) > 0) {
|
|
if (++tokc > tokn && !(tmp = realloc(tmp, ++tokn * sizeof(char*))))
|
|
goto fail;
|
|
|
|
tmp[tokc - 1] = s;
|
|
s += next;
|
|
}
|
|
|
|
*outTokv = tmp;
|
|
*outTokc = tokc;
|
|
return buffer;
|
|
|
|
fail:
|
|
if (buffer)
|
|
free(buffer);
|
|
if (tokv)
|
|
free(tokv);
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Dmenu filterer that accepts substring function.
|
|
*
|
|
* @param menu bmMenu instance to filter.
|
|
* @param addition This will be 1, if filter is same as previous filter with something appended.
|
|
* @param fstrstr Substring function used to match items.
|
|
* @param outNmemb unsigned int reference to filtered items outNmemb.
|
|
* @return Pointer to array of bmItem pointers.
|
|
*/
|
|
bmItem** _bmFilterDmenuFun(bmMenu *menu, char addition, char* (*fstrstr)(const char *a, const char *b), int (*fstrncmp)(const char *a, const char *b, size_t len), unsigned int *outNmemb)
|
|
{
|
|
assert(menu);
|
|
assert(fstrstr);
|
|
assert(fstrncmp);
|
|
assert(outNmemb);
|
|
*outNmemb = 0;
|
|
|
|
unsigned int itemsCount;
|
|
bmItem **items;
|
|
|
|
if (addition) {
|
|
items = bmMenuGetFilteredItems(menu, &itemsCount);
|
|
} else {
|
|
items = bmMenuGetItems(menu, &itemsCount);
|
|
}
|
|
|
|
char *buffer = NULL;
|
|
bmItem **filtered = calloc(itemsCount, sizeof(bmItem*));
|
|
if (!filtered)
|
|
goto fail;
|
|
|
|
char **tokv;
|
|
unsigned int tokc;
|
|
if (!(buffer = _bmFilterTokenize(menu, &tokv, &tokc)))
|
|
goto fail;
|
|
|
|
size_t len = (tokc ? strlen(tokv[0]) : 0);
|
|
unsigned int i, f, e;
|
|
for (e = f = i = 0; i < itemsCount; ++i) {
|
|
bmItem *item = items[i];
|
|
if (!item->text && tokc != 0)
|
|
continue;
|
|
|
|
if (tokc && item->text) {
|
|
unsigned int t;
|
|
for (t = 0; t < tokc && fstrstr(item->text, tokv[t]); ++t);
|
|
if (t < tokc)
|
|
continue;
|
|
}
|
|
|
|
if (tokc && item->text && !fstrncmp(tokv[0], item->text, len + 1)) { /* exact matches */
|
|
memmove(&filtered[1], filtered, f * sizeof(bmItem*));
|
|
filtered[0] = item;
|
|
e++; /* where do exact matches end */
|
|
} else if (tokc && item->text && !fstrncmp(tokv[0], item->text, len)) { /* prefixes */
|
|
memmove(&filtered[e + 1], &filtered[e], (f - e) * sizeof(bmItem*));
|
|
filtered[e] = item;
|
|
e++; /* where do exact matches end */
|
|
} else {
|
|
filtered[f] = item;
|
|
}
|
|
f++; /* where do all matches end */
|
|
}
|
|
|
|
if (buffer)
|
|
free(buffer);
|
|
if (tokv)
|
|
free(tokv);
|
|
|
|
return _bmFilterShrinkList(&filtered, menu->items.count, (*outNmemb = f));
|
|
|
|
fail:
|
|
if (filtered)
|
|
free(filtered);
|
|
if (buffer)
|
|
free(buffer);
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Filter that mimics the vanilla dmenu filtering.
|
|
*
|
|
* @param menu bmMenu instance to filter.
|
|
* @param addition This will be 1, if filter is same as previous filter with something appended.
|
|
* @param outNmemb unsigned int reference to filtered items outNmemb.
|
|
* @return Pointer to array of bmItem pointers.
|
|
*/
|
|
bmItem** _bmFilterDmenu(bmMenu *menu, char addition, unsigned int *outNmemb)
|
|
{
|
|
return _bmFilterDmenuFun(menu, addition, strstr, strncmp, outNmemb);
|
|
}
|
|
|
|
/**
|
|
* Filter that mimics the vanilla case-insensitive dmenu filtering.
|
|
*
|
|
* @param menu bmMenu instance to filter.
|
|
* @param addition This will be 1, if filter is same as previous filter with something appended.
|
|
* @param outNmemb unsigned int reference to filtered items outNmemb.
|
|
* @return Pointer to array of bmItem pointers.
|
|
*/
|
|
bmItem** _bmFilterDmenuCaseInsensitive(bmMenu *menu, char addition, unsigned int *outNmemb)
|
|
{
|
|
return _bmFilterDmenuFun(menu, addition, _bmStrupstr, _bmStrnupcmp, outNmemb);
|
|
}
|
|
|
|
/* vim: set ts=8 sw=4 tw=0 :*/
|