PolytreeDE/rofi
1
0
Fork 0
mirror of https://github.com/davatorium/rofi.git synced 2024-11-18 13:54:36 -05:00
Code Releases Activity
rofi/source/modes/dmenu.c
Dave Davenport f088d75ee4 Cleanup some duplicate checks.
2022-03-15 01:00:56 +01:00

827 lines
27 KiB
C
Raw Blame History

/*
* rofi
*
* MIT/X11 License
* Copyright © 2013-2022 Qball Cow <qball@gmpclient.org>
*
* 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.
*
*/
/** The log domain of this dialog. */
#define G_LOG_DOMAIN "Modes.DMenu"
#include "modes/dmenu.h"
#include "helper.h"
#include "rofi-icon-fetcher.h"
#include "rofi.h"
#include "settings.h"
#include "view.h"
#include "widgets/textbox.h"
#include "xrmoptions.h"
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <gio/gio.h>
#include <gio/gunixinputstream.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "modes/dmenuscriptshared.h"
static int dmenu_mode_init(Mode *sw);
static int dmenu_token_match(const Mode *sw, rofi_int_matcher **tokens,
unsigned int index);
static cairo_surface_t *dmenu_get_icon(const Mode *sw,
unsigned int selected_line, int height);
static char *dmenu_get_message(const Mode *sw);
static inline unsigned int bitget(uint32_t *array, unsigned int index) {
uint32_t bit = index % 32;
uint32_t val = array[index / 32];
return (val >> bit) & 1;
}
static inline void bittoggle(uint32_t *array, unsigned int index) {
uint32_t bit = index % 32;
uint32_t *v = &array[index / 32];
*v ^= 1 << bit;
}
typedef struct {
/** Settings */
// Separator.
char separator;
unsigned int selected_line;
char *message;
char *format;
struct rofi_range_pair *urgent_list;
unsigned int num_urgent_list;
struct rofi_range_pair *active_list;
unsigned int num_active_list;
uint32_t *selected_list;
unsigned int num_selected_list;
unsigned int do_markup;
// List with entries.
DmenuScriptEntry *cmd_list;
unsigned int cmd_list_real_length;
unsigned int cmd_list_length;
unsigned int only_selected;
unsigned int selected_count;
gchar **columns;
gchar *column_separator;
gboolean multi_select;
GCancellable *cancel;
gulong cancel_source;
GInputStream *input_stream;
GDataInputStream *data_input_stream;
} DmenuModePrivateData;
static void async_close_callback(GObject *source_object, GAsyncResult *res,
G_GNUC_UNUSED gpointer user_data) {
g_input_stream_close_finish(G_INPUT_STREAM(source_object), res, NULL);
g_debug("Closing data stream.");
}
static void read_add(DmenuModePrivateData *pd, char *data, gsize len) {
gsize data_len = len;
if ((pd->cmd_list_length + 2) > pd->cmd_list_real_length) {
pd->cmd_list_real_length = MAX(pd->cmd_list_real_length * 2, 512);
pd->cmd_list = g_realloc(pd->cmd_list, (pd->cmd_list_real_length) *
sizeof(DmenuScriptEntry));
}
// Init.
pd->cmd_list[pd->cmd_list_length].icon_fetch_uid = 0;
pd->cmd_list[pd->cmd_list_length].icon_name = NULL;
pd->cmd_list[pd->cmd_list_length].meta = NULL;
pd->cmd_list[pd->cmd_list_length].info = NULL;
pd->cmd_list[pd->cmd_list_length].nonselectable = FALSE;
char *end = data;
while (end < data + len && *end != '\0') {
end++;
}
if (end != data + len) {
data_len = end - data;
dmenuscript_parse_entry_extras(NULL, &(pd->cmd_list[pd->cmd_list_length]),
end + 1, len - data_len);
}
char *utfstr = rofi_force_utf8(data, data_len);
pd->cmd_list[pd->cmd_list_length].entry = utfstr;
pd->cmd_list[pd->cmd_list_length + 1].entry = NULL;
pd->cmd_list_length++;
}
static void async_read_callback(GObject *source_object, GAsyncResult *res,
gpointer user_data) {
GDataInputStream *stream = (GDataInputStream *)source_object;
DmenuModePrivateData *pd = (DmenuModePrivateData *)user_data;
gsize len;
char *data = g_data_input_stream_read_upto_finish(stream, res, &len, NULL);
if (data != NULL) {
// Absorb separator, already in buffer so should not block.
g_data_input_stream_read_byte(stream, NULL, NULL);
read_add(pd, data, len);
g_free(data);
rofi_view_reload();
g_data_input_stream_read_upto_async(pd->data_input_stream, &(pd->separator),
1, G_PRIORITY_LOW, pd->cancel,
async_read_callback, pd);
return;
} else {
GError *error = NULL;
// Absorb separator, already in buffer so should not block.
// If error == NULL end of stream..
g_data_input_stream_read_byte(stream, NULL, &error);
if (error == NULL) {
// Add empty line.
read_add(pd, "", 0);
rofi_view_reload();
g_data_input_stream_read_upto_async(pd->data_input_stream,
&(pd->separator), 1, G_PRIORITY_LOW,
pd->cancel, async_read_callback, pd);
return;
}
g_error_free(error);
}
if (!g_cancellable_is_cancelled(pd->cancel)) {
// Hack, don't use get active.
g_debug("Clearing overlay");
rofi_view_set_overlay(rofi_view_get_active(), NULL);
g_input_stream_close_async(G_INPUT_STREAM(stream), G_PRIORITY_LOW,
pd->cancel, async_close_callback, pd);
}
}
static void async_read_cancel(G_GNUC_UNUSED GCancellable *cancel,
G_GNUC_UNUSED gpointer data) {
g_debug("Cancelled the async read.");
}
static int get_dmenu_async(DmenuModePrivateData *pd, int sync_pre_read) {
while (sync_pre_read--) {
gsize len = 0;
char *data = g_data_input_stream_read_upto(
pd->data_input_stream, &(pd->separator), 1, &len, NULL, NULL);
if (data == NULL) {
g_input_stream_close_async(G_INPUT_STREAM(pd->input_stream),
G_PRIORITY_LOW, pd->cancel,
async_close_callback, pd);
return FALSE;
}
g_data_input_stream_read_byte(pd->data_input_stream, NULL, NULL);
read_add(pd, data, len);
g_free(data);
}
g_data_input_stream_read_upto_async(pd->data_input_stream, &(pd->separator),
1, G_PRIORITY_LOW, pd->cancel,
async_read_callback, pd);
return TRUE;
}
static void get_dmenu_sync(DmenuModePrivateData *pd) {
while (TRUE) {
gsize len = 0;
char *data = g_data_input_stream_read_upto(
pd->data_input_stream, &(pd->separator), 1, &len, NULL, NULL);
if (data == NULL) {
break;
}
g_data_input_stream_read_byte(pd->data_input_stream, NULL, NULL);
read_add(pd, data, len);
g_free(data);
}
g_input_stream_close_async(G_INPUT_STREAM(pd->input_stream), G_PRIORITY_LOW,
pd->cancel, async_close_callback, pd);
}
static unsigned int dmenu_mode_get_num_entries(const Mode *sw) {
const DmenuModePrivateData *rmpd =
(const DmenuModePrivateData *)mode_get_private_data(sw);
return rmpd->cmd_list_length;
}
static gchar *dmenu_format_output_string(const DmenuModePrivateData *pd,
const char *input) {
if (pd->columns == NULL) {
return g_strdup(input);
}
char *retv = NULL;
char **splitted =
g_regex_split_simple(pd->column_separator, input, G_REGEX_CASELESS, 00);
uint32_t ns = 0;
for (; splitted && splitted[ns]; ns++) {
;
}
GString *str_retv = g_string_new("");
for (uint32_t i = 0; pd->columns && pd->columns[i]; i++) {
unsigned int index =
(unsigned int)g_ascii_strtoull(pd->columns[i], NULL, 10);
if (index <= ns && index > 0) {
if (index == 1) {
g_string_append(str_retv, splitted[index - 1]);
} else {
g_string_append_c(str_retv, '\t');
g_string_append(str_retv, splitted[index - 1]);
}
}
}
g_strfreev(splitted);
retv = str_retv->str;
g_string_free(str_retv, FALSE);
return retv;
}
static inline unsigned int get_index(unsigned int length, int index) {
if (index >= 0) {
return index;
}
if (((unsigned int)-index) <= length) {
return length + index;
}
// Out of range.
return UINT_MAX;
}
static char *get_display_data(const Mode *data, unsigned int index, int *state,
G_GNUC_UNUSED GList **list, int get_entry) {
Mode *sw = (Mode *)data;
DmenuModePrivateData *pd = (DmenuModePrivateData *)mode_get_private_data(sw);
DmenuScriptEntry *retv = (DmenuScriptEntry *)pd->cmd_list;
for (unsigned int i = 0; i < pd->num_active_list; i++) {
unsigned int start =
get_index(pd->cmd_list_length, pd->active_list[i].start);
unsigned int stop = get_index(pd->cmd_list_length, pd->active_list[i].stop);
if (index >= start && index <= stop) {
*state |= ACTIVE;
}
}
for (unsigned int i = 0; i < pd->num_urgent_list; i++) {
unsigned int start =
get_index(pd->cmd_list_length, pd->urgent_list[i].start);
unsigned int stop = get_index(pd->cmd_list_length, pd->urgent_list[i].stop);
if (index >= start && index <= stop) {
*state |= URGENT;
}
}
if (pd->selected_list && bitget(pd->selected_list, index) == TRUE) {
*state |= SELECTED;
}
if (pd->do_markup) {
*state |= MARKUP;
}
return get_entry ? dmenu_format_output_string(pd, retv[index].entry) : NULL;
}
static void dmenu_mode_free(Mode *sw) {
if (mode_get_private_data(sw) == NULL) {
return;
}
DmenuModePrivateData *pd = (DmenuModePrivateData *)mode_get_private_data(sw);
if (pd != NULL) {
if (pd->cancel) {
// If open, cancel reads.
if (pd->input_stream && !g_input_stream_is_closed(pd->input_stream)) {
g_cancellable_cancel(pd->cancel);
}
// This blocks until cancel is done.
g_cancellable_disconnect(pd->cancel, pd->cancel_source);
if (pd->input_stream) {
// Should close the stream if not yet done.
g_object_unref(pd->data_input_stream);
g_object_unref(pd->input_stream);
}
g_object_unref(pd->cancel);
}
for (size_t i = 0; i < pd->cmd_list_length; i++) {
if (pd->cmd_list[i].entry) {
g_free(pd->cmd_list[i].entry);
g_free(pd->cmd_list[i].icon_name);
g_free(pd->cmd_list[i].meta);
g_free(pd->cmd_list[i].info);
}
}
g_free(pd->cmd_list);
g_free(pd->urgent_list);
g_free(pd->active_list);
g_free(pd->selected_list);
g_free(pd);
mode_set_private_data(sw, NULL);
}
}
#include "mode-private.h"
/** dmenu Mode object. */
Mode dmenu_mode = {.name = "dmenu",
.cfg_name_key = "display-combi",
._init = dmenu_mode_init,
._get_num_entries = dmenu_mode_get_num_entries,
._result = NULL,
._destroy = dmenu_mode_free,
._token_match = dmenu_token_match,
._get_display_value = get_display_data,
._get_icon = dmenu_get_icon,
._get_completion = NULL,
._preprocess_input = NULL,
._get_message = dmenu_get_message,
.private_data = NULL,
.free = NULL,
.display_name = "dmenu"};
static int dmenu_mode_init(Mode *sw) {
if (mode_get_private_data(sw) != NULL) {
return TRUE;
}
mode_set_private_data(sw, g_malloc0(sizeof(DmenuModePrivateData)));
DmenuModePrivateData *pd = (DmenuModePrivateData *)mode_get_private_data(sw);
pd->separator = '\n';
pd->selected_line = UINT32_MAX;
find_arg_str("-mesg", &(pd->message));
// Input data separator.
find_arg_char("-sep", &(pd->separator));
find_arg_uint("-selected-row", &(pd->selected_line));
// By default we print the unescaped line back.
pd->format = "s";
// Allow user to override the output format.
find_arg_str("-format", &(pd->format));
// Urgent.
char *str = NULL;
find_arg_str("-u", &str);
if (str != NULL) {
parse_ranges(str, &(pd->urgent_list), &(pd->num_urgent_list));
}
// Active
str = NULL;
find_arg_str("-a", &str);
if (str != NULL) {
parse_ranges(str, &(pd->active_list), &(pd->num_active_list));
}
// DMENU COMPATIBILITY
unsigned int lines = DEFAULT_MENU_LINES;
find_arg_uint("-l", &(lines));
if (lines != DEFAULT_MENU_LINES) {
Property *p = rofi_theme_property_create(P_INTEGER);
p->name = g_strdup("lines");
p->value.i = lines;
ThemeWidget *widget =
rofi_theme_find_or_create_name(rofi_theme, "listview");
GHashTable *table =
g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
(GDestroyNotify)rofi_theme_property_free);
g_hash_table_replace(table, p->name, p);
rofi_theme_widget_add_properties(widget, table);
g_hash_table_destroy(table);
}
str = NULL;
find_arg_str("-window-title", &str);
if (str) {
dmenu_mode.display_name = str;
}
/**
* Dmenu compatibility.
* `-b` put on bottom.
*/
if (find_arg("-b") >= 0) {
config.location = 6;
}
/* -i case insensitive */
config.case_sensitive = TRUE;
if (find_arg("-i") >= 0) {
config.case_sensitive = FALSE;
}
int fd = STDIN_FILENO;
str = NULL;
if (find_arg_str("-input", &str)) {
char *estr = rofi_expand_path(str);
fd = open(str, O_RDONLY);
if (fd < 0) {
char *msg = g_markup_printf_escaped(
"Failed to open file: <b>%s</b>:\n\t<i>%s</i>", estr,
g_strerror(errno));
rofi_view_error_dialog(msg, TRUE);
g_free(msg);
g_free(estr);
return TRUE;
}
g_free(estr);
}
// If input is stdin, and a tty, do not read as rofi grabs input and therefore
// blocks.
if (!(fd == STDIN_FILENO && isatty(fd) == 1)) {
pd->cancel = g_cancellable_new();
pd->cancel_source = g_cancellable_connect(
pd->cancel, G_CALLBACK(async_read_cancel), pd, NULL);
pd->input_stream = g_unix_input_stream_new(fd, fd != STDIN_FILENO);
pd->data_input_stream = g_data_input_stream_new(pd->input_stream);
}
gchar *columns = NULL;
if (find_arg_str("-display-columns", &columns)) {
pd->columns = g_strsplit(columns, ",", 0);
pd->column_separator = "\t";
find_arg_str("-display-column-separator", &pd->column_separator);
}
return TRUE;
}
static int dmenu_token_match(const Mode *sw, rofi_int_matcher **tokens,
unsigned int index) {
DmenuModePrivateData *rmpd =
(DmenuModePrivateData *)mode_get_private_data(sw);
/** Strip out the markup when matching. */
char *esc = NULL;
if (rmpd->do_markup) {
pango_parse_markup(rmpd->cmd_list[index].entry, -1, 0, NULL, &esc, NULL,
NULL);
} else {
esc = rmpd->cmd_list[index].entry;
}
if (esc) {
// int retv = helper_token_match ( tokens, esc );
int match = 1;
if (tokens) {
for (int j = 0; match && tokens[j] != NULL; j++) {
rofi_int_matcher *ftokens[2] = {tokens[j], NULL};
int test = 0;
test = helper_token_match(ftokens, esc);
if (test == tokens[j]->invert && rmpd->cmd_list[index].meta) {
test = helper_token_match(ftokens, rmpd->cmd_list[index].meta);
}
if (test == 0) {
match = 0;
}
}
}
if (rmpd->do_markup) {
g_free(esc);
}
return match;
}
return FALSE;
}
static char *dmenu_get_message(const Mode *sw) {
DmenuModePrivateData *pd = (DmenuModePrivateData *)mode_get_private_data(sw);
if (pd->message) {
return g_strdup(pd->message);
}
return NULL;
}
static cairo_surface_t *dmenu_get_icon(const Mode *sw,
unsigned int selected_line, int height) {
DmenuModePrivateData *pd = (DmenuModePrivateData *)mode_get_private_data(sw);
g_return_val_if_fail(pd->cmd_list != NULL, NULL);
DmenuScriptEntry *dr = &(pd->cmd_list[selected_line]);
if (dr->icon_name == NULL) {
return NULL;
}
if (dr->icon_fetch_uid > 0) {
return rofi_icon_fetcher_get(dr->icon_fetch_uid);
}
dr->icon_fetch_uid = rofi_icon_fetcher_query(dr->icon_name, height);
return rofi_icon_fetcher_get(dr->icon_fetch_uid);
}
static void dmenu_finish(RofiViewState *state, int retv) {
if (retv == FALSE) {
rofi_set_return_code(EXIT_FAILURE);
} else if (retv >= 10) {
rofi_set_return_code(retv);
} else {
rofi_set_return_code(EXIT_SUCCESS);
}
rofi_view_set_active(NULL);
rofi_view_free(state);
mode_destroy(&dmenu_mode);
}
static void dmenu_print_results(DmenuModePrivateData *pd, const char *input) {
DmenuScriptEntry *cmd_list = pd->cmd_list;
int seen = FALSE;
if (pd->selected_list != NULL) {
for (unsigned int st = 0; st < pd->cmd_list_length; st++) {
if (bitget(pd->selected_list, st)) {
seen = TRUE;
rofi_output_formatted_line(pd->format, cmd_list[st].entry, st, input);
}
}
}
if (!seen) {
const char *cmd = input;
if (pd->selected_line != UINT32_MAX) {
cmd = cmd_list[pd->selected_line].entry;
}
if (cmd) {
rofi_output_formatted_line(pd->format, cmd, pd->selected_line, input);
}
}
}
static void dmenu_finalize(RofiViewState *state) {
int retv = FALSE;
DmenuModePrivateData *pd =
(DmenuModePrivateData *)rofi_view_get_mode(state)->private_data;
unsigned int cmd_list_length = pd->cmd_list_length;
DmenuScriptEntry *cmd_list = pd->cmd_list;
char *input = g_strdup(rofi_view_get_user_input(state));
pd->selected_line = rofi_view_get_selected_line(state);
;
MenuReturn mretv = rofi_view_get_return_value(state);
unsigned int next_pos = rofi_view_get_next_position(state);
int restart = 0;
// Special behavior.
if (pd->only_selected) {
/**
* Select item mode.
*/
restart = 1;
// Skip if no valid item is selected.
if ((mretv & MENU_CANCEL) == MENU_CANCEL) {
// In no custom mode we allow canceling.
restart = (find_arg("-only-match") >= 0);
} else if (pd->selected_line != UINT32_MAX) {
if ((mretv & MENU_CUSTOM_ACTION) && pd->multi_select) {
restart = TRUE;
if (pd->selected_list == NULL) {
pd->selected_list =
g_malloc0(sizeof(uint32_t) * (pd->cmd_list_length / 32 + 1));
}
pd->selected_count +=
(bitget(pd->selected_list, pd->selected_line) ? (-1) : (1));
bittoggle(pd->selected_list, pd->selected_line);
// Move to next line.
pd->selected_line = MIN(next_pos, cmd_list_length - 1);
if (pd->selected_count > 0) {
char *str =
g_strdup_printf("%u/%u", pd->selected_count, pd->cmd_list_length);
rofi_view_set_overlay(state, str);
g_free(str);
} else {
rofi_view_set_overlay(state, NULL);
}
} else if ((mretv & (MENU_OK | MENU_CUSTOM_COMMAND)) &&
cmd_list[pd->selected_line].entry != NULL) {
if (cmd_list[pd->selected_line].nonselectable == TRUE) {
g_free(input);
return;
}
dmenu_print_results(pd, input);
retv = TRUE;
if ((mretv & MENU_CUSTOM_COMMAND)) {
retv = 10 + (mretv & MENU_LOWER_MASK);
}
g_free(input);
dmenu_finish(state, retv);
return;
} else {
pd->selected_line = next_pos - 1;
}
}
// Restart
rofi_view_restart(state);
rofi_view_set_selected_line(state, pd->selected_line);
if (!restart) {
dmenu_finish(state, retv);
}
return;
}
// We normally do not want to restart the loop.
restart = FALSE;
// Normal mode
if ((mretv & MENU_OK) && pd->selected_line != UINT32_MAX &&
cmd_list[pd->selected_line].entry != NULL) {
// Check if entry is non-selectable.
if (cmd_list[pd->selected_line].nonselectable == TRUE) {
g_free(input);
return;
}
if ((mretv & MENU_CUSTOM_ACTION) && pd->multi_select) {
restart = TRUE;
if (pd->selected_list == NULL) {
pd->selected_list =
g_malloc0(sizeof(uint32_t) * (pd->cmd_list_length / 32 + 1));
}
pd->selected_count +=
(bitget(pd->selected_list, pd->selected_line) ? (-1) : (1));
bittoggle(pd->selected_list, pd->selected_line);
// Move to next line.
pd->selected_line = MIN(next_pos, cmd_list_length - 1);
if (pd->selected_count > 0) {
char *str =
g_strdup_printf("%u/%u", pd->selected_count, pd->cmd_list_length);
rofi_view_set_overlay(state, str);
g_free(str);
} else {
rofi_view_set_overlay(state, NULL);
}
} else {
dmenu_print_results(pd, input);
}
retv = TRUE;
}
// Custom input
else if ((mretv & (MENU_CUSTOM_INPUT))) {
dmenu_print_results(pd, input);
retv = TRUE;
}
// Quick switch with entry selected.
else if ((mretv & MENU_CUSTOM_COMMAND)) {
dmenu_print_results(pd, input);
restart = FALSE;
retv = 10 + (mretv & MENU_LOWER_MASK);
}
g_free(input);
if (restart) {
rofi_view_restart(state);
rofi_view_set_selected_line(state, pd->selected_line);
} else {
dmenu_finish(state, retv);
}
}
int dmenu_mode_dialog(void) {
mode_init(&dmenu_mode);
MenuFlags menu_flags = MENU_NORMAL;
DmenuModePrivateData *pd = (DmenuModePrivateData *)dmenu_mode.private_data;
int async = TRUE;
// For now these only work in sync mode.
if (find_arg("-sync") >= 0 || find_arg("-dump") >= 0 ||
find_arg("-select") >= 0 || find_arg("-no-custom") >= 0 ||
find_arg("-only-match") >= 0 || config.auto_select ||
find_arg("-selected-row") >= 0) {
async = FALSE;
}
// Check if the subsystem is setup for reading, otherwise do not read.
if (pd->cancel != NULL) {
if (async) {
unsigned int pre_read = 25;
find_arg_uint("-async-pre-read", &pre_read);
async = get_dmenu_async(pd, pre_read);
} else {
get_dmenu_sync(pd);
}
}
char *input = NULL;
unsigned int cmd_list_length = pd->cmd_list_length;
DmenuScriptEntry *cmd_list = pd->cmd_list;
pd->only_selected = FALSE;
pd->multi_select = FALSE;
if (find_arg("-multi-select") >= 0) {
menu_flags = MENU_INDICATOR;
pd->multi_select = TRUE;
}
if (find_arg("-markup-rows") >= 0) {
pd->do_markup = TRUE;
}
if (find_arg("-only-match") >= 0 || find_arg("-no-custom") >= 0) {
pd->only_selected = TRUE;
if (cmd_list_length == 0) {
return TRUE;
}
}
if (config.auto_select && cmd_list_length == 1) {
rofi_output_formatted_line(pd->format, cmd_list[0].entry, 0, config.filter);
return TRUE;
}
if (find_arg("-password") >= 0) {
menu_flags |= MENU_PASSWORD;
}
/* copy filter string */
input = g_strdup(config.filter);
char *select = NULL;
find_arg_str("-select", &select);
if (select != NULL) {
rofi_int_matcher **tokens = helper_tokenize(select, config.case_sensitive);
unsigned int i = 0;
for (i = 0; i < cmd_list_length; i++) {
if (helper_token_match(tokens, cmd_list[i].entry)) {
pd->selected_line = i;
break;
}
}
helper_tokenize_free(tokens);
}
if (find_arg("-dump") >= 0) {
rofi_int_matcher **tokens = helper_tokenize(
config.filter ? config.filter : "", config.case_sensitive);
unsigned int i = 0;
for (i = 0; i < cmd_list_length; i++) {
if (tokens == NULL || helper_token_match(tokens, cmd_list[i].entry)) {
rofi_output_formatted_line(pd->format, cmd_list[i].entry, i,
config.filter);
}
}
helper_tokenize_free(tokens);
dmenu_mode_free(&dmenu_mode);
g_free(input);
return TRUE;
}
find_arg_str("-p", &(dmenu_mode.display_name));
RofiViewState *state =
rofi_view_create(&dmenu_mode, input, menu_flags, dmenu_finalize);
if (find_arg("-keep-right") >= 0) {
rofi_view_ellipsize_start(state);
}
// @TODO we should do this better.
if (async && (pd->cancel != NULL)) {
rofi_view_set_overlay(state, "Loading.. ");
}
rofi_view_set_selected_line(state, pd->selected_line);
rofi_view_set_active(state);
return FALSE;
}
void print_dmenu_options(void) {
int is_term = isatty(fileno(stdout));
print_help_msg(
"-mesg", "[string]",
"Print a small user message under the prompt (uses pango markup)", NULL,
is_term);
print_help_msg("-p", "[string]", "Prompt to display left of entry field",
NULL, is_term);
print_help_msg("-selected-row", "[integer]", "Select row", NULL, is_term);
print_help_msg("-format", "[string]", "Output format string", "s", is_term);
print_help_msg("-u", "[list]", "List of row indexes to mark urgent", NULL,
is_term);
print_help_msg("-a", "[list]", "List of row indexes to mark active", NULL,
is_term);
print_help_msg("-l", "[integer] ", "Number of rows to display", NULL,
is_term);
print_help_msg("-window-title", "[string] ", "Set the dmenu window title",
NULL, is_term);
print_help_msg("-i", "", "Set filter to be case insensitive", NULL, is_term);
print_help_msg("-only-match", "",
"Force selection to be given entry, disallow no match", NULL,
is_term);
print_help_msg("-no-custom", "", "Don't accept custom entry, allow no match",
NULL, is_term);
print_help_msg("-select", "[string]", "Select the first row that matches",
NULL, is_term);
print_help_msg("-password", "",
"Do not show what the user inputs. Show '*' instead.", NULL,
is_term);
print_help_msg("-markup-rows", "",
"Allow and render pango markup as input data.", NULL, is_term);
print_help_msg("-sep", "[char]", "Element separator.", "'\\n'", is_term);
print_help_msg("-input", "[filename]",
"Read input from file instead from standard input.", NULL,
is_term);
print_help_msg("-sync", "",
"Force dmenu to first read all input data, then show dialog.",
NULL, is_term);
print_help_msg("-async-pre-read", "[number]",
"Read several entries blocking before switching to async mode",
"25", is_term);
print_help_msg("-w", "windowid", "Position over window with X11 windowid.",
NULL, is_term);
print_help_msg("-keep-right", "", "Set ellipsize to end.", NULL, is_term);
print_help_msg("--display-columns", "", "Only show the selected columns",
NULL, is_term);
print_help_msg("--display-column-separator", "\t",
"Separator to use to split columns (regex)", NULL, is_term);
}
View git blame Copy permalink