PolytreeDE/rofi
1
0
Fork 0
mirror of https://github.com/davatorium/rofi.git synced 2025-07-31 21:59:25 -04:00
Code Releases Activity

Fix indenting and header commenting.

Browse source
This commit is contained in:
Dave Davenport 2017-01-11 09:11:19 +01:00
parent d1edf0dc08
commit bfae111579
5 changed files with 176 additions and 115 deletions
Download patch file Download diff file Expand all files Collapse all files

129
source/view.c
View file

@ -64,15 +64,25 @@
/** The Rofi View log domain */
#define LOG_DOMAIN "View"
/** Max length of input to score. */
#define FUZZY_SCORER_MAX_LENGTH 256
/** minimum score */
#define MIN_SCORE ( INT_MIN / 2 )
/** Leading gap score */
#define LEADING_GAP_SCORE -4
/** gap score */
#define GAP_SCORE -5
/** start of word score */
#define WORD_START_SCORE 50
/** non-word score */
#define NON_WORD_SCORE 40
/** CamelCase score */
#define CAMEL_SCORE ( WORD_START_SCORE + GAP_SCORE - 1 )
/** Consecutive score */
#define CONSECUTIVE_SCORE ( WORD_START_SCORE + GAP_SCORE )
/** non-start multiplier */
#define PATTERN_NON_START_MULTIPLIER 1
/** start multiplier */
#define PATTERN_START_MULTIPLIER 2
#include "xcb.h"
@ -552,59 +562,107 @@ static void rofi_view_call_thread ( gpointer data, gpointer user_data )
g_mutex_unlock ( t->mutex );
}
enum CharClass { LOWER, UPPER, DIGIT, NON_WORD };
/**
* Character classification.
*/
enum CharClass
{
/* Lower case */
LOWER,
/* Upper case */
UPPER,
/* Number */
DIGIT,
/* non word character */
NON_WORD
};
/**
* @param c The character to determine class of
*
* @returns the class of the character c.
*/
static enum CharClass rofi_scorer_get_character_class ( gunichar c )
{
if (g_unichar_islower(c))
if ( g_unichar_islower ( c ) ) {
return LOWER;
if (g_unichar_isupper(c))
}
if ( g_unichar_isupper ( c ) ) {
return UPPER;
if (g_unichar_isdigit(c))
}
if ( g_unichar_isdigit ( c ) ) {
return DIGIT;
}
return NON_WORD;
}
/**
* @param prev The previous character.
* @param curr The current character
*
* Scrore the transition.
*
* @returns score of the transition.
*/
static int rofi_scorer_get_score_for ( enum CharClass prev, enum CharClass curr )
{
if (prev == NON_WORD && curr != NON_WORD)
if ( prev == NON_WORD && curr != NON_WORD ) {
return WORD_START_SCORE;
}
if ( ( prev == LOWER && curr == UPPER ) ||
(prev != DIGIT && curr == DIGIT))
( prev != DIGIT && curr == DIGIT ) ) {
return CAMEL_SCORE;
if (curr == NON_WORD)
}
if ( curr == NON_WORD ) {
return NON_WORD_SCORE;
}
return 0;
}
/*
rofi_scorer_fuzzy_evaluate implements a global sequence alignment algorithm to find the maximum accumulated score by aligning `pattern` to `str`. It applies when `pattern` is a subsequence of `str`.
Scoring criteria
- Prefer matches at the start of a word, or the start of subwords in CamelCase/camelCase/camel123 words. See WORD_START_SCORE/CAMEL_SCORE.
- Non-word characters matter. See NON_WORD_SCORE.
- The first characters of words of `pattern` receive bonus because they usually have more significance than the rest. See PATTERN_START_MULTIPLIER/PATTERN_NON_START_MULTIPLIER.
- Superfluous characters in `str` will reduce the score (gap penalty). See GAP_SCORE.
- Prefer early occurrence of the first character. See LEADING_GAP_SCORE/GAP_SCORE.
The recurrence of the dynamic programming:
dp[i][j]: maximum accumulated score by aligning pattern[0..i] to str[0..j]
dp[0][j] = leading_gap_penalty(0, j) + score[j]
dp[i][j] = max(dp[i-1][j-1] + CONSECUTIVE_SCORE, max(dp[i-1][k] + gap_penalty(k+1, j) + score[j] : k < j))
The first dimension can be suppressed since we do not need a matching scheme, which reduces the space complexity from O(N*M) to O(M)
/**
* @param pattern The user input to match against.
* @param plen Pattern length.
* @param str The input to match against pattern.
* @param slen Lenght of str.
*
* rofi_scorer_fuzzy_evaluate implements a global sequence alignment algorithm to find the maximum accumulated score by
* aligning `pattern` to `str`. It applies when `pattern` is a subsequence of `str`.
*
* Scoring criteria
* - Prefer matches at the start of a word, or the start of subwords in CamelCase/camelCase/camel123 words. See WORD_START_SCORE/CAMEL_SCORE.
* - Non-word characters matter. See NON_WORD_SCORE.
* - The first characters of words of `pattern` receive bonus because they usually have more significance than the rest.
* See PATTERN_START_MULTIPLIER/PATTERN_NON_START_MULTIPLIER.
* - Superfluous characters in `str` will reduce the score (gap penalty). See GAP_SCORE.
* - Prefer early occurrence of the first character. See LEADING_GAP_SCORE/GAP_SCORE.
*
* The recurrence of the dynamic programming:
* dp[i][j]: maximum accumulated score by aligning pattern[0..i] to str[0..j]
* dp[0][j] = leading_gap_penalty(0, j) + score[j]
* dp[i][j] = max(dp[i-1][j-1] + CONSECUTIVE_SCORE, max(dp[i-1][k] + gap_penalty(k+1, j) + score[j] : k < j))
*
* The first dimension can be suppressed since we do not need a matching scheme, which reduces the space complexity from
* O(N*M) to O(M)
*
* @returns the sorting weight.
*/
static int rofi_scorer_fuzzy_evaluate ( const char *pattern, glong plen, const char *str, glong slen )
{
if (plen == 5)
if ( plen == 5 ) {
plen = plen;
}
glong pi, si;
gboolean pfirst = TRUE, // whether we are aligning the first character of pattern
pstart = TRUE; // whether the start of a word in pattern
int *score = g_malloc_n(slen, sizeof(int)), // score for each position
*dp = g_malloc_n(slen, sizeof(int)), // dp[i]: maximum value by aligning pattern[0..pi] to str[0..si]
uleft = 0, ulefts = 0, // uleft: value of the upper left cell; ulefts: maximum value of uleft and cells on the left. The arbitrary initial values suppress warnings.
left, lefts; // uleft & ulefts for the next row
// whether we are aligning the first character of pattern
gboolean pfirst = TRUE;
// whether the start of a word in pattern
gboolean pstart = TRUE;
// score for each position
int *score = g_malloc_n ( slen, sizeof ( int ) );
// dp[i]: maximum value by aligning pattern[0..pi] to str[0..si]
int *dp = g_malloc_n ( slen, sizeof ( int ) );
// uleft: value of the upper left cell; ulefts: maximum value of uleft and cells on the left. The arbitrary initial
// values suppress warnings.
int uleft = 0, ulefts = 0, left, lefts;
const gchar *pit = pattern, *sit;
enum CharClass prev = NON_WORD, cur;
for ( si = 0, sit = str; si < slen; si++, sit = g_utf8_next_char ( sit ) ) {
@ -631,7 +689,8 @@ static int rofi_scorer_fuzzy_evaluate(const char *pattern, glong plen, const cha
dp[si] = pfirst
? LEADING_GAP_SCORE * si + t
: MAX ( uleft + CONSECUTIVE_SCORE, ulefts + t );
} else {
}
else {
dp[si] = MIN_SCORE;
}
uleft = left;
@ -640,8 +699,9 @@ static int rofi_scorer_fuzzy_evaluate(const char *pattern, glong plen, const cha
pfirst = pstart = FALSE;
}
lefts = MIN_SCORE;
for (si = 0; si < slen; si++)
for ( si = 0; si < slen; si++ ) {
lefts = MAX ( lefts + GAP_SCORE, dp[si] );
}
g_free ( score );
g_free ( dp );
return lefts;
@ -650,7 +710,7 @@ static int rofi_scorer_fuzzy_evaluate(const char *pattern, glong plen, const cha
static void filter_elements ( thread_state *t, G_GNUC_UNUSED gpointer user_data )
{
char *pattern = NULL;
glong plen;
glong plen = 0;
if ( config.matching_method == MM_FUZZY || config.levenshtein_sort ) {
pattern = mode_preprocess_input ( t->state->sw, t->state->text->text );
plen = g_utf8_strlen ( pattern, -1 );
@ -667,7 +727,8 @@ static void filter_elements ( thread_state *t, G_GNUC_UNUSED gpointer user_data
? -MIN_SCORE
: -rofi_scorer_fuzzy_evaluate ( pattern, plen, str, slen );
g_free ( str );
} else if ( config.levenshtein_sort ) {
}
else if ( config.levenshtein_sort ) {
// This is inefficient, need to fix it.
char * str = mode_get_completion ( t->state->sw, i );
t->state->distance[i] = levenshtein ( pattern, str );