mirror of
https://github.com/davatorium/rofi.git
synced 2024-11-18 13:54:36 -05:00
5133f50f30
* Add -transient-window mode This will add a new mode for the rofi window so when you run it with -transient-window instead of -normal-window it will get the currently focused window and then use that as the parent window and set itself as transient of that window. It is useful so that when you use a keyboard shortcut to start rofi it will always popup on the window you are working on and so it doesn't make you refocus/move your head on large monitors :) * Fixed other windows to be focusable in transient mode and added print_help_msg for this new -transient-window option. * Added -transient-window option to doc too
2002 lines
61 KiB
C
2002 lines
61 KiB
C
/*
|
||
* rofi
|
||
*
|
||
* MIT/X11 License
|
||
* Copyright © 2012 Sean Pringle <sean.pringle@gmail.com>
|
||
* Copyright © 2013-2023 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.
|
||
*
|
||
*/
|
||
|
||
/** Log domain for this module */
|
||
#define G_LOG_DOMAIN "X11Helper"
|
||
|
||
#include "config.h"
|
||
#ifdef XCB_IMDKIT
|
||
#include <xcb-imdkit/encoding.h>
|
||
#endif
|
||
#include <cairo-xcb.h>
|
||
#include <cairo.h>
|
||
#include <glib.h>
|
||
#include <math.h>
|
||
#include <stdint.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <unistd.h>
|
||
#include <xcb/randr.h>
|
||
#include <xcb/xcb.h>
|
||
#include <xcb/xcb_aux.h>
|
||
#include <xcb/xcb_cursor.h>
|
||
#include <xcb/xcb_ewmh.h>
|
||
#include <xcb/xinerama.h>
|
||
#include <xcb/xkb.h>
|
||
#include <xcb/xproto.h>
|
||
#include <xkbcommon/xkbcommon-x11.h>
|
||
#include <xkbcommon/xkbcommon.h>
|
||
/** Indicate that we know the startup notification api is not yet stable. */
|
||
#define SN_API_NOT_YET_FROZEN
|
||
/** This function is declared as sn_launcher_context_set_application_id but
|
||
* implemented as sn_launcher_set_application_id. Quick Fix. */
|
||
#define sn_launcher_context_set_application_id sn_launcher_set_application_id
|
||
#include "display.h"
|
||
#include "helper.h"
|
||
#include "rofi-types.h"
|
||
#include "settings.h"
|
||
#include "timings.h"
|
||
#include "xcb-internal.h"
|
||
#include "xcb.h"
|
||
#include <libsn/sn.h>
|
||
#include <stdbool.h>
|
||
|
||
#include "mode.h"
|
||
#include "modes/window.h"
|
||
|
||
#include <rofi.h>
|
||
|
||
/** Minimal randr preferred for running rofi (1.5) (Major version number) */
|
||
#define RANDR_PREF_MAJOR_VERSION 1
|
||
/** Minimal randr preferred for running rofi (1.5) (Minor version number) */
|
||
#define RANDR_PREF_MINOR_VERSION 5
|
||
|
||
/** Checks if the if x and y is inside rectangle. */
|
||
#define INTERSECT(x, y, x1, y1, w1, h1) \
|
||
((((x) >= (x1)) && ((x) < (x1 + w1))) && (((y) >= (y1)) && ((y) < (y1 + h1))))
|
||
|
||
WindowManagerQuirk current_window_manager = WM_EWHM;
|
||
|
||
/**
|
||
* Structure holding xcb objects needed to function.
|
||
*/
|
||
struct _xcb_stuff xcb_int = {.connection = NULL,
|
||
.screen = NULL,
|
||
#ifdef XCB_IMDKIT
|
||
.im = NULL,
|
||
#endif
|
||
.screen_nbr = -1,
|
||
.sndisplay = NULL,
|
||
.sncontext = NULL,
|
||
.monitors = NULL,
|
||
.clipboard = NULL};
|
||
xcb_stuff *xcb = &xcb_int;
|
||
|
||
/**
|
||
* Depth of root window.
|
||
*/
|
||
xcb_depth_t *depth = NULL;
|
||
xcb_visualtype_t *visual = NULL;
|
||
xcb_colormap_t map = XCB_COLORMAP_NONE;
|
||
/**
|
||
* Visual of the root window.
|
||
*/
|
||
static xcb_visualtype_t *root_visual = NULL;
|
||
xcb_atom_t netatoms[NUM_NETATOMS];
|
||
const char *netatom_names[] = {EWMH_ATOMS(ATOM_CHAR)};
|
||
|
||
/**
|
||
* Cached X11 cursors.
|
||
*/
|
||
xcb_cursor_t cursors[NUM_CURSORS] = {XCB_CURSOR_NONE, XCB_CURSOR_NONE,
|
||
XCB_CURSOR_NONE};
|
||
|
||
/** Mapping between theme name and system name for mouse cursor. */
|
||
const struct {
|
||
/** Theme name */
|
||
const char *css_name;
|
||
/** System name */
|
||
const char *traditional_name;
|
||
} cursor_names[] = {
|
||
{"default", "left_ptr"}, {"pointer", "hand"}, {"text", "xterm"}};
|
||
|
||
static xcb_visualtype_t *lookup_visual(xcb_screen_t *s, xcb_visualid_t visual) {
|
||
xcb_depth_iterator_t d;
|
||
d = xcb_screen_allowed_depths_iterator(s);
|
||
for (; d.rem; xcb_depth_next(&d)) {
|
||
xcb_visualtype_iterator_t v = xcb_depth_visuals_iterator(d.data);
|
||
for (; v.rem; xcb_visualtype_next(&v)) {
|
||
if (v.data->visual_id == visual) {
|
||
return v.data;
|
||
}
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* This blur function was originally created my MacSlow and published on his
|
||
* website: http://macslow.thepimp.net. I'm not entirely sure he's proud of it,
|
||
* but it has proved immeasurably useful for me. */
|
||
|
||
static uint32_t *create_kernel(double radius, double deviation,
|
||
uint32_t *sum2) {
|
||
int size = 2 * (int)(radius) + 1;
|
||
uint32_t *kernel = (uint32_t *)(g_malloc(sizeof(uint32_t) * (size + 1)));
|
||
double radiusf = fabs(radius) + 1.0;
|
||
double value = -radius;
|
||
double sum = 0.0;
|
||
int i;
|
||
|
||
if (deviation == 0.0) {
|
||
deviation = sqrt(-(radiusf * radiusf) / (2.0 * log(1.0 / 255.0)));
|
||
}
|
||
|
||
kernel[0] = size;
|
||
|
||
for (i = 0; i < size; i++) {
|
||
kernel[1 + i] = INT16_MAX / (2.506628275 * deviation) *
|
||
exp(-((value * value) / (2.0 * (deviation * deviation))));
|
||
|
||
sum += kernel[1 + i];
|
||
value += 1.0;
|
||
}
|
||
|
||
*sum2 = sum;
|
||
|
||
return kernel;
|
||
}
|
||
|
||
void cairo_image_surface_blur(cairo_surface_t *surface, double radius,
|
||
double deviation) {
|
||
uint32_t *horzBlur;
|
||
uint32_t *kernel = 0;
|
||
cairo_format_t format;
|
||
unsigned int channels;
|
||
|
||
if (cairo_surface_status(surface)) {
|
||
return;
|
||
}
|
||
|
||
uint8_t *data = cairo_image_surface_get_data(surface);
|
||
format = cairo_image_surface_get_format(surface);
|
||
const int width = cairo_image_surface_get_width(surface);
|
||
const int height = cairo_image_surface_get_height(surface);
|
||
const int stride = cairo_image_surface_get_stride(surface);
|
||
|
||
if (format == CAIRO_FORMAT_ARGB32) {
|
||
channels = 4;
|
||
} else {
|
||
return;
|
||
}
|
||
|
||
horzBlur = (uint32_t *)(g_malloc(sizeof(uint32_t) * height * stride));
|
||
TICK();
|
||
uint32_t sum = 0;
|
||
kernel = create_kernel(radius, deviation, &sum);
|
||
TICK_N("BLUR: kernel");
|
||
|
||
/* Horizontal pass. */
|
||
uint32_t *horzBlur_ptr = horzBlur;
|
||
for (int iY = 0; iY < height; iY++) {
|
||
const int iYs = iY * stride;
|
||
for (int iX = 0; iX < width; iX++) {
|
||
uint32_t red = 0;
|
||
uint32_t green = 0;
|
||
uint32_t blue = 0;
|
||
uint32_t alpha = 0;
|
||
int offset = (int)(kernel[0]) / -2;
|
||
|
||
for (int i = 0; i < (int)(kernel[0]); i++) {
|
||
int x = iX + offset;
|
||
|
||
if (x < 0 || x >= width) {
|
||
offset++;
|
||
continue;
|
||
}
|
||
|
||
uint8_t *dataPtr = &data[iYs + x * channels];
|
||
const uint32_t kernip1 = kernel[i + 1];
|
||
|
||
blue += kernip1 * dataPtr[0];
|
||
green += kernip1 * dataPtr[1];
|
||
red += kernip1 * dataPtr[2];
|
||
alpha += kernip1 * dataPtr[3];
|
||
offset++;
|
||
}
|
||
|
||
*horzBlur_ptr++ = blue / sum;
|
||
*horzBlur_ptr++ = green / sum;
|
||
*horzBlur_ptr++ = red / sum;
|
||
*horzBlur_ptr++ = alpha / sum;
|
||
}
|
||
}
|
||
TICK_N("BLUR: hori");
|
||
|
||
/* Vertical pass. */
|
||
for (int iY = 0; iY < height; iY++) {
|
||
for (int iX = 0; iX < width; iX++) {
|
||
uint32_t red = 0;
|
||
uint32_t green = 0;
|
||
uint32_t blue = 0;
|
||
uint32_t alpha = 0;
|
||
int offset = (int)(kernel[0]) / -2;
|
||
|
||
const int iXs = iX * channels;
|
||
for (int i = 0; i < (int)(kernel[0]); i++) {
|
||
int y = iY + offset;
|
||
|
||
if (y < 0 || y >= height) {
|
||
offset++;
|
||
continue;
|
||
}
|
||
|
||
uint32_t *dataPtr = &horzBlur[y * stride + iXs];
|
||
const uint32_t kernip1 = kernel[i + 1];
|
||
|
||
blue += kernip1 * dataPtr[0];
|
||
green += kernip1 * dataPtr[1];
|
||
red += kernip1 * dataPtr[2];
|
||
alpha += kernip1 * dataPtr[3];
|
||
|
||
offset++;
|
||
}
|
||
|
||
*data++ = blue / sum;
|
||
*data++ = green / sum;
|
||
*data++ = red / sum;
|
||
*data++ = alpha / sum;
|
||
}
|
||
}
|
||
TICK_N("BLUR: vert");
|
||
|
||
free(kernel);
|
||
free(horzBlur);
|
||
|
||
return;
|
||
}
|
||
|
||
cairo_surface_t *x11_helper_get_screenshot_surface_window(xcb_window_t window,
|
||
int size) {
|
||
xcb_get_geometry_cookie_t cookie;
|
||
xcb_get_geometry_reply_t *reply;
|
||
|
||
cookie = xcb_get_geometry(xcb->connection, window);
|
||
reply = xcb_get_geometry_reply(xcb->connection, cookie, NULL);
|
||
if (reply == NULL) {
|
||
return NULL;
|
||
}
|
||
|
||
xcb_get_window_attributes_cookie_t attributesCookie =
|
||
xcb_get_window_attributes(xcb->connection, window);
|
||
xcb_get_window_attributes_reply_t *attributes =
|
||
xcb_get_window_attributes_reply(xcb->connection, attributesCookie, NULL);
|
||
if (attributes == NULL || (attributes->map_state != XCB_MAP_STATE_VIEWABLE)) {
|
||
free(reply);
|
||
if (attributes) {
|
||
free(attributes);
|
||
}
|
||
return NULL;
|
||
}
|
||
// Create a cairo surface for the window.
|
||
xcb_visualtype_t *vt = lookup_visual(xcb->screen, attributes->visual);
|
||
free(attributes);
|
||
|
||
cairo_surface_t *t = cairo_xcb_surface_create(xcb->connection, window, vt,
|
||
reply->width, reply->height);
|
||
|
||
if (cairo_surface_status(t) != CAIRO_STATUS_SUCCESS) {
|
||
cairo_surface_destroy(t);
|
||
free(reply);
|
||
return NULL;
|
||
}
|
||
|
||
// Scale the image, as we don't want to keep large one around.
|
||
int max = MAX(reply->width, reply->height);
|
||
double scale = (double)size / max;
|
||
|
||
cairo_surface_t *s2 = cairo_surface_create_similar_image(
|
||
t, CAIRO_FORMAT_ARGB32, reply->width * scale, reply->height * scale);
|
||
free(reply);
|
||
|
||
if (cairo_surface_status(s2) != CAIRO_STATUS_SUCCESS) {
|
||
cairo_surface_destroy(t);
|
||
return NULL;
|
||
}
|
||
// Paint it in.
|
||
cairo_t *d = cairo_create(s2);
|
||
cairo_scale(d, scale, scale);
|
||
cairo_set_source_surface(d, t, 0, 0);
|
||
cairo_paint(d);
|
||
cairo_destroy(d);
|
||
|
||
cairo_surface_destroy(t);
|
||
return s2;
|
||
}
|
||
/**
|
||
* Holds for each supported modifier the possible modifier mask.
|
||
* Check x11_mod_masks[MODIFIER]&mask != 0 to see if MODIFIER is activated.
|
||
*/
|
||
cairo_surface_t *x11_helper_get_screenshot_surface(void) {
|
||
return cairo_xcb_surface_create(xcb->connection, xcb_stuff_get_root_window(),
|
||
root_visual, xcb->screen->width_in_pixels,
|
||
xcb->screen->height_in_pixels);
|
||
}
|
||
|
||
static xcb_pixmap_t get_root_pixmap(xcb_connection_t *c, xcb_screen_t *screen,
|
||
xcb_atom_t atom) {
|
||
xcb_get_property_cookie_t cookie;
|
||
xcb_get_property_reply_t *reply;
|
||
xcb_pixmap_t rootpixmap = XCB_NONE;
|
||
|
||
cookie = xcb_get_property(c, 0, screen->root, atom, XCB_ATOM_PIXMAP, 0, 1);
|
||
|
||
reply = xcb_get_property_reply(c, cookie, NULL);
|
||
|
||
if (reply) {
|
||
if (xcb_get_property_value_length(reply) == sizeof(xcb_pixmap_t)) {
|
||
memcpy(&rootpixmap, xcb_get_property_value(reply), sizeof(xcb_pixmap_t));
|
||
}
|
||
free(reply);
|
||
}
|
||
|
||
return rootpixmap;
|
||
}
|
||
|
||
cairo_surface_t *x11_helper_get_bg_surface(void) {
|
||
xcb_pixmap_t pm =
|
||
get_root_pixmap(xcb->connection, xcb->screen, netatoms[ESETROOT_PMAP_ID]);
|
||
if (pm == XCB_NONE) {
|
||
return NULL;
|
||
}
|
||
return cairo_xcb_surface_create(xcb->connection, pm, root_visual,
|
||
xcb->screen->width_in_pixels,
|
||
xcb->screen->height_in_pixels);
|
||
}
|
||
|
||
// retrieve a text property from a window
|
||
// technically we could use window_get_prop(), but this is better for character
|
||
// set support
|
||
char *window_get_text_prop(xcb_window_t w, xcb_atom_t atom) {
|
||
xcb_get_property_cookie_t c = xcb_get_property(
|
||
xcb->connection, 0, w, atom, XCB_GET_PROPERTY_TYPE_ANY, 0, UINT_MAX);
|
||
xcb_get_property_reply_t *r =
|
||
xcb_get_property_reply(xcb->connection, c, NULL);
|
||
if (r) {
|
||
if (xcb_get_property_value_length(r) > 0) {
|
||
char *str = NULL;
|
||
if (r->type == netatoms[UTF8_STRING]) {
|
||
str = g_strndup(xcb_get_property_value(r),
|
||
xcb_get_property_value_length(r));
|
||
} else if (r->type == netatoms[STRING]) {
|
||
str = rofi_latin_to_utf8_strdup(xcb_get_property_value(r),
|
||
xcb_get_property_value_length(r));
|
||
} else {
|
||
str = g_strdup("Invalid encoding.");
|
||
}
|
||
|
||
free(r);
|
||
return str;
|
||
}
|
||
free(r);
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
void window_set_atom_prop(xcb_window_t w, xcb_atom_t prop, xcb_atom_t *atoms,
|
||
int count) {
|
||
xcb_change_property(xcb->connection, XCB_PROP_MODE_REPLACE, w, prop,
|
||
XCB_ATOM_ATOM, 32, count, atoms);
|
||
}
|
||
|
||
/****
|
||
* Code used to get monitor layout.
|
||
*/
|
||
|
||
/**
|
||
* Free monitor structure.
|
||
*/
|
||
static void x11_monitor_free(workarea *m) {
|
||
g_free(m->name);
|
||
g_free(m);
|
||
}
|
||
|
||
static void x11_monitors_free(void) {
|
||
while (xcb->monitors != NULL) {
|
||
workarea *m = xcb->monitors;
|
||
xcb->monitors = m->next;
|
||
x11_monitor_free(m);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Quick function that tries to fix the size (for dpi calculation)
|
||
* when monitor is rotate. This assumes the density is kinda equal in both X/Y
|
||
* direction.
|
||
*/
|
||
static void x11_workarea_fix_rotation(workarea *w) {
|
||
double ratio_res = w->w / (double)w->h;
|
||
double ratio_size = w->mw / (double)w->mh;
|
||
|
||
if ((ratio_res < 1.0 && ratio_size > 1.0) ||
|
||
(ratio_res > 1.0 && ratio_size < 1.0)) {
|
||
// Oposite ratios, swap them.
|
||
int nh = w->mw;
|
||
w->mw = w->mh;
|
||
w->mh = nh;
|
||
}
|
||
}
|
||
/**
|
||
* Create monitor based on output id
|
||
*/
|
||
static workarea *x11_get_monitor_from_output(xcb_randr_output_t out) {
|
||
xcb_randr_get_output_info_reply_t *op_reply;
|
||
xcb_randr_get_crtc_info_reply_t *crtc_reply;
|
||
xcb_randr_get_output_info_cookie_t it =
|
||
xcb_randr_get_output_info(xcb->connection, out, XCB_CURRENT_TIME);
|
||
op_reply = xcb_randr_get_output_info_reply(xcb->connection, it, NULL);
|
||
if (op_reply->crtc == XCB_NONE) {
|
||
free(op_reply);
|
||
return NULL;
|
||
}
|
||
xcb_randr_get_crtc_info_cookie_t ct = xcb_randr_get_crtc_info(
|
||
xcb->connection, op_reply->crtc, XCB_CURRENT_TIME);
|
||
crtc_reply = xcb_randr_get_crtc_info_reply(xcb->connection, ct, NULL);
|
||
if (!crtc_reply) {
|
||
free(op_reply);
|
||
return NULL;
|
||
}
|
||
workarea *retv = g_malloc0(sizeof(workarea));
|
||
retv->x = crtc_reply->x;
|
||
retv->y = crtc_reply->y;
|
||
retv->w = crtc_reply->width;
|
||
retv->h = crtc_reply->height;
|
||
|
||
retv->mw = op_reply->mm_width;
|
||
retv->mh = op_reply->mm_height;
|
||
x11_workarea_fix_rotation(retv);
|
||
|
||
char *tname = (char *)xcb_randr_get_output_info_name(op_reply);
|
||
int tname_len = xcb_randr_get_output_info_name_length(op_reply);
|
||
|
||
retv->name = g_malloc0((tname_len + 1) * sizeof(char));
|
||
memcpy(retv->name, tname, tname_len);
|
||
|
||
free(crtc_reply);
|
||
free(op_reply);
|
||
return retv;
|
||
}
|
||
|
||
#if (((XCB_RANDR_MAJOR_VERSION >= RANDR_PREF_MAJOR_VERSION) && \
|
||
(XCB_RANDR_MINOR_VERSION >= RANDR_PREF_MINOR_VERSION)) || \
|
||
XCB_RANDR_MAJOR_VERSION > RANDR_PREF_MAJOR_VERSION)
|
||
/**
|
||
* @param mon The randr monitor to parse.
|
||
*
|
||
* Create monitor based on xrandr monitor id.
|
||
*
|
||
* @returns A workarea representing the monitor mon
|
||
*/
|
||
static workarea *
|
||
x11_get_monitor_from_randr_monitor(xcb_randr_monitor_info_t *mon) {
|
||
// Query to the name of the monitor.
|
||
xcb_generic_error_t *err;
|
||
xcb_get_atom_name_cookie_t anc =
|
||
xcb_get_atom_name(xcb->connection, mon->name);
|
||
xcb_get_atom_name_reply_t *atom_reply =
|
||
xcb_get_atom_name_reply(xcb->connection, anc, &err);
|
||
if (err != NULL) {
|
||
g_warning("Could not get RandR monitor name: X11 error code %d\n",
|
||
err->error_code);
|
||
free(err);
|
||
return NULL;
|
||
}
|
||
workarea *retv = g_malloc0(sizeof(workarea));
|
||
|
||
// Is primary monitor.
|
||
retv->primary = mon->primary;
|
||
|
||
// Position and size.
|
||
retv->x = mon->x;
|
||
retv->y = mon->y;
|
||
retv->w = mon->width;
|
||
retv->h = mon->height;
|
||
|
||
// Physical
|
||
retv->mw = mon->width_in_millimeters;
|
||
retv->mh = mon->height_in_millimeters;
|
||
x11_workarea_fix_rotation(retv);
|
||
|
||
// Name
|
||
retv->name =
|
||
g_strdup_printf("%.*s", xcb_get_atom_name_name_length(atom_reply),
|
||
xcb_get_atom_name_name(atom_reply));
|
||
|
||
// Free name atom.
|
||
free(atom_reply);
|
||
|
||
return retv;
|
||
}
|
||
#endif
|
||
|
||
static int x11_is_extension_present(const char *extension) {
|
||
xcb_query_extension_cookie_t randr_cookie =
|
||
xcb_query_extension(xcb->connection, strlen(extension), extension);
|
||
|
||
xcb_query_extension_reply_t *randr_reply =
|
||
xcb_query_extension_reply(xcb->connection, randr_cookie, NULL);
|
||
|
||
int present = randr_reply->present;
|
||
|
||
free(randr_reply);
|
||
|
||
return present;
|
||
}
|
||
|
||
static void x11_build_monitor_layout_xinerama(void) {
|
||
xcb_xinerama_query_screens_cookie_t screens_cookie =
|
||
xcb_xinerama_query_screens_unchecked(xcb->connection);
|
||
|
||
xcb_xinerama_query_screens_reply_t *screens_reply =
|
||
xcb_xinerama_query_screens_reply(xcb->connection, screens_cookie, NULL);
|
||
|
||
xcb_xinerama_screen_info_iterator_t screens_iterator =
|
||
xcb_xinerama_query_screens_screen_info_iterator(screens_reply);
|
||
|
||
for (; screens_iterator.rem > 0;
|
||
xcb_xinerama_screen_info_next(&screens_iterator)) {
|
||
workarea *w = g_malloc0(sizeof(workarea));
|
||
|
||
w->x = screens_iterator.data->x_org;
|
||
w->y = screens_iterator.data->y_org;
|
||
w->w = screens_iterator.data->width;
|
||
w->h = screens_iterator.data->height;
|
||
|
||
w->next = xcb->monitors;
|
||
xcb->monitors = w;
|
||
}
|
||
|
||
int index = 0;
|
||
for (workarea *iter = xcb->monitors; iter; iter = iter->next) {
|
||
iter->monitor_id = index++;
|
||
}
|
||
|
||
free(screens_reply);
|
||
}
|
||
|
||
static void x11_build_monitor_layout(void) {
|
||
if (xcb->monitors) {
|
||
return;
|
||
}
|
||
// If RANDR is not available, try Xinerama
|
||
if (!x11_is_extension_present("RANDR")) {
|
||
// Check if xinerama is available.
|
||
if (x11_is_extension_present("XINERAMA")) {
|
||
g_debug("Query XINERAMA for monitor layout.");
|
||
x11_build_monitor_layout_xinerama();
|
||
return;
|
||
}
|
||
g_debug("No RANDR or Xinerama available for getting monitor layout.");
|
||
return;
|
||
}
|
||
g_debug("Query RANDR for monitor layout.");
|
||
|
||
g_debug("Randr XCB api version: %d.%d.", XCB_RANDR_MAJOR_VERSION,
|
||
XCB_RANDR_MINOR_VERSION);
|
||
#if (((XCB_RANDR_MAJOR_VERSION == RANDR_PREF_MAJOR_VERSION) && \
|
||
(XCB_RANDR_MINOR_VERSION >= RANDR_PREF_MINOR_VERSION)) || \
|
||
XCB_RANDR_MAJOR_VERSION > RANDR_PREF_MAJOR_VERSION)
|
||
xcb_randr_query_version_cookie_t cversion = xcb_randr_query_version(
|
||
xcb->connection, RANDR_PREF_MAJOR_VERSION, RANDR_PREF_MINOR_VERSION);
|
||
xcb_randr_query_version_reply_t *rversion =
|
||
xcb_randr_query_version_reply(xcb->connection, cversion, NULL);
|
||
if (rversion) {
|
||
g_debug("Found randr version: %d.%d", rversion->major_version,
|
||
rversion->minor_version);
|
||
// Check if we are 1.5 and up.
|
||
if (((rversion->major_version == RANDR_PREF_MAJOR_VERSION) &&
|
||
(rversion->minor_version >= RANDR_PREF_MINOR_VERSION)) ||
|
||
(rversion->major_version > RANDR_PREF_MAJOR_VERSION)) {
|
||
xcb_randr_get_monitors_cookie_t t =
|
||
xcb_randr_get_monitors(xcb->connection, xcb->screen->root, 1);
|
||
xcb_randr_get_monitors_reply_t *mreply =
|
||
xcb_randr_get_monitors_reply(xcb->connection, t, NULL);
|
||
if (mreply) {
|
||
xcb_randr_monitor_info_iterator_t iter =
|
||
xcb_randr_get_monitors_monitors_iterator(mreply);
|
||
while (iter.rem > 0) {
|
||
workarea *w = x11_get_monitor_from_randr_monitor(iter.data);
|
||
if (w) {
|
||
w->next = xcb->monitors;
|
||
xcb->monitors = w;
|
||
}
|
||
xcb_randr_monitor_info_next(&iter);
|
||
}
|
||
free(mreply);
|
||
}
|
||
}
|
||
free(rversion);
|
||
}
|
||
#endif
|
||
|
||
// If no monitors found.
|
||
if (xcb->monitors == NULL) {
|
||
xcb_randr_get_screen_resources_current_reply_t *res_reply;
|
||
xcb_randr_get_screen_resources_current_cookie_t src;
|
||
src = xcb_randr_get_screen_resources_current(xcb->connection,
|
||
xcb->screen->root);
|
||
res_reply = xcb_randr_get_screen_resources_current_reply(xcb->connection,
|
||
src, NULL);
|
||
if (!res_reply) {
|
||
return; // just report error
|
||
}
|
||
int mon_num =
|
||
xcb_randr_get_screen_resources_current_outputs_length(res_reply);
|
||
xcb_randr_output_t *ops =
|
||
xcb_randr_get_screen_resources_current_outputs(res_reply);
|
||
|
||
// Get primary.
|
||
xcb_randr_get_output_primary_cookie_t pc =
|
||
xcb_randr_get_output_primary(xcb->connection, xcb->screen->root);
|
||
xcb_randr_get_output_primary_reply_t *pc_rep =
|
||
xcb_randr_get_output_primary_reply(xcb->connection, pc, NULL);
|
||
|
||
for (int i = mon_num - 1; i >= 0; i--) {
|
||
workarea *w = x11_get_monitor_from_output(ops[i]);
|
||
if (w) {
|
||
w->next = xcb->monitors;
|
||
xcb->monitors = w;
|
||
if (pc_rep && pc_rep->output == ops[i]) {
|
||
w->primary = TRUE;
|
||
}
|
||
}
|
||
}
|
||
// If exists, free primary output reply.
|
||
if (pc_rep) {
|
||
free(pc_rep);
|
||
}
|
||
free(res_reply);
|
||
}
|
||
|
||
// Number monitor
|
||
int index = 0;
|
||
for (workarea *iter = xcb->monitors; iter; iter = iter->next) {
|
||
iter->monitor_id = index++;
|
||
}
|
||
}
|
||
|
||
void display_dump_monitor_layout(void) {
|
||
int is_term = isatty(fileno(stdout));
|
||
printf("Monitor layout:\n");
|
||
for (workarea *iter = xcb->monitors; iter; iter = iter->next) {
|
||
printf("%s ID%s: %d", (is_term) ? color_bold : "",
|
||
is_term ? color_reset : "", iter->monitor_id);
|
||
if (iter->primary) {
|
||
printf(" (primary)");
|
||
}
|
||
printf("\n");
|
||
printf("%s name%s: %s\n", (is_term) ? color_bold : "",
|
||
is_term ? color_reset : "", iter->name);
|
||
printf("%s position%s: %d,%d\n", (is_term) ? color_bold : "",
|
||
is_term ? color_reset : "", iter->x, iter->y);
|
||
printf("%s size%s: %d,%d\n", (is_term) ? color_bold : "",
|
||
is_term ? color_reset : "", iter->w, iter->h);
|
||
if (iter->mw > 0 && iter->mh > 0) {
|
||
printf("%s size%s: %dmm,%dmm dpi: %.0f,%.0f\n",
|
||
(is_term) ? color_bold : "", is_term ? color_reset : "", iter->mw,
|
||
iter->mh, iter->w * 25.4 / (double)iter->mw,
|
||
iter->h * 25.4 / (double)iter->mh);
|
||
}
|
||
printf("\n");
|
||
}
|
||
}
|
||
|
||
void display_startup_notification(RofiHelperExecuteContext *context,
|
||
GSpawnChildSetupFunc *child_setup,
|
||
gpointer *user_data) {
|
||
if (context == NULL) {
|
||
return;
|
||
}
|
||
|
||
SnLauncherContext *sncontext;
|
||
|
||
sncontext = sn_launcher_context_new(xcb->sndisplay, xcb->screen_nbr);
|
||
|
||
sn_launcher_context_set_name(sncontext, context->name);
|
||
sn_launcher_context_set_description(sncontext, context->description);
|
||
if (context->binary != NULL) {
|
||
sn_launcher_context_set_binary_name(sncontext, context->binary);
|
||
}
|
||
if (context->icon != NULL) {
|
||
sn_launcher_context_set_icon_name(sncontext, context->icon);
|
||
}
|
||
if (context->app_id != NULL) {
|
||
sn_launcher_context_set_application_id(sncontext, context->app_id);
|
||
}
|
||
if (context->wmclass != NULL) {
|
||
sn_launcher_context_set_wmclass(sncontext, context->wmclass);
|
||
}
|
||
|
||
xcb_get_property_cookie_t c;
|
||
unsigned int current_desktop = 0;
|
||
|
||
c = xcb_ewmh_get_current_desktop(&xcb->ewmh, xcb->screen_nbr);
|
||
if (xcb_ewmh_get_current_desktop_reply(&xcb->ewmh, c, ¤t_desktop,
|
||
NULL)) {
|
||
sn_launcher_context_set_workspace(sncontext, current_desktop);
|
||
}
|
||
|
||
sn_launcher_context_initiate(sncontext, "rofi", context->command,
|
||
xcb->last_timestamp);
|
||
|
||
*child_setup = (GSpawnChildSetupFunc)sn_launcher_context_setup_child_process;
|
||
*user_data = sncontext;
|
||
}
|
||
|
||
static int monitor_get_dimension(int monitor_id, workarea *mon) {
|
||
memset(mon, 0, sizeof(workarea));
|
||
mon->w = xcb->screen->width_in_pixels;
|
||
mon->h = xcb->screen->height_in_pixels;
|
||
|
||
workarea *iter = NULL;
|
||
for (iter = xcb->monitors; iter; iter = iter->next) {
|
||
if (iter->monitor_id == monitor_id) {
|
||
*mon = *iter;
|
||
return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
// find the dimensions of the monitor displaying point x,y
|
||
static void monitor_dimensions(int x, int y, workarea *mon) {
|
||
if (mon == NULL) {
|
||
g_error("%s: mon == NULL", __func__);
|
||
return;
|
||
}
|
||
memset(mon, 0, sizeof(workarea));
|
||
mon->w = xcb->screen->width_in_pixels;
|
||
mon->h = xcb->screen->height_in_pixels;
|
||
|
||
for (workarea *iter = xcb->monitors; iter; iter = iter->next) {
|
||
if (INTERSECT(x, y, iter->x, iter->y, iter->w, iter->h)) {
|
||
*mon = *iter;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param root The X11 window used to find the pointer position. Usually the
|
||
* root window.
|
||
* @param x The x position of the mouse [out]
|
||
* @param y The y position of the mouse [out]
|
||
*
|
||
* find mouse pointer location
|
||
*
|
||
* @returns TRUE when found, FALSE otherwise
|
||
*/
|
||
static int pointer_get(xcb_window_t root, int *x, int *y) {
|
||
*x = 0;
|
||
*y = 0;
|
||
xcb_query_pointer_cookie_t c = xcb_query_pointer(xcb->connection, root);
|
||
xcb_query_pointer_reply_t *r =
|
||
xcb_query_pointer_reply(xcb->connection, c, NULL);
|
||
if (r) {
|
||
*x = r->root_x;
|
||
*y = r->root_y;
|
||
free(r);
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
static int monitor_active_from_winid(xcb_drawable_t id, workarea *mon) {
|
||
if (mon == NULL) {
|
||
g_error("%s: mon == NULL", __func__);
|
||
return FALSE;
|
||
}
|
||
xcb_window_t root = xcb->screen->root;
|
||
xcb_get_geometry_cookie_t c = xcb_get_geometry(xcb->connection, id);
|
||
xcb_get_geometry_reply_t *r =
|
||
xcb_get_geometry_reply(xcb->connection, c, NULL);
|
||
if (r) {
|
||
xcb_translate_coordinates_cookie_t ct =
|
||
xcb_translate_coordinates(xcb->connection, id, root, r->x, r->y);
|
||
xcb_translate_coordinates_reply_t *t =
|
||
xcb_translate_coordinates_reply(xcb->connection, ct, NULL);
|
||
if (t) {
|
||
// place the menu above the window
|
||
// if some window is focused, place menu above window, else fall
|
||
// back to selected monitor.
|
||
mon->x = t->dst_x - r->x;
|
||
mon->y = t->dst_y - r->y;
|
||
mon->w = r->width;
|
||
mon->h = r->height;
|
||
free(r);
|
||
free(t);
|
||
return TRUE;
|
||
}
|
||
free(r);
|
||
}
|
||
return FALSE;
|
||
}
|
||
static int monitor_active_from_id_focused(int mon_id, workarea *mon) {
|
||
int retv = FALSE;
|
||
xcb_window_t active_window;
|
||
xcb_get_property_cookie_t awc;
|
||
if (mon == NULL) {
|
||
g_error("%s: mon == NULL", __func__);
|
||
return retv;
|
||
}
|
||
awc = xcb_ewmh_get_active_window(&xcb->ewmh, xcb->screen_nbr);
|
||
if (!xcb_ewmh_get_active_window_reply(&xcb->ewmh, awc, &active_window,
|
||
NULL)) {
|
||
g_debug(
|
||
"Failed to get active window, falling back to mouse location (-5).");
|
||
return retv;
|
||
}
|
||
xcb_query_tree_cookie_t tree_cookie =
|
||
xcb_query_tree(xcb->connection, active_window);
|
||
xcb_query_tree_reply_t *tree_reply =
|
||
xcb_query_tree_reply(xcb->connection, tree_cookie, NULL);
|
||
if (!tree_reply) {
|
||
g_debug(
|
||
"Failed to get parent window, falling back to mouse location (-5).");
|
||
return retv;
|
||
}
|
||
// get geometry.
|
||
xcb_get_geometry_cookie_t c =
|
||
xcb_get_geometry(xcb->connection, active_window);
|
||
xcb_get_geometry_reply_t *r =
|
||
xcb_get_geometry_reply(xcb->connection, c, NULL);
|
||
if (!r) {
|
||
g_debug("Failed to get geometry of active window, falling back to mouse "
|
||
"location (-5).");
|
||
free(tree_reply);
|
||
return retv;
|
||
}
|
||
if (tree_reply->parent != r->root) {
|
||
xcb_translate_coordinates_cookie_t ct = xcb_translate_coordinates(
|
||
xcb->connection, tree_reply->parent, r->root, r->x, r->y);
|
||
xcb_translate_coordinates_reply_t *t =
|
||
xcb_translate_coordinates_reply(xcb->connection, ct, NULL);
|
||
if (t) {
|
||
r->x = t->dst_x;
|
||
r->y = t->dst_y;
|
||
free(t);
|
||
} else {
|
||
g_debug("Failed to get translate position of active window, falling back "
|
||
"to mouse location (-5).");
|
||
free(r);
|
||
free(tree_reply);
|
||
return retv;
|
||
}
|
||
}
|
||
if (mon_id == -2) {
|
||
// place the menu above the window
|
||
// if some window is focused, place menu above window, else fall
|
||
// back to selected monitor.
|
||
mon->x = r->x + r->border_width;
|
||
mon->y = r->y + r->border_width;
|
||
mon->w = r->width;
|
||
mon->h = r->height;
|
||
retv = TRUE;
|
||
} else if (mon_id == -4) {
|
||
g_debug("Find monitor at location: %d %d", r->x, r->y);
|
||
monitor_dimensions(r->x, r->y, mon);
|
||
retv = TRUE;
|
||
}
|
||
g_debug("mon pos: %d %d %d-%d", mon->x, mon->y, mon->w, mon->h);
|
||
free(r);
|
||
free(tree_reply);
|
||
return retv;
|
||
}
|
||
static int monitor_active_from_id(int mon_id, workarea *mon) {
|
||
xcb_window_t root = xcb->screen->root;
|
||
int x, y;
|
||
if (mon == NULL) {
|
||
g_error("%s: mon == NULL", __func__);
|
||
return FALSE;
|
||
}
|
||
g_debug("Monitor id: %d", mon_id);
|
||
// At mouse position.
|
||
if (mon_id == -3) {
|
||
if (pointer_get(root, &x, &y)) {
|
||
monitor_dimensions(x, y, mon);
|
||
mon->x = x;
|
||
mon->y = y;
|
||
return TRUE;
|
||
}
|
||
}
|
||
// Focused monitor
|
||
else if (mon_id == -1) {
|
||
g_debug("rofi on current monitor");
|
||
// Get the current desktop.
|
||
unsigned int current_desktop = 0;
|
||
xcb_get_property_cookie_t gcdc;
|
||
gcdc = xcb_ewmh_get_current_desktop(&xcb->ewmh, xcb->screen_nbr);
|
||
if (xcb_ewmh_get_current_desktop_reply(&xcb->ewmh, gcdc, ¤t_desktop,
|
||
NULL)) {
|
||
g_debug("Found current desktop: %u", current_desktop);
|
||
xcb_get_property_cookie_t c =
|
||
xcb_ewmh_get_desktop_viewport(&xcb->ewmh, xcb->screen_nbr);
|
||
xcb_ewmh_get_desktop_viewport_reply_t vp;
|
||
if (xcb_ewmh_get_desktop_viewport_reply(&xcb->ewmh, c, &vp, NULL)) {
|
||
g_debug("Found %d number of desktops", vp.desktop_viewport_len);
|
||
if (current_desktop < vp.desktop_viewport_len) {
|
||
g_debug("Found viewport for desktop: %d %d",
|
||
vp.desktop_viewport[current_desktop].x,
|
||
vp.desktop_viewport[current_desktop].y);
|
||
monitor_dimensions(vp.desktop_viewport[current_desktop].x,
|
||
vp.desktop_viewport[current_desktop].y, mon);
|
||
g_debug("Found monitor @: %d %d %dx%d", mon->x, mon->y, mon->w,
|
||
mon->h);
|
||
xcb_ewmh_get_desktop_viewport_reply_wipe(&vp);
|
||
return TRUE;
|
||
}
|
||
g_debug("Viewport does not exist for current desktop: %d, falling "
|
||
"back to mouse location (-5)",
|
||
current_desktop);
|
||
xcb_ewmh_get_desktop_viewport_reply_wipe(&vp);
|
||
} else {
|
||
g_debug("Failed to get viewport for current desktop: %d, falling back "
|
||
"to mouse location (-5).",
|
||
current_desktop);
|
||
}
|
||
} else {
|
||
g_debug("Failed to get current desktop, falling back to mouse location "
|
||
"(-5).");
|
||
}
|
||
} else if (mon_id == -2 || mon_id == -4) {
|
||
if (monitor_active_from_id_focused(mon_id, mon)) {
|
||
return TRUE;
|
||
}
|
||
}
|
||
// Monitor that has mouse pointer.
|
||
else if (mon_id == -5) {
|
||
if (pointer_get(root, &x, &y)) {
|
||
monitor_dimensions(x, y, mon);
|
||
return TRUE;
|
||
}
|
||
// This is our give up point.
|
||
return FALSE;
|
||
}
|
||
g_debug("Failed to find monitor, fall back to monitor showing mouse.");
|
||
return monitor_active_from_id(-5, mon);
|
||
}
|
||
|
||
// determine which monitor holds the active window, or failing that the mouse
|
||
// pointer
|
||
/** The cached monitor setup (mon_cache) is populated */
|
||
gboolean mon_set = FALSE;
|
||
/** cached monitor cache, to avoid multiple roundtrips to fetch this. */
|
||
workarea mon_cache = {
|
||
0,
|
||
};
|
||
int monitor_active(workarea *mon) {
|
||
if (mon == NULL) {
|
||
g_error("%s: mon == NULL", __func__);
|
||
return FALSE;
|
||
}
|
||
g_debug("Monitor active");
|
||
if (mon_set) {
|
||
*mon = mon_cache;
|
||
return TRUE;
|
||
}
|
||
if (config.monitor != NULL) {
|
||
g_debug("Monitor lookup by name : %s", config.monitor);
|
||
for (workarea *iter = xcb->monitors; iter; iter = iter->next) {
|
||
if (g_strcmp0(config.monitor, iter->name) == 0) {
|
||
*mon = *iter;
|
||
mon_cache = *mon;
|
||
mon_set = TRUE;
|
||
return TRUE;
|
||
}
|
||
}
|
||
}
|
||
g_debug("Monitor lookup by name failed: %s", config.monitor);
|
||
// Grab primary.
|
||
if (g_strcmp0(config.monitor, "primary") == 0) {
|
||
for (workarea *iter = xcb->monitors; iter; iter = iter->next) {
|
||
if (iter->primary) {
|
||
*mon = *iter;
|
||
mon_cache = *mon;
|
||
mon_set = TRUE;
|
||
return TRUE;
|
||
}
|
||
}
|
||
}
|
||
if (g_str_has_prefix(config.monitor, "wid:")) {
|
||
char *end = NULL;
|
||
xcb_drawable_t win = g_ascii_strtoll(config.monitor + 4, &end, 0);
|
||
if (end != config.monitor) {
|
||
if (monitor_active_from_winid(win, mon)) {
|
||
mon_cache = *mon;
|
||
mon_set = TRUE;
|
||
return TRUE;
|
||
}
|
||
}
|
||
}
|
||
{
|
||
// IF fail, fall back to classic mode.
|
||
char *end = NULL;
|
||
gint64 mon_id = g_ascii_strtoll(config.monitor, &end, 0);
|
||
if (end != config.monitor) {
|
||
if (mon_id >= 0) {
|
||
if (monitor_get_dimension(mon_id, mon)) {
|
||
mon_cache = *mon;
|
||
mon_set = TRUE;
|
||
return TRUE;
|
||
}
|
||
g_warning("Failed to find selected monitor.");
|
||
} else {
|
||
int val = monitor_active_from_id(mon_id, mon);
|
||
mon_cache = *mon;
|
||
mon_set = TRUE;
|
||
return val;
|
||
}
|
||
}
|
||
}
|
||
// Fallback.
|
||
monitor_dimensions(0, 0, mon);
|
||
mon_cache = *mon;
|
||
mon_set = TRUE;
|
||
return FALSE;
|
||
}
|
||
|
||
static bool get_atom_name(xcb_connection_t *conn, xcb_atom_t atom, char **out) {
|
||
xcb_get_atom_name_cookie_t cookie;
|
||
xcb_get_atom_name_reply_t *reply;
|
||
int length;
|
||
char *name;
|
||
|
||
if (atom == 0) {
|
||
*out = NULL;
|
||
return true;
|
||
}
|
||
|
||
cookie = xcb_get_atom_name(conn, atom);
|
||
reply = xcb_get_atom_name_reply(conn, cookie, NULL);
|
||
if (!reply)
|
||
return false;
|
||
|
||
length = xcb_get_atom_name_name_length(reply);
|
||
name = xcb_get_atom_name_name(reply);
|
||
|
||
(*out) = g_strndup(name, length);
|
||
if (!(*out)) {
|
||
free(reply);
|
||
return false;
|
||
}
|
||
|
||
free(reply);
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @param state Internal state of the menu.
|
||
* @param xse X selection event.
|
||
*
|
||
* Handle paste event.
|
||
*/
|
||
static void rofi_view_paste(RofiViewState *state,
|
||
xcb_selection_notify_event_t *xse) {
|
||
if (xse->property == XCB_ATOM_NONE) {
|
||
g_debug("Failed to convert selection");
|
||
} else if (xse->property == xcb->ewmh.UTF8_STRING) {
|
||
gchar *text = window_get_text_prop(xse->requestor, xcb->ewmh.UTF8_STRING);
|
||
if (text != NULL && text[0] != '\0') {
|
||
unsigned int dl = strlen(text);
|
||
// Strip new line
|
||
for (unsigned int i = 0; i < dl; i++) {
|
||
if (text[i] == '\n') {
|
||
text[i] = '\0';
|
||
}
|
||
}
|
||
rofi_view_handle_text(state, text);
|
||
}
|
||
g_free(text);
|
||
} else {
|
||
char *out = NULL;
|
||
if (get_atom_name(xcb->connection, xse->property, &out)) {
|
||
g_debug("rofi_view_paste: Got unknown atom: %s", out);
|
||
g_free(out);
|
||
} else {
|
||
g_debug("rofi_view_paste: Got unknown, unnamed: %s", out);
|
||
}
|
||
}
|
||
}
|
||
|
||
static gboolean
|
||
x11_button_to_nk_bindings_button(guint32 x11_button,
|
||
NkBindingsMouseButton *button) {
|
||
switch (x11_button) {
|
||
case 1:
|
||
*button = NK_BINDINGS_MOUSE_BUTTON_PRIMARY;
|
||
break;
|
||
case 3:
|
||
*button = NK_BINDINGS_MOUSE_BUTTON_SECONDARY;
|
||
break;
|
||
case 2:
|
||
*button = NK_BINDINGS_MOUSE_BUTTON_MIDDLE;
|
||
break;
|
||
case 8:
|
||
*button = NK_BINDINGS_MOUSE_BUTTON_BACK;
|
||
break;
|
||
case 9:
|
||
*button = NK_BINDINGS_MOUSE_BUTTON_FORWARD;
|
||
break;
|
||
case 4:
|
||
case 5:
|
||
case 6:
|
||
case 7:
|
||
return FALSE;
|
||
default:
|
||
*button = NK_BINDINGS_MOUSE_BUTTON_EXTRA + x11_button;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
static gboolean x11_button_to_nk_bindings_scroll(guint32 x11_button,
|
||
NkBindingsScrollAxis *axis,
|
||
gint32 *steps) {
|
||
*steps = 1;
|
||
switch (x11_button) {
|
||
case 4:
|
||
*steps = -1;
|
||
/* fallthrough */
|
||
case 5:
|
||
*axis = NK_BINDINGS_SCROLL_AXIS_VERTICAL;
|
||
break;
|
||
case 6:
|
||
*steps = -1;
|
||
/* fallthrough */
|
||
case 7:
|
||
*axis = NK_BINDINGS_SCROLL_AXIS_HORIZONTAL;
|
||
break;
|
||
default:
|
||
return FALSE;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
static void rofi_key_press_event_handler(xcb_key_press_event_t *xkpe,
|
||
RofiViewState *state) {
|
||
gchar *text;
|
||
g_log("IMDKit", G_LOG_LEVEL_DEBUG, "press handler");
|
||
|
||
xcb->last_timestamp = xkpe->time;
|
||
if (config.xserver_i300_workaround) {
|
||
text = nk_bindings_seat_handle_key_with_modmask(
|
||
xcb->bindings_seat, NULL, xkpe->state, xkpe->detail,
|
||
NK_BINDINGS_KEY_STATE_PRESS);
|
||
} else {
|
||
text = nk_bindings_seat_handle_key(xcb->bindings_seat, NULL, xkpe->detail,
|
||
NK_BINDINGS_KEY_STATE_PRESS);
|
||
}
|
||
if (text != NULL) {
|
||
rofi_view_handle_text(state, text);
|
||
g_free(text);
|
||
}
|
||
}
|
||
|
||
static void rofi_key_release_event_handler(xcb_key_release_event_t *xkre,
|
||
G_GNUC_UNUSED RofiViewState *state) {
|
||
xcb->last_timestamp = xkre->time;
|
||
nk_bindings_seat_handle_key(xcb->bindings_seat, NULL, xkre->detail,
|
||
NK_BINDINGS_KEY_STATE_RELEASE);
|
||
}
|
||
|
||
/**
|
||
* Process X11 events in the main-loop (gui-thread) of the application.
|
||
*/
|
||
static void main_loop_x11_event_handler_view(xcb_generic_event_t *event) {
|
||
RofiViewState *state = rofi_view_get_active();
|
||
if (state == NULL) {
|
||
return;
|
||
}
|
||
|
||
switch (event->response_type & ~0x80) {
|
||
case XCB_CLIENT_MESSAGE: {
|
||
xcb_client_message_event_t *cme = (xcb_client_message_event_t *)event;
|
||
xcb_atom_t atom = cme->data.data32[0];
|
||
xcb_timestamp_t time = cme->data.data32[1];
|
||
if (atom == netatoms[WM_TAKE_FOCUS]) {
|
||
xcb_set_input_focus(xcb->connection, XCB_INPUT_FOCUS_NONE, cme->window,
|
||
time);
|
||
xcb_flush(xcb->connection);
|
||
}
|
||
break;
|
||
}
|
||
case XCB_DESTROY_NOTIFY: {
|
||
xcb_window_t win = ((xcb_destroy_notify_event_t *)event)->window;
|
||
if (win != rofi_view_get_window()) {
|
||
#ifdef WINDOW_MODE
|
||
window_client_handle_signal(win, FALSE);
|
||
#endif
|
||
} else {
|
||
g_main_loop_quit(xcb->main_loop);
|
||
}
|
||
break;
|
||
}
|
||
case XCB_CREATE_NOTIFY: {
|
||
xcb_window_t win = ((xcb_create_notify_event_t *)event)->window;
|
||
if (win != rofi_view_get_window()) {
|
||
#ifdef WINDOW_MODE
|
||
window_client_handle_signal(win, TRUE);
|
||
#endif
|
||
}
|
||
break;
|
||
}
|
||
case XCB_EXPOSE:
|
||
rofi_view_frame_callback();
|
||
break;
|
||
case XCB_CONFIGURE_NOTIFY: {
|
||
xcb_configure_notify_event_t *xce = (xcb_configure_notify_event_t *)event;
|
||
rofi_view_temp_configure_notify(state, xce);
|
||
break;
|
||
}
|
||
case XCB_MOTION_NOTIFY: {
|
||
xcb_motion_notify_event_t *xme = (xcb_motion_notify_event_t *)event;
|
||
gboolean button_mask = xme->state & XCB_EVENT_MASK_BUTTON_1_MOTION;
|
||
rofi_view_handle_mouse_motion(state, xme->event_x, xme->event_y,
|
||
!button_mask && config.hover_select);
|
||
break;
|
||
}
|
||
case XCB_BUTTON_PRESS: {
|
||
xcb_button_press_event_t *bpe = (xcb_button_press_event_t *)event;
|
||
NkBindingsMouseButton button;
|
||
NkBindingsScrollAxis axis;
|
||
gint32 steps;
|
||
|
||
xcb->last_timestamp = bpe->time;
|
||
rofi_view_handle_mouse_motion(state, bpe->event_x, bpe->event_y, FALSE);
|
||
if (x11_button_to_nk_bindings_button(bpe->detail, &button)) {
|
||
nk_bindings_seat_handle_button(xcb->bindings_seat, NULL, button,
|
||
NK_BINDINGS_BUTTON_STATE_PRESS, bpe->time);
|
||
} else if (x11_button_to_nk_bindings_scroll(bpe->detail, &axis, &steps)) {
|
||
nk_bindings_seat_handle_scroll(xcb->bindings_seat, NULL, axis, steps);
|
||
}
|
||
xcb->mouse_seen++;
|
||
break;
|
||
}
|
||
case XCB_SELECTION_CLEAR: {
|
||
g_debug("Selection Clear.");
|
||
xcb_stuff_set_clipboard(NULL);
|
||
} break;
|
||
case XCB_SELECTION_REQUEST: {
|
||
g_debug("Selection Request.");
|
||
xcb_selection_request_event_t *req = (xcb_selection_request_event_t *)event;
|
||
if (req->selection == netatoms[CLIPBOARD]) {
|
||
xcb_atom_t targets[2];
|
||
xcb_selection_notify_event_t selection_notify = {
|
||
.response_type = XCB_SELECTION_NOTIFY,
|
||
.sequence = 0,
|
||
.time = req->time,
|
||
.requestor = req->requestor,
|
||
.selection = req->selection,
|
||
.target = req->target,
|
||
.property = XCB_ATOM_NONE,
|
||
};
|
||
// If no clipboard, we return NONE.
|
||
if (xcb->clipboard) {
|
||
// Request for UTF-8
|
||
if (req->target == netatoms[UTF8_STRING]) {
|
||
g_debug("Selection Request UTF-8.");
|
||
xcb_change_property(xcb->connection, XCB_PROP_MODE_REPLACE,
|
||
req->requestor, req->property,
|
||
netatoms[UTF8_STRING], 8,
|
||
strlen(xcb->clipboard) + 1, xcb->clipboard);
|
||
selection_notify.property = req->property;
|
||
} else if (req->target == netatoms[TARGETS]) {
|
||
g_debug("Selection Request Targets.");
|
||
// We currently only support UTF8 from clipboard. So indicate this.
|
||
targets[0] = netatoms[UTF8_STRING];
|
||
xcb_change_property(xcb->connection, XCB_PROP_MODE_REPLACE,
|
||
req->requestor, req->property, XCB_ATOM_ATOM, 32,
|
||
1, targets);
|
||
selection_notify.property = req->property;
|
||
}
|
||
}
|
||
|
||
xcb_send_event(xcb->connection,
|
||
0, // propagate
|
||
req->requestor, XCB_EVENT_MASK_NO_EVENT,
|
||
(const char *)&selection_notify);
|
||
xcb_flush(xcb->connection);
|
||
}
|
||
} break;
|
||
case XCB_BUTTON_RELEASE: {
|
||
xcb_button_release_event_t *bre = (xcb_button_release_event_t *)event;
|
||
NkBindingsMouseButton button;
|
||
|
||
xcb->last_timestamp = bre->time;
|
||
if (x11_button_to_nk_bindings_button(bre->detail, &button)) {
|
||
nk_bindings_seat_handle_button(xcb->bindings_seat, NULL, button,
|
||
NK_BINDINGS_BUTTON_STATE_RELEASE,
|
||
bre->time);
|
||
}
|
||
if (config.click_to_exit == TRUE) {
|
||
if (!xcb->mouse_seen) {
|
||
rofi_view_temp_click_to_exit(state, bre->event);
|
||
}
|
||
xcb->mouse_seen--;
|
||
}
|
||
break;
|
||
}
|
||
// Paste event.
|
||
case XCB_SELECTION_NOTIFY:
|
||
rofi_view_paste(state, (xcb_selection_notify_event_t *)event);
|
||
break;
|
||
case XCB_KEYMAP_NOTIFY: {
|
||
xcb_keymap_notify_event_t *kne = (xcb_keymap_notify_event_t *)event;
|
||
for (gint32 by = 0; by < 31; ++by) {
|
||
for (gint8 bi = 0; bi < 7; ++bi) {
|
||
if (kne->keys[by] & (1 << bi)) {
|
||
// X11 keycodes starts at 8
|
||
nk_bindings_seat_handle_key(xcb->bindings_seat, NULL,
|
||
(8 * by + bi) + 8,
|
||
NK_BINDINGS_KEY_STATE_PRESSED);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case XCB_KEY_PRESS: {
|
||
xcb_key_press_event_t *xkpe = (xcb_key_press_event_t *)event;
|
||
#ifdef XCB_IMDKIT
|
||
if (xcb->ic) {
|
||
g_log("IMDKit", G_LOG_LEVEL_DEBUG, "input xim");
|
||
xcb_xim_forward_event(xcb->im, xcb->ic, xkpe);
|
||
} else
|
||
#endif
|
||
{
|
||
rofi_key_press_event_handler(xkpe, state);
|
||
}
|
||
break;
|
||
}
|
||
case XCB_KEY_RELEASE: {
|
||
xcb_key_release_event_t *xkre = (xcb_key_release_event_t *)event;
|
||
#ifdef XCB_IMDKIT
|
||
if (xcb->ic) {
|
||
xcb_xim_forward_event(xcb->im, xcb->ic, xkre);
|
||
} else
|
||
#endif
|
||
{
|
||
rofi_key_release_event_handler(xkre, state);
|
||
}
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
rofi_view_maybe_update(state);
|
||
}
|
||
|
||
#ifdef XCB_IMDKIT
|
||
void x11_event_handler_fowarding(G_GNUC_UNUSED xcb_xim_t *im,
|
||
G_GNUC_UNUSED xcb_xic_t ic,
|
||
xcb_key_press_event_t *event,
|
||
G_GNUC_UNUSED void *user_data) {
|
||
RofiViewState *state = rofi_view_get_active();
|
||
if (state == NULL) {
|
||
return;
|
||
}
|
||
uint8_t type = event->response_type & ~0x80;
|
||
if (type == XCB_KEY_PRESS) {
|
||
rofi_key_press_event_handler(event, state);
|
||
} else if (type == XCB_KEY_RELEASE) {
|
||
xcb_key_release_event_t *xkre = (xcb_key_release_event_t *)event;
|
||
rofi_key_release_event_handler(xkre, state);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
static gboolean main_loop_x11_event_handler(xcb_generic_event_t *ev,
|
||
G_GNUC_UNUSED gpointer user_data) {
|
||
if (ev == NULL) {
|
||
int status = xcb_connection_has_error(xcb->connection);
|
||
if (status > 0) {
|
||
g_warning("The XCB connection to X server had a fatal error: %d", status);
|
||
g_main_loop_quit(xcb->main_loop);
|
||
return G_SOURCE_REMOVE;
|
||
}
|
||
// DD: it seems this handler often gets dispatched while the queue in GWater
|
||
// is empty. resulting in a NULL for ev. This seems not an error.
|
||
// g_warning("main_loop_x11_event_handler: ev == NULL, status == %d",
|
||
// status);
|
||
return G_SOURCE_CONTINUE;
|
||
}
|
||
|
||
#ifdef XCB_IMDKIT
|
||
if (xcb->im && xcb_xim_filter_event(xcb->im, ev)) {
|
||
return G_SOURCE_CONTINUE;
|
||
}
|
||
#endif
|
||
|
||
uint8_t type = ev->response_type & ~0x80;
|
||
if (type == xcb->xkb.first_event) {
|
||
switch (ev->pad0) {
|
||
case XCB_XKB_MAP_NOTIFY: {
|
||
struct xkb_keymap *keymap = xkb_x11_keymap_new_from_device(
|
||
nk_bindings_seat_get_context(xcb->bindings_seat), xcb->connection,
|
||
xcb->xkb.device_id, 0);
|
||
struct xkb_state *state = xkb_x11_state_new_from_device(
|
||
keymap, xcb->connection, xcb->xkb.device_id);
|
||
nk_bindings_seat_update_keymap(xcb->bindings_seat, keymap, state);
|
||
xkb_keymap_unref(keymap);
|
||
xkb_state_unref(state);
|
||
break;
|
||
}
|
||
case XCB_XKB_STATE_NOTIFY: {
|
||
xcb_xkb_state_notify_event_t *ksne = (xcb_xkb_state_notify_event_t *)ev;
|
||
nk_bindings_seat_update_mask(xcb->bindings_seat, NULL, ksne->baseMods,
|
||
ksne->latchedMods, ksne->lockedMods,
|
||
ksne->baseGroup, ksne->latchedGroup,
|
||
ksne->lockedGroup);
|
||
rofi_view_maybe_update(rofi_view_get_active());
|
||
break;
|
||
}
|
||
}
|
||
return G_SOURCE_CONTINUE;
|
||
}
|
||
if (xcb->sndisplay != NULL) {
|
||
sn_xcb_display_process_event(xcb->sndisplay, ev);
|
||
}
|
||
|
||
main_loop_x11_event_handler_view(ev);
|
||
return G_SOURCE_CONTINUE;
|
||
}
|
||
|
||
void rofi_xcb_set_input_focus(xcb_window_t w) {
|
||
if (config.steal_focus != TRUE) {
|
||
xcb->focus_revert = 0;
|
||
return;
|
||
}
|
||
xcb_generic_error_t *error;
|
||
xcb_get_input_focus_reply_t *freply;
|
||
xcb_get_input_focus_cookie_t fcookie = xcb_get_input_focus(xcb->connection);
|
||
freply = xcb_get_input_focus_reply(xcb->connection, fcookie, &error);
|
||
if (error != NULL) {
|
||
g_warning("Could not get input focus (error %d), will revert focus to best "
|
||
"effort",
|
||
error->error_code);
|
||
free(error);
|
||
xcb->focus_revert = 0;
|
||
} else {
|
||
xcb->focus_revert = freply->focus;
|
||
}
|
||
xcb_set_input_focus(xcb->connection, XCB_INPUT_FOCUS_POINTER_ROOT, w,
|
||
XCB_CURRENT_TIME);
|
||
xcb_flush(xcb->connection);
|
||
}
|
||
|
||
void rofi_xcb_revert_input_focus(void) {
|
||
if (xcb->focus_revert == 0) {
|
||
return;
|
||
}
|
||
|
||
xcb_set_input_focus(xcb->connection, XCB_INPUT_FOCUS_POINTER_ROOT,
|
||
xcb->focus_revert, XCB_CURRENT_TIME);
|
||
xcb_flush(xcb->connection);
|
||
}
|
||
|
||
static int take_pointer(xcb_window_t w, int iters) {
|
||
int i = 0;
|
||
while (TRUE) {
|
||
if (xcb_connection_has_error(xcb->connection)) {
|
||
g_warning("Connection has error");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
xcb_grab_pointer_cookie_t cc =
|
||
xcb_grab_pointer(xcb->connection, 1, w, XCB_EVENT_MASK_BUTTON_RELEASE,
|
||
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, w, XCB_NONE,
|
||
XCB_CURRENT_TIME);
|
||
xcb_grab_pointer_reply_t *r =
|
||
xcb_grab_pointer_reply(xcb->connection, cc, NULL);
|
||
if (r) {
|
||
if (r->status == XCB_GRAB_STATUS_SUCCESS) {
|
||
free(r);
|
||
return 1;
|
||
}
|
||
free(r);
|
||
}
|
||
if ((++i) > iters) {
|
||
break;
|
||
}
|
||
struct timespec del = {.tv_sec = 0, .tv_nsec = 1000000};
|
||
nanosleep(&del, NULL);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static int take_keyboard(xcb_window_t w, int iters) {
|
||
int i = 0;
|
||
while (TRUE) {
|
||
if (xcb_connection_has_error(xcb->connection)) {
|
||
g_warning("Connection has error");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
xcb_grab_keyboard_cookie_t cc =
|
||
xcb_grab_keyboard(xcb->connection, 1, w, XCB_CURRENT_TIME,
|
||
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
|
||
xcb_grab_keyboard_reply_t *r =
|
||
xcb_grab_keyboard_reply(xcb->connection, cc, NULL);
|
||
if (r) {
|
||
if (r->status == XCB_GRAB_STATUS_SUCCESS) {
|
||
free(r);
|
||
return 1;
|
||
}
|
||
free(r);
|
||
}
|
||
if ((++i) > iters) {
|
||
break;
|
||
}
|
||
struct timespec del = {.tv_sec = 0, .tv_nsec = 1000000};
|
||
nanosleep(&del, NULL);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static void release_keyboard(void) {
|
||
xcb_ungrab_keyboard(xcb->connection, XCB_CURRENT_TIME);
|
||
}
|
||
static void release_pointer(void) {
|
||
xcb_ungrab_pointer(xcb->connection, XCB_CURRENT_TIME);
|
||
}
|
||
|
||
/** X server error depth. to handle nested errors. */
|
||
static int error_trap_depth = 0;
|
||
static void error_trap_push(G_GNUC_UNUSED SnDisplay *display,
|
||
G_GNUC_UNUSED xcb_connection_t *xdisplay) {
|
||
++error_trap_depth;
|
||
}
|
||
|
||
static void error_trap_pop(G_GNUC_UNUSED SnDisplay *display,
|
||
xcb_connection_t *xdisplay) {
|
||
if (error_trap_depth == 0) {
|
||
g_warning("Error trap underflow!");
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
xcb_flush(xdisplay);
|
||
--error_trap_depth;
|
||
}
|
||
|
||
/**
|
||
* Fill in the list of frequently used X11 Atoms.
|
||
*/
|
||
static void x11_create_frequently_used_atoms(void) {
|
||
// X atom values
|
||
for (int i = 0; i < NUM_NETATOMS; i++) {
|
||
xcb_intern_atom_cookie_t cc = xcb_intern_atom(
|
||
xcb->connection, 0, strlen(netatom_names[i]), netatom_names[i]);
|
||
xcb_intern_atom_reply_t *r =
|
||
xcb_intern_atom_reply(xcb->connection, cc, NULL);
|
||
if (r) {
|
||
netatoms[i] = r->atom;
|
||
free(r);
|
||
}
|
||
}
|
||
}
|
||
|
||
char *x11_helper_get_window_manager(void) {
|
||
char *retv = NULL;
|
||
xcb_window_t wm_win = 0;
|
||
xcb_get_property_cookie_t cc = xcb_ewmh_get_supporting_wm_check_unchecked(
|
||
&xcb->ewmh, xcb_stuff_get_root_window());
|
||
|
||
if (xcb_ewmh_get_supporting_wm_check_reply(&xcb->ewmh, cc, &wm_win, NULL)) {
|
||
xcb_ewmh_get_utf8_strings_reply_t wtitle;
|
||
xcb_get_property_cookie_t cookie =
|
||
xcb_ewmh_get_wm_name_unchecked(&(xcb->ewmh), wm_win);
|
||
if (xcb_ewmh_get_wm_name_reply(&(xcb->ewmh), cookie, &wtitle, (void *)0)) {
|
||
if (wtitle.strings_len > 0) {
|
||
retv = g_strndup(wtitle.strings, wtitle.strings_len);
|
||
}
|
||
xcb_ewmh_get_utf8_strings_reply_wipe(&wtitle);
|
||
}
|
||
}
|
||
return retv;
|
||
}
|
||
|
||
static void x11_helper_discover_window_manager(void) {
|
||
xcb_window_t wm_win = 0;
|
||
xcb_get_property_cookie_t cc = xcb_ewmh_get_supporting_wm_check_unchecked(
|
||
&xcb->ewmh, xcb_stuff_get_root_window());
|
||
|
||
if (xcb_ewmh_get_supporting_wm_check_reply(&xcb->ewmh, cc, &wm_win, NULL)) {
|
||
xcb_ewmh_get_utf8_strings_reply_t wtitle;
|
||
xcb_get_property_cookie_t cookie =
|
||
xcb_ewmh_get_wm_name_unchecked(&(xcb->ewmh), wm_win);
|
||
if (xcb_ewmh_get_wm_name_reply(&(xcb->ewmh), cookie, &wtitle, (void *)0)) {
|
||
if (wtitle.strings_len > 0) {
|
||
// Copy the string and add terminating '\0'.
|
||
char *str = g_strndup(wtitle.strings, wtitle.strings_len);
|
||
g_debug("Found window manager: |%s|", str);
|
||
if (g_strcmp0(str, "i3") == 0) {
|
||
current_window_manager =
|
||
WM_DO_NOT_CHANGE_CURRENT_DESKTOP | WM_PANGO_WORKSPACE_NAMES;
|
||
}
|
||
g_free(str);
|
||
}
|
||
xcb_ewmh_get_utf8_strings_reply_wipe(&wtitle);
|
||
}
|
||
}
|
||
}
|
||
|
||
gboolean display_setup(GMainLoop *main_loop, NkBindings *bindings) {
|
||
// Get DISPLAY, first env, then argument.
|
||
// We never modify display_str content.
|
||
char *display_str = (char *)g_getenv("DISPLAY");
|
||
find_arg_str("-display", &display_str);
|
||
|
||
xcb->main_loop = main_loop;
|
||
#ifdef XCB_IMDKIT
|
||
xcb_compound_text_init();
|
||
#endif
|
||
xcb->source = g_water_xcb_source_new(g_main_loop_get_context(xcb->main_loop),
|
||
display_str, &xcb->screen_nbr,
|
||
main_loop_x11_event_handler, NULL, NULL);
|
||
if (xcb->source == NULL) {
|
||
g_warning("Failed to open display: %s", display_str);
|
||
return FALSE;
|
||
}
|
||
xcb->connection = g_water_xcb_source_get_connection(xcb->source);
|
||
#ifdef XCB_IMDKIT
|
||
xcb->im = xcb_xim_create(xcb->connection, xcb->screen_nbr, NULL);
|
||
#endif
|
||
|
||
#ifdef XCB_IMDKIT
|
||
#ifndef XCB_IMDKIT_1_0_3_LOWER
|
||
xcb_xim_set_use_compound_text(xcb->im, true);
|
||
xcb_xim_set_use_utf8_string(xcb->im, true);
|
||
#endif
|
||
#endif
|
||
|
||
TICK_N("Open Display");
|
||
|
||
xcb->screen = xcb_aux_get_screen(xcb->connection, xcb->screen_nbr);
|
||
|
||
x11_build_monitor_layout();
|
||
|
||
xcb_intern_atom_cookie_t *ac =
|
||
xcb_ewmh_init_atoms(xcb->connection, &xcb->ewmh);
|
||
xcb_generic_error_t *errors = NULL;
|
||
xcb_ewmh_init_atoms_replies(&xcb->ewmh, ac, &errors);
|
||
if (errors) {
|
||
g_warning("Failed to create EWMH atoms");
|
||
free(errors);
|
||
}
|
||
// Discover the current active window manager.
|
||
x11_helper_discover_window_manager();
|
||
TICK_N("Setup XCB");
|
||
|
||
if (xkb_x11_setup_xkb_extension(
|
||
xcb->connection, XKB_X11_MIN_MAJOR_XKB_VERSION,
|
||
XKB_X11_MIN_MINOR_XKB_VERSION, XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS,
|
||
NULL, NULL, &xcb->xkb.first_event, NULL) < 0) {
|
||
g_warning("cannot setup XKB extension!");
|
||
return FALSE;
|
||
}
|
||
|
||
xcb->xkb.device_id = xkb_x11_get_core_keyboard_device_id(xcb->connection);
|
||
|
||
enum {
|
||
required_events =
|
||
(XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY |
|
||
XCB_XKB_EVENT_TYPE_MAP_NOTIFY | XCB_XKB_EVENT_TYPE_STATE_NOTIFY),
|
||
|
||
required_nkn_details = (XCB_XKB_NKN_DETAIL_KEYCODES),
|
||
|
||
required_map_parts =
|
||
(XCB_XKB_MAP_PART_KEY_TYPES | XCB_XKB_MAP_PART_KEY_SYMS |
|
||
XCB_XKB_MAP_PART_MODIFIER_MAP | XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS |
|
||
XCB_XKB_MAP_PART_KEY_ACTIONS | XCB_XKB_MAP_PART_VIRTUAL_MODS |
|
||
XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP),
|
||
|
||
required_state_details =
|
||
(XCB_XKB_STATE_PART_MODIFIER_BASE | XCB_XKB_STATE_PART_MODIFIER_LATCH |
|
||
XCB_XKB_STATE_PART_MODIFIER_LOCK | XCB_XKB_STATE_PART_GROUP_BASE |
|
||
XCB_XKB_STATE_PART_GROUP_LATCH | XCB_XKB_STATE_PART_GROUP_LOCK),
|
||
};
|
||
|
||
static const xcb_xkb_select_events_details_t details = {
|
||
.affectNewKeyboard = required_nkn_details,
|
||
.newKeyboardDetails = required_nkn_details,
|
||
.affectState = required_state_details,
|
||
.stateDetails = required_state_details,
|
||
};
|
||
xcb_xkb_select_events(xcb->connection, xcb->xkb.device_id,
|
||
required_events, /* affectWhich */
|
||
0, /* clear */
|
||
required_events, /* selectAll */
|
||
required_map_parts, /* affectMap */
|
||
required_map_parts, /* map */
|
||
&details);
|
||
|
||
xcb->bindings_seat = nk_bindings_seat_new(bindings, XKB_CONTEXT_NO_FLAGS);
|
||
struct xkb_keymap *keymap = xkb_x11_keymap_new_from_device(
|
||
nk_bindings_seat_get_context(xcb->bindings_seat), xcb->connection,
|
||
xcb->xkb.device_id, XKB_KEYMAP_COMPILE_NO_FLAGS);
|
||
if (keymap == NULL) {
|
||
g_warning("Failed to get Keymap for current keyboard device.");
|
||
return FALSE;
|
||
}
|
||
struct xkb_state *state = xkb_x11_state_new_from_device(
|
||
keymap, xcb->connection, xcb->xkb.device_id);
|
||
if (state == NULL) {
|
||
g_warning("Failed to get state object for current keyboard device.");
|
||
return FALSE;
|
||
}
|
||
|
||
nk_bindings_seat_update_keymap(xcb->bindings_seat, keymap, state);
|
||
xkb_state_unref(state);
|
||
xkb_keymap_unref(keymap);
|
||
|
||
// determine numlock mask so we can bind on keys with and without it
|
||
x11_create_frequently_used_atoms();
|
||
|
||
if (xcb_connection_has_error(xcb->connection)) {
|
||
g_warning("Connection has error");
|
||
return FALSE;
|
||
}
|
||
|
||
uint32_t val[] = {XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY};
|
||
|
||
xcb_change_window_attributes(xcb->connection, xcb_stuff_get_root_window(),
|
||
XCB_CW_EVENT_MASK, val);
|
||
|
||
// startup not.
|
||
xcb->sndisplay =
|
||
sn_xcb_display_new(xcb->connection, error_trap_push, error_trap_pop);
|
||
if (xcb_connection_has_error(xcb->connection)) {
|
||
g_warning("Connection has error");
|
||
return FALSE;
|
||
}
|
||
|
||
if (xcb->sndisplay != NULL) {
|
||
xcb->sncontext = sn_launchee_context_new_from_environment(xcb->sndisplay,
|
||
xcb->screen_nbr);
|
||
}
|
||
if (xcb_connection_has_error(xcb->connection)) {
|
||
g_warning("Connection has error");
|
||
return FALSE;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
static void x11_create_visual_and_colormap(void) {
|
||
xcb_depth_t *root_depth = NULL;
|
||
xcb_depth_iterator_t depth_iter;
|
||
for (depth_iter = xcb_screen_allowed_depths_iterator(xcb->screen);
|
||
depth_iter.rem; xcb_depth_next(&depth_iter)) {
|
||
xcb_depth_t *d = depth_iter.data;
|
||
|
||
xcb_visualtype_iterator_t visual_iter;
|
||
for (visual_iter = xcb_depth_visuals_iterator(d); visual_iter.rem;
|
||
xcb_visualtype_next(&visual_iter)) {
|
||
xcb_visualtype_t *v = visual_iter.data;
|
||
if ((v->bits_per_rgb_value == 8) && (d->depth == 32) &&
|
||
(v->_class == XCB_VISUAL_CLASS_TRUE_COLOR)) {
|
||
depth = d;
|
||
visual = v;
|
||
}
|
||
if (xcb->screen->root_visual == v->visual_id) {
|
||
root_depth = d;
|
||
root_visual = v;
|
||
}
|
||
}
|
||
}
|
||
if (visual != NULL) {
|
||
xcb_void_cookie_t c;
|
||
xcb_generic_error_t *e;
|
||
map = xcb_generate_id(xcb->connection);
|
||
c = xcb_create_colormap_checked(xcb->connection, XCB_COLORMAP_ALLOC_NONE,
|
||
map, xcb->screen->root, visual->visual_id);
|
||
e = xcb_request_check(xcb->connection, c);
|
||
if (e) {
|
||
depth = NULL;
|
||
visual = NULL;
|
||
free(e);
|
||
}
|
||
}
|
||
|
||
if (visual == NULL) {
|
||
depth = root_depth;
|
||
visual = root_visual;
|
||
map = xcb->screen->default_colormap;
|
||
}
|
||
}
|
||
|
||
static void x11_lookup_cursors(void) {
|
||
xcb_cursor_context_t *ctx;
|
||
|
||
if (xcb_cursor_context_new(xcb->connection, xcb->screen, &ctx) < 0) {
|
||
return;
|
||
}
|
||
|
||
for (int i = 0; i < NUM_CURSORS; ++i) {
|
||
cursors[i] = xcb_cursor_load_cursor(ctx, cursor_names[i].css_name);
|
||
|
||
if (cursors[i] == XCB_CURSOR_NONE) {
|
||
cursors[i] =
|
||
xcb_cursor_load_cursor(ctx, cursor_names[i].traditional_name);
|
||
}
|
||
}
|
||
|
||
xcb_cursor_context_free(ctx);
|
||
}
|
||
|
||
/** Retry count of grabbing keyboard. */
|
||
unsigned int lazy_grab_retry_count_kb = 0;
|
||
/** Retry count of grabbing pointer. */
|
||
unsigned int lazy_grab_retry_count_pt = 0;
|
||
static gboolean lazy_grab_pointer(G_GNUC_UNUSED gpointer data) {
|
||
// After 5 sec.
|
||
if (lazy_grab_retry_count_pt > (5 * 1000)) {
|
||
g_warning("Failed to grab pointer after %u times. Giving up.",
|
||
lazy_grab_retry_count_pt);
|
||
return G_SOURCE_REMOVE;
|
||
}
|
||
if (take_pointer(xcb_stuff_get_root_window(), 0)) {
|
||
return G_SOURCE_REMOVE;
|
||
}
|
||
lazy_grab_retry_count_pt++;
|
||
return G_SOURCE_CONTINUE;
|
||
}
|
||
static gboolean lazy_grab_keyboard(G_GNUC_UNUSED gpointer data) {
|
||
// After 5 sec.
|
||
if (lazy_grab_retry_count_kb > (5 * 1000)) {
|
||
g_warning("Failed to grab keyboard after %u times. Giving up.",
|
||
lazy_grab_retry_count_kb);
|
||
g_main_loop_quit(xcb->main_loop);
|
||
return G_SOURCE_REMOVE;
|
||
}
|
||
if (take_keyboard(xcb_stuff_get_root_window(), 0)) {
|
||
return G_SOURCE_REMOVE;
|
||
}
|
||
lazy_grab_retry_count_kb++;
|
||
return G_SOURCE_CONTINUE;
|
||
}
|
||
|
||
gboolean display_late_setup(void) {
|
||
x11_create_visual_and_colormap();
|
||
|
||
x11_lookup_cursors();
|
||
|
||
/**
|
||
* Create window (without showing)
|
||
*/
|
||
// Try to grab the keyboard as early as possible.
|
||
// We grab this using the rootwindow (as dmenu does it).
|
||
// this seems to result in the smallest delay for most people.
|
||
if (find_arg("-normal-window") >= 0 || find_arg("-transient-window") >= 0) {
|
||
return TRUE;
|
||
}
|
||
if (find_arg("-no-lazy-grab") >= 0) {
|
||
if (!take_keyboard(xcb_stuff_get_root_window(), 500)) {
|
||
g_warning("Failed to grab keyboard, even after %d uS.", 500 * 1000);
|
||
return FALSE;
|
||
}
|
||
if (!take_pointer(xcb_stuff_get_root_window(), 100)) {
|
||
g_warning("Failed to grab mouse pointer, even after %d uS.", 100 * 1000);
|
||
}
|
||
} else {
|
||
if (!take_keyboard(xcb_stuff_get_root_window(), 0)) {
|
||
g_timeout_add(1, lazy_grab_keyboard, NULL);
|
||
}
|
||
if (!take_pointer(xcb_stuff_get_root_window(), 0)) {
|
||
g_timeout_add(1, lazy_grab_pointer, NULL);
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
xcb_window_t xcb_stuff_get_root_window(void) { return xcb->screen->root; }
|
||
|
||
void display_early_cleanup(void) {
|
||
release_keyboard();
|
||
release_pointer();
|
||
xcb_flush(xcb->connection);
|
||
}
|
||
|
||
void display_cleanup(void) {
|
||
if (xcb->connection == NULL) {
|
||
return;
|
||
}
|
||
|
||
g_debug("Cleaning up XCB and XKB");
|
||
|
||
nk_bindings_seat_free(xcb->bindings_seat);
|
||
if (xcb->sncontext != NULL) {
|
||
sn_launchee_context_unref(xcb->sncontext);
|
||
xcb->sncontext = NULL;
|
||
}
|
||
if (xcb->sndisplay != NULL) {
|
||
sn_display_unref(xcb->sndisplay);
|
||
xcb->sndisplay = NULL;
|
||
}
|
||
x11_monitors_free();
|
||
xcb_ewmh_connection_wipe(&(xcb->ewmh));
|
||
xcb_flush(xcb->connection);
|
||
xcb_aux_sync(xcb->connection);
|
||
#ifdef XCB_IMDKIT
|
||
xcb_xim_close(xcb->im);
|
||
xcb_xim_destroy(xcb->im);
|
||
xcb->im = NULL;
|
||
#endif
|
||
g_water_xcb_source_free(xcb->source);
|
||
xcb->source = NULL;
|
||
xcb->connection = NULL;
|
||
xcb->screen = NULL;
|
||
xcb->screen_nbr = 0;
|
||
}
|
||
|
||
void x11_disable_decoration(xcb_window_t window) {
|
||
// Flag used to indicate we are setting the decoration type.
|
||
const uint32_t MWM_HINTS_DECORATIONS = (1 << 1);
|
||
// Motif property data structure
|
||
struct MotifWMHints {
|
||
uint32_t flags;
|
||
uint32_t functions;
|
||
uint32_t decorations;
|
||
int32_t inputMode;
|
||
uint32_t state;
|
||
};
|
||
|
||
struct MotifWMHints hints;
|
||
hints.flags = MWM_HINTS_DECORATIONS;
|
||
hints.decorations = 0;
|
||
hints.functions = 0;
|
||
hints.inputMode = 0;
|
||
hints.state = 0;
|
||
|
||
xcb_atom_t ha = netatoms[_MOTIF_WM_HINTS];
|
||
xcb_change_property(xcb->connection, XCB_PROP_MODE_REPLACE, window, ha, ha,
|
||
32, 5, &hints);
|
||
}
|
||
|
||
void x11_set_cursor(xcb_window_t window, X11CursorType type) {
|
||
if (type < 0 || type >= NUM_CURSORS) {
|
||
return;
|
||
}
|
||
|
||
if (cursors[type] == XCB_CURSOR_NONE) {
|
||
return;
|
||
}
|
||
|
||
xcb_change_window_attributes(xcb->connection, window, XCB_CW_CURSOR,
|
||
&(cursors[type]));
|
||
}
|
||
void xcb_stuff_set_clipboard(char *data) {
|
||
g_free(xcb->clipboard);
|
||
xcb->clipboard = data;
|
||
}
|