/*
* Copyright (C) 2019 Scoopta
* This file is part of Wofi
* Wofi is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Wofi is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Wofi. If not, see .
*/
#include
static uint64_t width, height;
static int64_t x, y;
static struct zwlr_layer_shell_v1* shell;
static GtkWidget* window, *outer_box, *scroll, *entry, *inner_box, *previous_selection = NULL;
static const gchar* filter;
static char* mode;
static time_t filter_time;
static int64_t filter_rate;
static bool allow_images, allow_markup;
static uint64_t image_size;
static char* cache_file = NULL;
struct node {
char* text, *action;
GtkContainer* container;
};
struct cache_line {
char* line;
struct wl_list link;
};
static void nop() {}
static void add_interface(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version) {
(void) data;
if(strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) {
shell = wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, version);
}
}
static void config_surface(void* data, struct zwlr_layer_surface_v1* surface, uint32_t serial, uint32_t _width, uint32_t _height) {
(void) data;
(void) _width;
(void) _height;
zwlr_layer_surface_v1_ack_configure(surface, serial);
zwlr_layer_surface_v1_set_size(surface, width, height);
zwlr_layer_surface_v1_set_keyboard_interactivity(surface, true);
if(x >= 0 && y >= 0) {
zwlr_layer_surface_v1_set_margin(surface, y, 0, 0, x);
zwlr_layer_surface_v1_set_anchor(surface, ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT);
}
}
static void get_input(GtkSearchEntry* entry, gpointer data) {
(void) data;
if(utils_get_time_millis() - filter_time > filter_rate) {
filter = gtk_entry_get_text(GTK_ENTRY(entry));
filter_time = utils_get_time_millis();
gtk_list_box_invalidate_filter(GTK_LIST_BOX(inner_box));
}
}
static void get_search(GtkSearchEntry* entry, gpointer data) {
(void) data;
filter = gtk_entry_get_text(GTK_ENTRY(entry));
gtk_list_box_invalidate_filter(GTK_LIST_BOX(inner_box));
}
static GtkWidget* create_label(char* text, char* action) {
GtkWidget* box = wofi_property_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_name(box, "unselected");
wofi_property_box_add_property(WOFI_PROPERTY_BOX(box), "action", action);
if(allow_images) {
char* tmp = strdup(text);
char* original = tmp;
char* mode = NULL;
char* filter = NULL;
size_t colon_count = utils_split(tmp, ':');
for(size_t count = 0; count < colon_count; ++count) {
if(mode == NULL) {
mode = tmp;
} else {
if(strcmp(mode, "img") == 0) {
GdkPixbuf* buf = gdk_pixbuf_new_from_file(tmp, NULL);
int width = gdk_pixbuf_get_width(buf);
int height = gdk_pixbuf_get_height(buf);
if(height > width) {
float percent = (float) image_size / height;
GdkPixbuf* tmp = gdk_pixbuf_scale_simple(buf, width * percent, image_size, GDK_INTERP_BILINEAR);
g_object_unref(buf);
buf = tmp;
} else {
float percent = (float) image_size / width;
GdkPixbuf* tmp = gdk_pixbuf_scale_simple(buf, image_size, height * percent, GDK_INTERP_BILINEAR);
g_object_unref(buf);
buf = tmp;
}
GtkWidget* img = gtk_image_new_from_pixbuf(buf);
gtk_container_add(GTK_CONTAINER(box), img);
} else if(strcmp(mode, "text") == 0) {
if(filter == NULL) {
filter = strdup(tmp);
} else {
char* tmp_filter = utils_concat(2, filter, tmp);
free(filter);
filter = tmp_filter;
}
GtkWidget* label = gtk_label_new(tmp);
gtk_label_set_use_markup(GTK_LABEL(label), allow_markup);
gtk_label_set_xalign(GTK_LABEL(label), 0);
gtk_container_add(GTK_CONTAINER(box), label);
}
mode = NULL;
}
tmp += strlen(tmp) + 1;
}
wofi_property_box_add_property(WOFI_PROPERTY_BOX(box), "filter", filter);
free(filter);
free(original);
} else {
wofi_property_box_add_property(WOFI_PROPERTY_BOX(box), "filter", text);
GtkWidget* label = gtk_label_new(text);
gtk_label_set_use_markup(GTK_LABEL(label), allow_markup);
gtk_label_set_xalign(GTK_LABEL(label), 0);
gtk_container_add(GTK_CONTAINER(box), label);
}
return box;
}
static gboolean insert_widget(gpointer data) {
struct node* node = data;
GtkWidget* box = create_label(node->text, node->action);
gtk_container_add(node->container, box);
gtk_widget_show_all(box);
free(node->text);
free(node->action);
free(node);
return FALSE;
}
static char* get_cache_path(char* mode) {
if(cache_file != NULL) {
return cache_file;
}
char* cache_path = getenv("XDG_CACHE_HOME");
if(cache_path == NULL) {
cache_path = utils_concat(3, getenv("HOME"), "/.cache/wofi-", mode);
} else {
cache_path = utils_concat(3, cache_path, "/wofi-", mode);
}
return cache_path;
}
static struct wl_list* read_cache(char* mode) {
char* cache_path = get_cache_path(mode);
struct wl_list* cache = malloc(sizeof(struct wl_list));
wl_list_init(cache);
struct wl_list lines;
wl_list_init(&lines);
if(access(cache_path, R_OK) == 0) {
FILE* file = fopen(cache_path, "r");
char* line = NULL;
size_t size = 0;
while(getline(&line, &size, file) != -1) {
struct cache_line* node = malloc(sizeof(struct cache_line));
char* lf = strchr(line, '\n');
if(lf != NULL) {
*lf = 0;
}
node->line = strdup(line);
wl_list_insert(&lines, &node->link);
}
free(line);
fclose(file);
}
while(wl_list_length(&lines) > 0) {
uint64_t largest = 0;
struct cache_line* node, *largest_node = NULL;
wl_list_for_each(node, &lines, link) {
uint64_t num = strtol(node->line, NULL, 10);
if(num > largest) {
largest = num;
largest_node = node;
}
}
wl_list_remove(&largest_node->link);
wl_list_insert(cache, &largest_node->link);
}
free(cache_path);
return cache;
}
static void* do_run(void* data) {
(void) data;
struct map* cached = map_init();
struct wl_list* cache = read_cache("run");
struct cache_line* node, *tmp;
wl_list_for_each_reverse_safe(node, tmp, cache, link) {
struct node* label = malloc(sizeof(struct node));
char* text = strrchr(node->line, '/');
char* action = strchr(node->line, ' ') + 1;
if(text == NULL) {
text = action;
} else {
++text;
}
map_put(cached, action, "true");
label->text = strdup(text);
label->action = strdup(action);
label->container = GTK_CONTAINER(inner_box);
g_idle_add(insert_widget, label);
utils_sleep_millis(1);
free(node->line);
wl_list_remove(&node->link);
free(node);
}
free(cache);
char* path = strdup(getenv("PATH"));
char* original_path = path;
size_t colon_count = utils_split(path, ':');
for(size_t count = 0; count < colon_count; ++count) {
DIR* dir = opendir(path);
if(dir == NULL) {
goto cont;
}
struct dirent* entry;
while((entry = readdir(dir)) != NULL) {
if(strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
continue;
}
char* full_path = utils_concat(3, path, "/", entry->d_name);
struct stat info;
stat(full_path, &info);
if(access(full_path, X_OK) == 0 && S_ISREG(info.st_mode) && !map_contains(cached, full_path)) {
struct node* node = malloc(sizeof(struct node));
node->text = strdup(entry->d_name);
node->action = strdup(full_path);
node->container = GTK_CONTAINER(inner_box);
g_idle_add(insert_widget, node);
utils_sleep_millis(1);
}
free(full_path);
}
closedir(dir);
cont:
path += strlen(path) + 1;
}
free(original_path);
map_free(cached);
return NULL;
}
static void* do_dmenu(void* data) {
(void) data;
char* line;
size_t size = 0;
while(getline(&line, &size, stdin) != -1) {
char* lf = strchr(line, '\n');
if(lf != NULL) {
*lf = 0;
}
struct node* node = malloc(sizeof(struct node));
node->text = strdup(line);
node->action = strdup(line);
node->container = GTK_CONTAINER(inner_box);
g_idle_add(insert_widget, node);
utils_sleep_millis(1);
}
free(line);
return NULL;
}
static void* do_drun(void* data) {
(void) data;
char* data_home = getenv("XDG_DATA_HOME");
if(data_home == NULL) {
data_home = utils_concat(2, getenv("HOME"), "/.local/share");
} else {
data_home = strdup(data_home);
}
char* data_dirs = getenv("XDG_DATA_DIRS");
if(data_dirs == NULL) {
data_dirs = "/usr/local/share:/usr/share";
}
char* dirs = utils_concat(3, data_home, ":", data_dirs);
char* original_dirs = dirs;
free(data_home);
size_t colon_count = utils_split(dirs, ':');
for(size_t count = 0; count < colon_count; ++count) {
char* app_dir = utils_concat(2, dirs, "/applications");
DIR* dir = opendir(app_dir);
if(dir == NULL) {
goto cont;
}
struct dirent* entry;
while((entry = readdir(dir)) != NULL) {
if(strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
continue;
}
char* full_path = utils_concat(3, app_dir, "/", entry->d_name);
GDesktopAppInfo* info = g_desktop_app_info_new_from_filename(full_path);
if(!G_IS_DESKTOP_APP_INFO(info) || g_desktop_app_info_get_is_hidden(info) || g_desktop_app_info_get_nodisplay(info)) {
free(full_path);
continue;
}
const char* name = g_app_info_get_display_name(G_APP_INFO(info));
if(name == NULL) {
free(full_path);
continue;
}
char* text;
GIcon* icon = g_app_info_get_icon(G_APP_INFO(info));
if(allow_images && icon != NULL) {
if(G_IS_THEMED_ICON(icon)) {
GtkIconTheme* theme = gtk_icon_theme_get_default();
const gchar* const* icon_names = g_themed_icon_get_names(G_THEMED_ICON(icon));
GtkIconInfo* info = gtk_icon_theme_choose_icon(theme, (const gchar**) icon_names, image_size, 0);
const gchar* icon_path = gtk_icon_info_get_filename(info);
text = utils_concat(4, "img:", icon_path, ":text:", name);
} else {
text = strdup(name);
}
} else {
text = strdup(name);
}
struct node* node = malloc(sizeof(struct node));
node->text = text;
node->action = strdup(full_path);
node->container = GTK_CONTAINER(inner_box);
g_idle_add(insert_widget, node);
utils_sleep_millis(1);
free(full_path);
}
closedir(dir);
cont:
dirs += strlen(dirs) + 1;
free(app_dir);
}
free(original_dirs);
return NULL;
}
static void execute_action(char* mode, const gchar* cmd) {
char* cache_path = get_cache_path(mode);
struct wl_list lines;
wl_list_init(&lines);
bool inc_count = false;
if(access(cache_path, R_OK) == 0) {
FILE* file = fopen(cache_path, "r");
char* line = NULL;
size_t size = 0;
while(getline(&line, &size, file) != -1) {
struct cache_line* node = malloc(sizeof(struct cache_line));
if(strstr(line, cmd) != NULL) {
uint64_t count = strtol(line, NULL, 10) + 1;
char num[6];
snprintf(num, 5, "%lu", count);
node->line = utils_concat(4, num, " ", cmd, "\n");
inc_count = true;
} else {
node->line = strdup(line);
}
wl_list_insert(&lines, &node->link);
}
free(line);
fclose(file);
}
if(!inc_count) {
struct cache_line* node = malloc(sizeof(struct cache_line));
node->line = utils_concat(3, "1 ", cmd, "\n");
wl_list_insert(&lines, &node->link);
}
FILE* file = fopen(cache_path, "w");
struct cache_line* node, *tmp;
wl_list_for_each_safe(node, tmp, &lines, link) {
fwrite(node->line, 1, strlen(node->line), file);
free(node->line);
wl_list_remove(&node->link);
free(node);
}
fclose(file);
free(cache_path);
if(strcmp(mode, "run") == 0) {
execlp(cmd, cmd, NULL);
fprintf(stderr, "%s cannot be executed\n", cmd);
exit(errno);
} else if(strcmp(mode, "dmenu") == 0) {
printf("%s\n", cmd);
exit(0);
} else if(strcmp(mode, "drun") == 0) {
GDesktopAppInfo* info = g_desktop_app_info_new_from_filename(cmd);
if(G_IS_DESKTOP_APP_INFO(info)) {
const char* exec = g_app_info_get_executable(G_APP_INFO(info));
execlp(exec, exec, NULL);
fprintf(stderr, "%s cannot be executed\n", exec);
exit(errno);
} else {
fprintf(stderr, "%s cannot be executed\n", cmd);
exit(1);
}
}
}
static void activate_item(GtkListBox* list_box, GtkListBoxRow* row, gpointer data) {
(void) list_box;
(void) data;
GtkWidget* box = gtk_bin_get_child(GTK_BIN(row));
execute_action(mode, wofi_property_box_get_property(WOFI_PROPERTY_BOX(box), "action"));
}
static void select_item(GtkListBox* list_box, GtkListBoxRow* row, gpointer data) {
(void) list_box;
(void) data;
if(previous_selection != NULL) {
gtk_widget_set_name(previous_selection, "unselected");
}
GtkWidget* box = gtk_bin_get_child(GTK_BIN(row));
gtk_widget_set_name(box, "selected");
previous_selection = box;
}
static void activate_search(GtkEntry* entry, gpointer data) {
(void) data;
if(strcmp(mode, "dmenu") == 0) {
execute_action(mode, gtk_entry_get_text(entry));
} else {
GtkListBoxRow* row = gtk_list_box_get_row_at_y(GTK_LIST_BOX(inner_box), 0);
GtkWidget* box = gtk_bin_get_child(GTK_BIN(row));
execute_action(mode, wofi_property_box_get_property(WOFI_PROPERTY_BOX(box), "action"));
}
}
static gboolean do_filter(GtkListBoxRow* row, gpointer data) {
(void) data;
GtkWidget* box = gtk_bin_get_child(GTK_BIN(row));
const gchar* text = wofi_property_box_get_property(WOFI_PROPERTY_BOX(box), "filter");
if(filter == NULL || strcmp(filter, "") == 0) {
return TRUE;
}
if(strcasestr(text, filter) != NULL) {
return TRUE;
}
return FALSE;
}
static gboolean key_press(GtkWidget* widget, GdkEvent* event, gpointer data) {
(void) widget;
(void) event;
(void) data;
guint code;
gdk_event_get_keyval(event, &code);
switch(code) {
case GDK_KEY_Escape:
exit(0);
break;
case GDK_KEY_Up:
case GDK_KEY_Down:
case GDK_KEY_Left:
case GDK_KEY_Right:
case GDK_KEY_Return:
break;
default:
if(!gtk_widget_has_focus(entry)) {
gtk_entry_grab_focus_without_selecting(GTK_ENTRY(entry));
}
break;
}
return FALSE;
}
void wofi_init(struct map* config) {
width = strtol(config_get(config, "width", "1000"), NULL, 10);
height = strtol(config_get(config, "height", "400"), NULL, 10);
x = strtol(config_get(config, "x", "-1"), NULL, 10);
y = strtol(config_get(config, "y", "-1"), NULL, 10);
bool normal_window = strcmp(config_get(config, "normal_window", "false"), "true") == 0;
mode = map_get(config, "mode");
char* prompt = config_get(config, "prompt", mode);
filter_rate = strtol(config_get(config, "filter_rate", "100"), NULL, 10);
filter_time = utils_get_time_millis();
allow_images = strcmp(config_get(config, "allow_images", "false"), "true") == 0;
allow_markup = strcmp(config_get(config, "allow_markup", "false"), "true") == 0;
image_size = strtol(config_get(config, "image_size", "32"), NULL, 10);
cache_file = map_get(config, "cache_file");
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_realize(window);
gtk_widget_set_name(window, "window");
gtk_window_set_default_size(GTK_WINDOW(window), width, height);
gtk_window_resize(GTK_WINDOW(window), width, height);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
if(!normal_window) {
GdkDisplay* disp = gdk_display_get_default();
struct wl_display* wl = gdk_wayland_display_get_wl_display(disp);
struct wl_registry* registry = wl_display_get_registry(wl);
struct wl_registry_listener listener = {
.global = add_interface,
.global_remove = nop
};
wl_registry_add_listener(registry, &listener, NULL);
wl_display_roundtrip(wl);
GdkWindow* gdk_win = gtk_widget_get_window(window);
gdk_wayland_window_set_use_custom_surface(gdk_win);
struct wl_surface* wl_surface = gdk_wayland_window_get_wl_surface(gdk_win);
struct zwlr_layer_surface_v1* surface = zwlr_layer_shell_v1_get_layer_surface(shell, wl_surface, NULL, ZWLR_LAYER_SHELL_V1_LAYER_TOP, "wofi");
struct zwlr_layer_surface_v1_listener* surface_listener = malloc(sizeof(struct zwlr_layer_surface_v1_listener));
surface_listener->configure = config_surface;
surface_listener->closed = nop;
zwlr_layer_surface_v1_add_listener(surface, surface_listener, NULL);
wl_surface_commit(wl_surface);
wl_display_roundtrip(wl);
}
outer_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_name(outer_box, "outer-box");
gtk_container_add(GTK_CONTAINER(window), outer_box);
entry = gtk_search_entry_new();
gtk_widget_set_name(entry, "input");
gtk_entry_set_placeholder_text(GTK_ENTRY(entry), prompt);
gtk_container_add(GTK_CONTAINER(outer_box), entry);
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_name(scroll, "scroll");
gtk_container_add(GTK_CONTAINER(outer_box), scroll);
gtk_widget_set_size_request(scroll, width, height);
inner_box = gtk_list_box_new();
gtk_widget_set_name(inner_box, "inner-box");
gtk_list_box_set_activate_on_single_click(GTK_LIST_BOX(inner_box), FALSE);
gtk_container_add(GTK_CONTAINER(scroll), inner_box);
gtk_list_box_set_filter_func(GTK_LIST_BOX(inner_box), do_filter, NULL, NULL);
g_signal_connect(entry, "changed", G_CALLBACK(get_input), NULL);
g_signal_connect(entry, "search-changed", G_CALLBACK(get_search), NULL);
g_signal_connect(inner_box, "row-activated", G_CALLBACK(activate_item), NULL);
g_signal_connect(inner_box, "row-selected", G_CALLBACK(select_item), NULL);
g_signal_connect(entry, "activate", G_CALLBACK(activate_search), NULL);
g_signal_connect(window, "key-press-event", G_CALLBACK(key_press), NULL);
pthread_t thread;
if(strcmp(mode, "run") == 0) {
pthread_create(&thread, NULL, do_run, NULL);
} else if(strcmp(mode, "dmenu") == 0) {
pthread_create(&thread, NULL, do_dmenu, NULL);
} else if(strcmp(mode, "drun") == 0) {
pthread_create(&thread, NULL, do_drun, NULL);
} else {
fprintf(stderr, "I would love to show %s but Idk what it is\n", mode);
exit(1);
}
gtk_widget_grab_focus(entry);
gtk_window_set_title(GTK_WINDOW(window), prompt);
gtk_widget_show_all(window);
}