rofi/source/dialogs/dmenu.c

313 lines
9.8 KiB
C
Raw Normal View History

2014-01-29 23:47:23 +00:00
/**
2014-03-01 16:27:52 +00:00
* rofi
2014-01-29 23:47:23 +00:00
*
* MIT/X11 License
2015-04-14 20:12:21 +00:00
* Copyright 2013-2015 Qball Cow <qball@gmpclient.org>
2014-01-29 23:47:23 +00:00
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
#include <config.h>
2014-01-29 23:47:23 +00:00
#include <stdio.h>
2014-02-03 21:49:07 +00:00
#include <stdlib.h>
2014-01-29 23:47:23 +00:00
#include <unistd.h>
#include <strings.h>
#include <string.h>
#include <ctype.h>
2014-03-12 07:41:38 +00:00
#include "rofi.h"
2015-03-25 07:36:19 +00:00
#include "dialogs/dmenu.h"
2014-10-19 17:42:02 +00:00
#include "helper.h"
2014-01-29 23:47:23 +00:00
static char **get_dmenu ( int *length )
2014-01-29 23:47:23 +00:00
{
2014-02-03 21:28:04 +00:00
char buffer[1024];
2014-01-29 23:47:23 +00:00
char **retv = NULL;
*length = 0;
2014-01-29 23:47:23 +00:00
2014-10-19 17:42:02 +00:00
while ( fgets_s ( buffer, 1024, stdin, (char) config.separator ) != NULL ) {
retv = g_realloc ( retv, ( ( *length ) + 2 ) * sizeof ( char* ) );
retv[( *length )] = g_strdup ( buffer );
retv[( *length ) + 1] = NULL;
2014-02-03 21:49:07 +00:00
// Filter out line-end.
if ( retv[( *length )][strlen ( buffer ) - 1] == '\n' ) {
retv[( *length )][strlen ( buffer ) - 1] = '\0';
2014-03-22 20:04:19 +00:00
}
( *length )++;
// Stop when we hit 2³¹ entries.
if ( ( *length ) == INT_MAX ) {
return retv;
}
2014-01-29 23:47:23 +00:00
}
return retv;
}
struct range_pair
{
unsigned int start;
unsigned int stop;
};
struct range_pair * urgent_list = NULL;
unsigned int num_urgent_list = 0;
struct range_pair * active_list = NULL;
unsigned int num_active_list = 0;
static void parse_pair ( char *input, struct range_pair *item )
{
int index = 0;
for ( char *token = strsep ( &input, "-" );
token != NULL;
token = strsep ( &input, "-" ) ) {
if ( index == 0 ) {
item->start = item->stop = (unsigned int) strtoul ( token, NULL, 10 );
index++;
}
else {
if ( token[0] == '\0' ) {
item->stop = 0xFFFFFFFF;
}
else{
item->stop = (unsigned int) strtoul ( token, NULL, 10 );
}
}
}
}
static void parse_ranges ( char *input, struct range_pair **list, unsigned int *length )
{
char *endp;
for ( char *token = strtok_r ( input, ",", &endp );
token != NULL;
token = strtok_r ( NULL, ",", &endp ) ) {
// Make space.
*list = g_realloc ( ( *list ), ( ( *length ) + 1 ) * sizeof ( struct range_pair ) );
// Parse a single pair.
parse_pair ( token, &( ( *list )[*length] ) );
( *length )++;
}
}
static const char *get_display_data ( unsigned int index, void *data, G_GNUC_UNUSED int *state )
{
char **retv = (char * *) data;
for ( unsigned int i = 0; i < num_active_list; i++ ) {
if ( index >= active_list[i].start && index <= active_list[i].stop ) {
*state |= ACTIVE;
}
}
for ( unsigned int i = 0; i < num_urgent_list; i++ ) {
if ( index >= urgent_list[i].start && index <= urgent_list[i].stop ) {
*state |= URGENT;
}
}
return retv[index];
}
2015-05-11 21:20:34 +00:00
/**
* @param format The format string used. See below for possible syntax.
* @param string The selected entry.
* @param selected_line The selected line index.
2015-05-16 11:58:09 +00:00
* @param filter The entered filter.
2015-05-14 17:39:30 +00:00
*
2015-05-11 21:20:34 +00:00
* Function that outputs the selected line in the user-specified format.
* Currently the following formats are supported:
* * i: Print the index (0-(N-1))
2015-05-14 17:39:30 +00:00
* * d: Print the index (1-N)
2015-05-11 21:20:34 +00:00
* * s: Print input string.
2015-05-16 11:58:09 +00:00
* * q: Print quoted input string.
* * f: Print the entered filter.
* * F: Print the entered filter, quoted
2015-05-11 21:20:34 +00:00
*
* This functions outputs the formatted string to stdout, appends a newline (\n) character and
* calls flush on the file descriptor.
*/
2015-05-16 11:58:09 +00:00
static void dmenu_output_formatted_line ( const char *format, const char *string, int selected_line, const char *filter )
2015-05-10 10:08:08 +00:00
{
for ( int i = 0; format && format[i]; i++ ) {
if ( format[i] == 'i' ) {
fprintf ( stdout, "%d", selected_line );
}
2015-05-11 21:20:34 +00:00
else if ( format[i] == 'd' ) {
2015-05-14 17:39:30 +00:00
fprintf ( stdout, "%d", ( selected_line + 1 ) );
2015-05-11 21:20:34 +00:00
}
2015-05-10 10:08:08 +00:00
else if ( format[i] == 's' ) {
fputs ( string, stdout );
}
2015-05-13 16:35:55 +00:00
else if ( format[i] == 'q' ) {
2015-05-10 10:08:08 +00:00
char *quote = g_shell_quote ( string );
fputs ( quote, stdout );
g_free ( quote );
}
2015-05-16 11:58:09 +00:00
else if ( format[i] == 'f' ) {
fputs ( filter, stdout );
}
else if ( format[i] == 'F' ) {
char *quote = g_shell_quote ( filter );
2015-05-13 16:35:55 +00:00
fputs ( quote, stdout );
g_free ( quote );
}
2015-05-10 10:08:08 +00:00
else {
fputc ( format[i], stdout );
}
}
fputc ( '\n', stdout );
fflush ( stdout );
}
2015-06-23 19:22:38 +00:00
int dmenu_switcher_dialog ( char **input )
{
char *dmenu_prompt = "dmenu ";
int selected_line = -1;
int retv = FALSE;
int length = 0;
char **list = get_dmenu ( &length );
int restart = FALSE;
char *message = NULL;
menu_match_cb filter = token_match;
find_arg_str ( "-mesg", &message );
2014-01-29 23:47:23 +00:00
2015-05-11 21:20:34 +00:00
// By default we print the unescaped line back.
2015-05-14 17:39:30 +00:00
char *format = "s";
2015-05-11 21:20:34 +00:00
// This is here for compatibility reason.
2015-05-14 17:39:30 +00:00
// Use -format 'i' instead.
2015-03-11 17:32:37 +00:00
if ( find_arg ( "-i" ) >= 0 ) {
2015-05-14 17:39:30 +00:00
format = "i";
}
2015-05-11 21:20:34 +00:00
// Allow user to override the output format.
2015-05-10 10:08:08 +00:00
find_arg_str ( "-format", &format );
// Check prompt
2015-03-11 17:32:37 +00:00
find_arg_str ( "-p", &dmenu_prompt );
find_arg_int ( "-l", &selected_line );
// Urgent.
char *str = NULL;
find_arg_str ( "-u", &str );
if ( str != NULL ) {
parse_ranges ( str, &urgent_list, &num_urgent_list );
}
// Active
str = NULL;
find_arg_str ( "-a", &str );
if ( str != NULL ) {
parse_ranges ( str, &active_list, &num_active_list );
}
int only_selected = FALSE;
2015-06-11 19:07:25 +00:00
if ( find_arg ( "-only-match" ) >= 0 || find_arg ( "-no-custom" ) >= 0 ) {
only_selected = TRUE;
if ( length == 0 ) {
return TRUE;
}
}
2015-05-16 11:58:09 +00:00
find_arg_str_alloc ( "-filter", input );
2015-06-23 19:22:38 +00:00
if ( find_arg ( "-z" ) >= 0 ) {
filter = fuzzy_token_match;
}
2015-05-18 20:38:51 +00:00
char *select = NULL;
find_arg_str ( "-select", &select );
2015-06-05 21:08:02 +00:00
if ( select != NULL ) {
2015-05-18 20:38:51 +00:00
char **tokens = tokenize ( select, config.case_sensitive );
int i = 0;
for ( i = 0; i < length; i++ ) {
if ( token_match ( tokens, list[i], config.case_sensitive, 0, NULL ) ) {
selected_line = i;
break;
}
}
g_strfreev ( tokens );
}
2014-08-01 21:29:01 +00:00
do {
2015-04-16 19:13:45 +00:00
int next_pos = selected_line;
int mretv = menu ( list, length, input, dmenu_prompt,
2015-06-23 19:22:38 +00:00
filter, NULL, &selected_line, config.levenshtein_sort, get_display_data, list, &next_pos, message );
// Special behavior.
if ( only_selected ) {
2015-05-09 12:17:27 +00:00
/**
* Select item mode.
*/
2015-06-11 18:38:48 +00:00
restart = ( find_arg ( "-only-match" ) >= 0 );
if ( ( mretv & ( MENU_OK | MENU_QUICK_SWITCH ) ) && list[selected_line] != NULL ) {
2015-05-16 11:58:09 +00:00
dmenu_output_formatted_line ( format, list[selected_line], selected_line, *input );
retv = TRUE;
if ( ( mretv & MENU_QUICK_SWITCH ) ) {
retv = 10 + ( mretv & MENU_LOWER_MASK );
}
return retv;
}
selected_line = next_pos - 1;
continue;
}
2014-08-01 21:29:01 +00:00
// We normally do not want to restart the loop.
restart = FALSE;
2015-06-09 16:10:23 +00:00
// Normal mode
if ( ( mretv & MENU_OK ) && list[selected_line] != NULL ) {
dmenu_output_formatted_line ( format, list[selected_line], selected_line, *input );
2015-03-27 19:28:53 +00:00
if ( ( mretv & MENU_SHIFT ) ) {
2014-08-01 21:29:01 +00:00
restart = TRUE;
// Move to next line.
2015-04-16 19:13:45 +00:00
selected_line = MIN ( next_pos, length - 1 );
2014-08-01 21:29:01 +00:00
}
retv = TRUE;
2014-08-01 21:29:01 +00:00
}
2015-06-09 16:14:09 +00:00
// Custom input
2015-06-09 16:10:23 +00:00
else if ( ( mretv & ( MENU_CUSTOM_INPUT ) ) ) {
dmenu_output_formatted_line ( format, *input, -1, *input );
if ( ( mretv & MENU_SHIFT ) ) {
restart = TRUE;
// Move to next line.
selected_line = MIN ( next_pos, length - 1 );
}
2015-06-09 16:10:23 +00:00
retv = TRUE;
}
// Quick switch with entry selected.
2015-06-20 13:10:02 +00:00
else if ( ( mretv & MENU_QUICK_SWITCH ) && selected_line >= 0 ) {
2015-06-09 16:10:23 +00:00
dmenu_output_formatted_line ( format, list[selected_line], selected_line, *input );
restart = FALSE;
retv = 10 + ( mretv & MENU_LOWER_MASK );
}
// Quick switch without entry selected.
else if ( ( mretv & MENU_QUICK_SWITCH ) && selected_line == -1 ) {
dmenu_output_formatted_line ( format, *input, -1, *input );
restart = FALSE;
2015-05-05 17:30:43 +00:00
retv = 10 + ( mretv & MENU_LOWER_MASK );
}
2014-08-01 21:29:01 +00:00
} while ( restart );
2014-01-30 09:02:01 +00:00
g_strfreev ( list );
g_free ( urgent_list );
g_free ( active_list );
2014-01-29 23:47:23 +00:00
return retv;
}