2017-04-15 10:32:05 +00:00
|
|
|
/*
|
2014-03-01 16:27:52 +00:00
|
|
|
* rofi
|
2014-01-29 23:47:23 +00:00
|
|
|
*
|
|
|
|
* MIT/X11 License
|
2021-06-09 12:50:39 +00:00
|
|
|
* Copyright © 2013-2021 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2018-06-12 09:45:42 +00:00
|
|
|
/** The log domain of this dialog. */
|
2021-08-17 23:16:45 +00:00
|
|
|
#define G_LOG_DOMAIN "Dialogs.DMenu"
|
2017-04-15 09:58:49 +00:00
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
#include "dialogs/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"
|
2014-01-29 23:47:23 +00:00
|
|
|
#include <ctype.h>
|
2015-12-03 17:21:23 +00:00
|
|
|
#include <errno.h>
|
2021-08-17 23:16:45 +00:00
|
|
|
#include <fcntl.h>
|
2016-09-17 16:57:44 +00:00
|
|
|
#include <gio/gio.h>
|
|
|
|
#include <gio/gunixinputstream.h>
|
2021-08-17 23:16:45 +00:00
|
|
|
#include <stdint.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <strings.h>
|
2016-09-17 16:57:44 +00:00
|
|
|
#include <sys/stat.h>
|
2021-08-17 23:16:45 +00:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <unistd.h>
|
2016-09-17 16:57:44 +00:00
|
|
|
|
2019-04-02 11:51:53 +00:00
|
|
|
#include "dialogs/dmenuscriptshared.h"
|
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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;
|
2016-06-25 15:36:35 +00:00
|
|
|
}
|
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
static inline void bittoggle(uint32_t *array, unsigned int index) {
|
|
|
|
uint32_t bit = index % 32;
|
|
|
|
uint32_t *v = &array[index / 32];
|
|
|
|
*v ^= 1 << bit;
|
2016-06-25 15:36:35 +00:00
|
|
|
}
|
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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;
|
2015-09-08 19:41:54 +00:00
|
|
|
} DmenuModePrivateData;
|
2014-01-29 23:47:23 +00:00
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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.");
|
2016-09-17 16:57:44 +00:00
|
|
|
}
|
2015-10-01 10:41:44 +00:00
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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;
|
2021-09-23 08:22:19 +00:00
|
|
|
pd->cmd_list[pd->cmd_list_length].nonselectable = FALSE;
|
2021-08-17 23:16:45 +00:00
|
|
|
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++;
|
2016-09-17 17:41:24 +00:00
|
|
|
}
|
2021-08-17 23:16:45 +00:00
|
|
|
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);
|
|
|
|
}
|
2016-09-17 16:57:44 +00:00
|
|
|
}
|
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
static void async_read_cancel(G_GNUC_UNUSED GCancellable *cancel,
|
|
|
|
G_GNUC_UNUSED gpointer data) {
|
|
|
|
g_debug("Cancelled the async read.");
|
2016-09-17 16:57:44 +00:00
|
|
|
}
|
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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;
|
2014-01-29 23:47:23 +00:00
|
|
|
}
|
2021-08-17 23:16:45 +00:00
|
|
|
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);
|
2016-09-17 17:41:24 +00:00
|
|
|
}
|
2014-01-29 23:47:23 +00:00
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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;
|
2015-09-08 19:41:54 +00:00
|
|
|
}
|
2015-04-05 09:53:08 +00:00
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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++) {
|
|
|
|
;
|
|
|
|
}
|
|
|
|
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 (retv == NULL) {
|
|
|
|
retv = g_strdup(splitted[index - 1]);
|
|
|
|
} else {
|
|
|
|
gchar *t = g_strjoin("\t", retv, splitted[index - 1], NULL);
|
|
|
|
g_free(retv);
|
|
|
|
retv = t;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
g_strfreev(splitted);
|
|
|
|
return retv ? retv : g_strdup("");
|
2016-06-28 21:34:07 +00:00
|
|
|
}
|
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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;
|
2019-07-06 15:04:17 +00:00
|
|
|
}
|
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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;
|
2015-03-31 20:45:02 +00:00
|
|
|
}
|
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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);
|
|
|
|
}
|
2015-09-08 19:41:54 +00:00
|
|
|
}
|
|
|
|
|
2019-08-10 10:02:49 +00:00
|
|
|
#include "mode-private.h"
|
|
|
|
/** dmenu Mode object. */
|
2021-08-17 23:16:45 +00:00
|
|
|
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) {
|
2016-01-08 08:16:59 +00:00
|
|
|
return TRUE;
|
2021-08-17 23:16:45 +00:00
|
|
|
}
|
|
|
|
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;
|
2015-11-21 22:59:59 +00:00
|
|
|
}
|
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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 != NULL && 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);
|
2020-02-02 16:21:21 +00:00
|
|
|
}
|
2021-08-17 23:16:45 +00:00
|
|
|
|
|
|
|
if (test == 0) {
|
|
|
|
match = 0;
|
2020-02-02 16:21:21 +00:00
|
|
|
}
|
2021-08-17 23:16:45 +00:00
|
|
|
}
|
2019-08-09 17:55:34 +00:00
|
|
|
}
|
2021-08-17 23:16:45 +00:00
|
|
|
if (rmpd->do_markup) {
|
|
|
|
g_free(esc);
|
2017-03-01 08:57:54 +00:00
|
|
|
}
|
2021-08-17 23:16:45 +00:00
|
|
|
return match;
|
|
|
|
}
|
|
|
|
return FALSE;
|
2017-03-01 08:57:54 +00:00
|
|
|
}
|
2021-08-17 23:16:45 +00:00
|
|
|
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;
|
2019-04-02 11:12:42 +00:00
|
|
|
}
|
2021-08-17 23:16:45 +00:00
|
|
|
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);
|
2016-02-19 20:08:46 +00:00
|
|
|
}
|
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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);
|
2016-07-22 07:44:12 +00:00
|
|
|
}
|
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
rofi_output_formatted_line(pd->format, cmd, pd->selected_line, input);
|
|
|
|
}
|
2016-02-19 18:29:06 +00:00
|
|
|
}
|
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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));
|
2017-07-17 13:01:02 +00:00
|
|
|
}
|
2021-08-17 23:16:45 +00:00
|
|
|
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);
|
2015-05-07 19:07:15 +00:00
|
|
|
}
|
2021-08-17 23:16:45 +00:00
|
|
|
} 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;
|
2015-05-18 20:38:51 +00:00
|
|
|
}
|
2021-08-17 23:16:45 +00:00
|
|
|
dmenu_print_results(pd, input);
|
|
|
|
retv = TRUE;
|
|
|
|
if ((mretv & MENU_CUSTOM_COMMAND)) {
|
|
|
|
retv = 10 + (mretv & MENU_LOWER_MASK);
|
2015-11-27 12:14:46 +00:00
|
|
|
}
|
2021-08-17 23:16:45 +00:00
|
|
|
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);
|
2020-04-16 21:31:43 +00:00
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
2015-06-09 16:10:23 +00:00
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
int dmenu_switcher_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;
|
2014-01-29 23:47:23 +00:00
|
|
|
}
|
|
|
|
|
2021-08-17 23:16:45 +00:00
|
|
|
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);
|
2015-10-21 16:58:01 +00:00
|
|
|
}
|