2015-02-12 21:34:06 +00:00
|
|
|
/**
|
|
|
|
* rofi
|
|
|
|
*
|
|
|
|
* MIT/X11 License
|
|
|
|
* Copyright (c) 2012 Sean Pringle <sean.pringle@gmail.com>
|
2015-12-31 23:27:00 +00:00
|
|
|
* Modified 2013-2016 Qball Cow <qball@gmpclient.org>
|
2015-02-12 21:34:06 +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.
|
|
|
|
*
|
|
|
|
*/
|
2015-02-09 18:35:51 +00:00
|
|
|
#include <config.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <glib.h>
|
2015-09-27 09:46:19 +00:00
|
|
|
#include <cairo.h>
|
2015-02-09 18:35:51 +00:00
|
|
|
|
2016-02-21 18:42:32 +00:00
|
|
|
#include <xcb/xcb.h>
|
2016-02-27 19:45:47 +00:00
|
|
|
#include <xcb/xinerama.h>
|
2016-02-27 18:26:51 +00:00
|
|
|
#include <xcb/xcb_ewmh.h>
|
2016-01-07 15:01:56 +00:00
|
|
|
#include "settings.h"
|
2015-02-09 18:35:51 +00:00
|
|
|
|
2015-04-06 15:13:26 +00:00
|
|
|
#include <rofi.h>
|
2015-09-19 10:21:30 +00:00
|
|
|
#define OVERLAP( a, b, c, \
|
|
|
|
d ) ( ( ( a ) == ( c ) && \
|
|
|
|
( b ) == ( d ) ) || \
|
|
|
|
MIN ( ( a ) + ( b ), ( c ) + ( d ) ) - MAX ( ( a ), ( c ) ) > 0 )
|
|
|
|
#define INTERSECT( x, y, w, h, x1, y1, w1, \
|
|
|
|
h1 ) ( OVERLAP ( ( x ), ( w ), ( x1 ), \
|
|
|
|
( w1 ) ) && OVERLAP ( ( y ), ( h ), ( y1 ), ( h1 ) ) )
|
2015-02-09 18:35:51 +00:00
|
|
|
#include "x11-helper.h"
|
2016-02-23 09:44:36 +00:00
|
|
|
#include "xkb-internal.h"
|
2015-02-09 18:35:51 +00:00
|
|
|
|
2016-02-23 09:44:36 +00:00
|
|
|
enum
|
|
|
|
{
|
|
|
|
X11MOD_SHIFT,
|
|
|
|
X11MOD_CONTROL,
|
|
|
|
X11MOD_ALT,
|
2016-02-23 09:47:09 +00:00
|
|
|
X11MOD_META,
|
|
|
|
X11MOD_SUPER,
|
|
|
|
X11MOD_HYPER,
|
2016-02-23 09:44:36 +00:00
|
|
|
X11MOD_ANY,
|
|
|
|
NUM_X11MOD
|
|
|
|
};
|
|
|
|
|
2016-02-21 18:42:32 +00:00
|
|
|
xcb_depth_t *depth = NULL;
|
|
|
|
xcb_visualtype_t *visual = NULL;
|
|
|
|
xcb_colormap_t map = XCB_COLORMAP_NONE;
|
|
|
|
xcb_depth_t *root_depth = NULL;
|
|
|
|
xcb_visualtype_t *root_visual = NULL;
|
2016-02-27 23:09:05 +00:00
|
|
|
xcb_atom_t netatoms[NUM_NETATOMS];
|
2016-02-23 09:44:36 +00:00
|
|
|
const char *netatom_names[] = { EWMH_ATOMS ( ATOM_CHAR ) };
|
|
|
|
static unsigned int x11_mod_masks[NUM_X11MOD];
|
2016-02-27 18:26:51 +00:00
|
|
|
extern xcb_ewmh_connection_t xcb_ewmh;
|
2016-02-23 09:44:36 +00:00
|
|
|
|
2016-02-27 18:51:06 +00:00
|
|
|
extern xcb_connection_t *xcb_connection;
|
|
|
|
|
2015-02-09 18:35:51 +00:00
|
|
|
// retrieve a text property from a window
|
|
|
|
// technically we could use window_get_prop(), but this is better for character set support
|
2016-02-27 23:09:05 +00:00
|
|
|
char* window_get_text_prop ( xcb_connection_t *xcb_connection, xcb_window_t w, Atom atom )
|
2015-02-09 18:35:51 +00:00
|
|
|
{
|
2016-02-27 23:09:05 +00:00
|
|
|
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 ){
|
|
|
|
char *str = g_malloc ( xcb_get_property_value_length(r)+1);
|
|
|
|
memcpy(str, xcb_get_property_value(r), xcb_get_property_value_length(r));
|
|
|
|
str[xcb_get_property_value_length(r)] = '\0';
|
|
|
|
free(r);
|
|
|
|
return str;
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
2016-02-27 23:09:05 +00:00
|
|
|
return NULL;
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
|
|
|
|
2016-02-27 23:09:05 +00:00
|
|
|
void window_set_atom_prop ( xcb_connection_t *xcb_connection, xcb_window_t w, xcb_atom_t prop, xcb_atom_t *atoms, int count )
|
2015-02-09 18:35:51 +00:00
|
|
|
{
|
2016-02-27 16:42:50 +00:00
|
|
|
xcb_change_property ( xcb_connection, XCB_PROP_MODE_REPLACE, w, prop, XCB_ATOM_ATOM, 32, count, atoms);
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
|
|
|
|
2016-02-27 19:45:47 +00:00
|
|
|
extern xcb_screen_t *xcb_screen;
|
|
|
|
extern int xcb_screen_nbr;
|
|
|
|
int monitor_get_smallest_size ( xcb_connection_t *xcb_connection )
|
2015-10-18 11:40:39 +00:00
|
|
|
{
|
2016-02-27 19:45:47 +00:00
|
|
|
xcb_generic_error_t *error;
|
|
|
|
int size = MIN (xcb_screen->width_in_pixels, xcb_screen->height_in_pixels);
|
|
|
|
xcb_xinerama_is_active_cookie_t is_active_req = xcb_xinerama_is_active(xcb_connection);
|
|
|
|
xcb_xinerama_is_active_reply_t *is_active = xcb_xinerama_is_active_reply(xcb_connection, is_active_req, &error);
|
|
|
|
if (error) {
|
|
|
|
fprintf(stderr, "Couldn't query Xinerama\n");
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
if (!is_active->state) {
|
|
|
|
free ( is_active );
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
free ( is_active );
|
2015-02-09 18:35:51 +00:00
|
|
|
|
2016-02-27 19:45:47 +00:00
|
|
|
xcb_xinerama_query_screens_cookie_t cookie_screen;
|
|
|
|
cookie_screen = xcb_xinerama_query_screens(xcb_connection);
|
|
|
|
xcb_xinerama_query_screens_reply_t *query_screens;
|
|
|
|
query_screens = xcb_xinerama_query_screens_reply(xcb_connection, cookie_screen, &error);
|
|
|
|
if (error) {
|
|
|
|
fprintf(stderr, "Error getting screen info\n");
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
xcb_xinerama_screen_info_t *screens = xcb_xinerama_query_screens_screen_info(query_screens);
|
|
|
|
int len = xcb_xinerama_query_screens_screen_info_length(query_screens);
|
|
|
|
for (int i = 0; i < len; i++) {
|
|
|
|
xcb_xinerama_screen_info_t *info = &screens[i];
|
|
|
|
size = MIN ( info->width, size );
|
|
|
|
size = MIN ( info->height, size );
|
2015-10-18 11:40:39 +00:00
|
|
|
}
|
2016-02-27 19:45:47 +00:00
|
|
|
free(query_screens);
|
2015-10-18 11:40:39 +00:00
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
2016-02-27 19:45:47 +00:00
|
|
|
int monitor_get_dimension ( xcb_connection_t *xcb_connection, xcb_screen_t *screen, int monitor, workarea *mon )
|
2015-08-02 13:45:52 +00:00
|
|
|
{
|
2016-02-27 19:45:47 +00:00
|
|
|
xcb_generic_error_t *error = NULL;
|
2015-08-02 13:45:52 +00:00
|
|
|
memset ( mon, 0, sizeof ( workarea ) );
|
2016-02-27 19:45:47 +00:00
|
|
|
mon->w = screen->width_in_pixels;
|
|
|
|
mon->h = screen->height_in_pixels;
|
2015-08-02 13:45:52 +00:00
|
|
|
|
2016-02-27 19:45:47 +00:00
|
|
|
xcb_xinerama_is_active_cookie_t is_active_req = xcb_xinerama_is_active(xcb_connection);
|
|
|
|
xcb_xinerama_is_active_reply_t *is_active = xcb_xinerama_is_active_reply(xcb_connection, is_active_req, &error);
|
|
|
|
if (error) {
|
|
|
|
fprintf(stderr, "Error getting screen info\n");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
if (!is_active->state) {
|
|
|
|
free ( is_active );
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
free ( is_active );
|
|
|
|
|
|
|
|
xcb_xinerama_query_screens_cookie_t cookie_screen;
|
|
|
|
cookie_screen = xcb_xinerama_query_screens(xcb_connection);
|
|
|
|
xcb_xinerama_query_screens_reply_t *query_screens;
|
|
|
|
query_screens = xcb_xinerama_query_screens_reply(xcb_connection, cookie_screen, &error);
|
|
|
|
if (error) {
|
|
|
|
fprintf(stderr, "Error getting screen info\n");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
xcb_xinerama_screen_info_t *screens = xcb_xinerama_query_screens_screen_info(query_screens);
|
|
|
|
int len = xcb_xinerama_query_screens_screen_info_length(query_screens);
|
|
|
|
if ( monitor < len ) {
|
|
|
|
xcb_xinerama_screen_info_t *info = &screens[monitor];
|
|
|
|
mon->w = info->width;
|
|
|
|
mon->h = info->height;
|
|
|
|
mon->x = info->x_org;
|
|
|
|
mon->y = info->y_org;
|
|
|
|
free(query_screens);
|
|
|
|
return TRUE;
|
2015-08-02 13:45:52 +00:00
|
|
|
}
|
2016-02-27 19:45:47 +00:00
|
|
|
free(query_screens);
|
|
|
|
|
2015-08-02 13:45:52 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2015-02-09 18:35:51 +00:00
|
|
|
// find the dimensions of the monitor displaying point x,y
|
2016-02-27 19:45:47 +00:00
|
|
|
void monitor_dimensions ( xcb_connection_t *xcb_connection, xcb_screen_t *screen, int x, int y, workarea *mon )
|
2015-02-09 18:35:51 +00:00
|
|
|
{
|
2016-02-27 19:45:47 +00:00
|
|
|
xcb_generic_error_t *error = NULL;
|
2015-02-09 18:35:51 +00:00
|
|
|
memset ( mon, 0, sizeof ( workarea ) );
|
2016-02-27 19:45:47 +00:00
|
|
|
mon->w = screen->width_in_pixels;
|
|
|
|
mon->h = screen->height_in_pixels;
|
2015-02-09 18:35:51 +00:00
|
|
|
|
2016-02-27 19:45:47 +00:00
|
|
|
xcb_xinerama_is_active_cookie_t is_active_req = xcb_xinerama_is_active(xcb_connection);
|
|
|
|
xcb_xinerama_is_active_reply_t *is_active = xcb_xinerama_is_active_reply(xcb_connection, is_active_req, &error);
|
|
|
|
if (error) {
|
|
|
|
fprintf(stderr, "Couldn't query Xinerama\n");
|
|
|
|
return ;
|
|
|
|
}
|
|
|
|
if (!is_active->state) {
|
|
|
|
free ( is_active );
|
|
|
|
return ;
|
|
|
|
}
|
|
|
|
free ( is_active );
|
2015-02-09 18:35:51 +00:00
|
|
|
|
2016-02-27 19:45:47 +00:00
|
|
|
xcb_xinerama_query_screens_cookie_t cookie_screen;
|
|
|
|
cookie_screen = xcb_xinerama_query_screens(xcb_connection);
|
|
|
|
xcb_xinerama_query_screens_reply_t *query_screens;
|
|
|
|
query_screens = xcb_xinerama_query_screens_reply(xcb_connection, cookie_screen, &error);
|
|
|
|
if (error) {
|
|
|
|
fprintf(stderr, "Error getting screen info\n");
|
|
|
|
return ;
|
|
|
|
}
|
|
|
|
xcb_xinerama_screen_info_t *screens = xcb_xinerama_query_screens_screen_info(query_screens);
|
|
|
|
int len = xcb_xinerama_query_screens_screen_info_length(query_screens);
|
|
|
|
for ( int i = 0; i < len; i++){
|
|
|
|
xcb_xinerama_screen_info_t *info = &screens[i];
|
|
|
|
if ( INTERSECT ( x, y, 1, 1, info->x_org, info->y_org, info->width, info->height ) ) {
|
|
|
|
mon->w = info->width;
|
|
|
|
mon->h = info->height;
|
|
|
|
mon->x = info->x_org;
|
|
|
|
mon->y = info->y_org;
|
|
|
|
break;
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
|
|
|
}
|
2016-02-27 19:45:47 +00:00
|
|
|
free(query_screens);
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param x The x position of the mouse [out]
|
|
|
|
* @param y The y position of the mouse [out]
|
|
|
|
*
|
|
|
|
* find mouse pointer location
|
|
|
|
*
|
|
|
|
* @returns 1 when found
|
|
|
|
*/
|
2016-02-27 23:09:05 +00:00
|
|
|
static int pointer_get ( xcb_connection_t *xcb_connection, xcb_window_t root, int *x, int *y )
|
2015-02-09 18:35:51 +00:00
|
|
|
{
|
|
|
|
*x = 0;
|
|
|
|
*y = 0;
|
2016-02-27 18:51:06 +00:00
|
|
|
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);
|
2015-02-09 18:35:51 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// determine which monitor holds the active window, or failing that the mouse pointer
|
2016-02-27 19:45:47 +00:00
|
|
|
void monitor_active ( xcb_connection_t *xcb_connection, workarea *mon )
|
2015-02-09 18:35:51 +00:00
|
|
|
{
|
2016-02-27 19:45:47 +00:00
|
|
|
xcb_window_t root = xcb_screen->root;
|
2015-02-09 18:35:51 +00:00
|
|
|
int x, y;
|
|
|
|
|
2015-08-02 13:45:52 +00:00
|
|
|
if ( config.monitor >= 0 ) {
|
2016-02-27 19:45:47 +00:00
|
|
|
if ( monitor_get_dimension ( xcb_connection, xcb_screen, config.monitor, mon ) ) {
|
2015-08-02 13:45:52 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
fprintf ( stderr, "Failed to find selected monitor.\n" );
|
|
|
|
}
|
2016-02-09 20:25:29 +00:00
|
|
|
// Get the current desktop.
|
2016-02-27 18:26:51 +00:00
|
|
|
unsigned int current_desktop = 0;
|
|
|
|
if ( config.monitor != -2 && xcb_ewmh_get_current_desktop_reply ( &xcb_ewmh,
|
2016-02-27 19:45:47 +00:00
|
|
|
xcb_ewmh_get_current_desktop( &xcb_ewmh, xcb_screen_nbr), ¤t_desktop, NULL )) {
|
2016-02-28 10:57:52 +00:00
|
|
|
xcb_get_property_cookie_t c = xcb_ewmh_get_desktop_viewport(&xcb_ewmh, xcb_screen_nbr);
|
2016-02-27 18:26:51 +00:00
|
|
|
xcb_ewmh_get_desktop_viewport_reply_t vp;
|
2016-02-28 10:57:52 +00:00
|
|
|
if ( xcb_ewmh_get_desktop_viewport_reply ( &xcb_ewmh, c, &vp, NULL)){
|
2016-02-27 18:26:51 +00:00
|
|
|
if ( current_desktop < vp.desktop_viewport_len) {
|
2016-02-27 19:45:47 +00:00
|
|
|
monitor_dimensions ( xcb_connection, xcb_screen, vp.desktop_viewport[current_desktop].x,
|
2016-02-27 18:26:51 +00:00
|
|
|
vp.desktop_viewport[current_desktop].y, mon );
|
2016-02-28 10:57:52 +00:00
|
|
|
xcb_ewmh_get_desktop_viewport_reply_wipe(&vp);
|
2016-02-09 20:25:29 +00:00
|
|
|
return;
|
|
|
|
}
|
2016-02-28 10:57:52 +00:00
|
|
|
xcb_ewmh_get_desktop_viewport_reply_wipe(&vp);
|
2016-02-09 20:25:29 +00:00
|
|
|
}
|
|
|
|
}
|
2016-02-27 18:26:51 +00:00
|
|
|
|
|
|
|
xcb_window_t active_window;
|
|
|
|
if ( xcb_ewmh_get_active_window_reply ( &xcb_ewmh,
|
2016-02-27 19:45:47 +00:00
|
|
|
xcb_ewmh_get_active_window( &xcb_ewmh, xcb_screen_nbr), &active_window, NULL )) {
|
2016-02-27 18:26:51 +00:00
|
|
|
// 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 ) {
|
|
|
|
if ( config.monitor == -2 ) {
|
|
|
|
xcb_translate_coordinates_cookie_t ct = xcb_translate_coordinates(xcb_connection, active_window, root, r->x, r->y);
|
|
|
|
xcb_translate_coordinates_reply_t *t = xcb_translate_coordinates_reply (xcb_connection, ct, NULL);
|
|
|
|
if ( t ){
|
2015-08-17 16:32:17 +00:00
|
|
|
// place the menu above the window
|
|
|
|
// if some window is focused, place menu above window, else fall
|
|
|
|
// back to selected monitor.
|
2016-02-27 18:26:51 +00:00
|
|
|
mon->x = t->dst_x;
|
|
|
|
mon->y = t->dst_y;
|
|
|
|
mon->w = r->width;
|
|
|
|
mon->h = r->height;
|
|
|
|
mon->t = r->border_width;
|
|
|
|
mon->b = r->border_width;
|
|
|
|
mon->l = r->border_width;
|
|
|
|
mon->r = r->border_width;
|
|
|
|
free(r);
|
|
|
|
free(t);
|
2015-08-17 16:32:17 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
2016-02-27 19:45:47 +00:00
|
|
|
monitor_dimensions ( xcb_connection, xcb_screen, r->x, r->y, mon );
|
2016-02-27 18:26:51 +00:00
|
|
|
free(r);
|
|
|
|
return;
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
|
|
|
}
|
2016-02-27 19:45:47 +00:00
|
|
|
if ( pointer_get ( xcb_connection, root, &x, &y ) ) {
|
|
|
|
monitor_dimensions ( xcb_connection, xcb_screen, x, y, mon );
|
2015-02-09 18:35:51 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-02-27 19:45:47 +00:00
|
|
|
monitor_dimensions ( xcb_connection, xcb_screen, 0, 0, mon );
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
|
|
|
|
2016-02-27 23:09:05 +00:00
|
|
|
int take_keyboard ( xcb_connection_t *xcb_connection, xcb_window_t w )
|
2015-02-09 18:35:51 +00:00
|
|
|
{
|
2016-02-27 23:09:05 +00:00
|
|
|
|
2015-05-03 11:04:03 +00:00
|
|
|
for ( int i = 0; i < 500; i++ ) {
|
2016-02-28 09:36:13 +00:00
|
|
|
xcb_grab_keyboard_cookie_t cc = xcb_grab_keyboard ( xcb_connection,
|
|
|
|
1, w, XCB_CURRENT_TIME, XCB_GRAB_MODE_ASYNC,
|
2016-02-27 23:09:05 +00:00
|
|
|
XCB_GRAB_MODE_ASYNC);
|
|
|
|
xcb_grab_keyboard_reply_t *r = xcb_grab_keyboard_reply ( xcb_connection, cc, NULL);
|
|
|
|
if ( r ) {
|
2016-02-28 09:36:13 +00:00
|
|
|
if ( r->status == XCB_GRAB_STATUS_SUCCESS) {
|
|
|
|
free(r);
|
|
|
|
return 1;
|
|
|
|
}
|
2016-02-27 23:09:05 +00:00
|
|
|
free ( r );
|
2015-05-02 10:42:36 +00:00
|
|
|
}
|
|
|
|
usleep ( 1000 );
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-27 23:09:05 +00:00
|
|
|
void release_keyboard ( xcb_connection_t *xcb_connection )
|
2015-02-09 18:35:51 +00:00
|
|
|
{
|
2016-02-27 23:09:05 +00:00
|
|
|
xcb_ungrab_keyboard ( xcb_connection, XCB_CURRENT_TIME);
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
|
|
|
|
2016-02-22 10:39:52 +00:00
|
|
|
static unsigned int x11_find_mod_mask ( xkb_stuff *xkb, ... )
|
2015-02-09 18:35:51 +00:00
|
|
|
{
|
2016-02-22 10:39:52 +00:00
|
|
|
va_list names;
|
|
|
|
const char *name;
|
|
|
|
xkb_mod_index_t i;
|
|
|
|
unsigned int mask = 0;
|
|
|
|
va_start ( names, xkb );
|
|
|
|
while ( ( name = va_arg ( names, const char * ) ) != NULL ) {
|
|
|
|
i = xkb_keymap_mod_get_index ( xkb->keymap, name );
|
|
|
|
if ( i != XKB_MOD_INVALID ) {
|
|
|
|
mask |= 1 << i;
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
|
|
|
}
|
2016-02-22 10:39:52 +00:00
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void x11_figure_out_masks ( xkb_stuff *xkb )
|
|
|
|
{
|
|
|
|
x11_mod_masks[X11MOD_SHIFT] = x11_find_mod_mask ( xkb, XKB_MOD_NAME_SHIFT, NULL );
|
|
|
|
x11_mod_masks[X11MOD_CONTROL] = x11_find_mod_mask ( xkb, XKB_MOD_NAME_CTRL, "RControl", "LControl", NULL );
|
|
|
|
x11_mod_masks[X11MOD_ALT] = x11_find_mod_mask ( xkb, XKB_MOD_NAME_ALT, "Alt", "LAlt", "RAlt", "AltGr", "Mod5", "LevelThree", NULL );
|
|
|
|
x11_mod_masks[X11MOD_META] = x11_find_mod_mask ( xkb, "Meta", NULL );
|
|
|
|
x11_mod_masks[X11MOD_SUPER] = x11_find_mod_mask ( xkb, XKB_MOD_NAME_LOGO, "Super", NULL );
|
|
|
|
x11_mod_masks[X11MOD_HYPER] = x11_find_mod_mask ( xkb, "Hyper", NULL );
|
2016-02-23 09:44:36 +00:00
|
|
|
|
|
|
|
gsize i;
|
|
|
|
for ( i = 0; i < X11MOD_ANY; ++i ) {
|
2016-02-22 10:39:52 +00:00
|
|
|
x11_mod_masks[X11MOD_ANY] |= x11_mod_masks[i];
|
2016-02-23 09:44:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int x11_canonalize_mask ( unsigned int mask )
|
|
|
|
{
|
|
|
|
// Bits 13 and 14 of the modifiers together are the group number, and
|
|
|
|
// should be ignored when looking up key bindings
|
2016-02-22 10:39:52 +00:00
|
|
|
mask &= x11_mod_masks[X11MOD_ANY];
|
2016-02-23 09:44:36 +00:00
|
|
|
|
|
|
|
gsize i;
|
|
|
|
for ( i = 0; i < X11MOD_ANY; ++i ) {
|
2016-02-22 10:39:52 +00:00
|
|
|
if ( mask & x11_mod_masks[i] ) {
|
|
|
|
mask |= x11_mod_masks[i];
|
2016-02-23 09:44:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return mask;
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// convert a Mod+key arg to mod mask and keysym
|
2016-02-21 12:10:32 +00:00
|
|
|
void x11_parse_key ( char *combo, unsigned int *mod, xkb_keysym_t *key )
|
2015-02-09 18:35:51 +00:00
|
|
|
{
|
2015-11-20 21:22:11 +00:00
|
|
|
GString *str = g_string_new ( "" );
|
2015-02-09 18:35:51 +00:00
|
|
|
unsigned int modmask = 0;
|
|
|
|
|
|
|
|
if ( strcasestr ( combo, "shift" ) ) {
|
2016-02-23 09:44:36 +00:00
|
|
|
modmask |= x11_mod_masks[X11MOD_SHIFT];
|
2016-02-22 10:39:52 +00:00
|
|
|
if ( x11_mod_masks[X11MOD_SHIFT] == 0 ) {
|
|
|
|
g_string_append_printf ( str, "X11 configured keyboard has no <b>Shift</b> key.\n" );
|
|
|
|
}
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
|
|
|
if ( strcasestr ( combo, "control" ) ) {
|
2016-02-23 09:44:36 +00:00
|
|
|
modmask |= x11_mod_masks[X11MOD_CONTROL];
|
2016-02-22 10:39:52 +00:00
|
|
|
if ( x11_mod_masks[X11MOD_CONTROL] == 0 ) {
|
|
|
|
g_string_append_printf ( str, "X11 configured keyboard has no <b>Control</b> key.\n" );
|
|
|
|
}
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
|
|
|
if ( strcasestr ( combo, "alt" ) ) {
|
2016-02-23 09:44:36 +00:00
|
|
|
modmask |= x11_mod_masks[X11MOD_ALT];
|
|
|
|
if ( x11_mod_masks[X11MOD_ALT] == 0 ) {
|
2015-11-20 21:22:11 +00:00
|
|
|
g_string_append_printf ( str, "X11 configured keyboard has no <b>Alt</b> key.\n" );
|
2015-11-20 21:00:37 +00:00
|
|
|
}
|
|
|
|
}
|
2016-02-23 09:47:09 +00:00
|
|
|
if ( strcasestr ( combo, "super" ) ) {
|
|
|
|
modmask |= x11_mod_masks[X11MOD_SUPER];
|
|
|
|
if ( x11_mod_masks[X11MOD_SUPER] == 0 ) {
|
|
|
|
g_string_append_printf ( str, "X11 configured keyboard has no <b>Super</b> key.\n" );
|
2015-11-20 21:00:37 +00:00
|
|
|
}
|
|
|
|
}
|
2016-02-23 09:47:09 +00:00
|
|
|
if ( strcasestr ( combo, "meta" ) ) {
|
|
|
|
modmask |= x11_mod_masks[X11MOD_META];
|
|
|
|
if ( x11_mod_masks[X11MOD_META] == 0 ) {
|
|
|
|
g_string_append_printf ( str, "X11 configured keyboard has no <b>Meta</b> key.\n" );
|
2015-11-20 21:00:37 +00:00
|
|
|
}
|
|
|
|
}
|
2016-02-23 09:47:09 +00:00
|
|
|
if ( strcasestr ( combo, "hyper" ) ) {
|
|
|
|
modmask |= x11_mod_masks[X11MOD_HYPER];
|
|
|
|
if ( x11_mod_masks[X11MOD_HYPER] == 0 ) {
|
|
|
|
g_string_append_printf ( str, "X11 configured keyboard has no <b>Hyper</b> key.\n" );
|
2015-11-20 21:00:37 +00:00
|
|
|
}
|
|
|
|
}
|
2015-12-04 07:54:27 +00:00
|
|
|
int seen_mod = FALSE;
|
2015-12-04 08:50:53 +00:00
|
|
|
if ( strcasestr ( combo, "Mod" ) ) {
|
2015-12-04 07:54:27 +00:00
|
|
|
seen_mod = TRUE;
|
|
|
|
}
|
2015-02-09 18:35:51 +00:00
|
|
|
|
2015-02-16 01:03:26 +00:00
|
|
|
*mod = modmask;
|
2015-02-09 18:35:51 +00:00
|
|
|
|
|
|
|
// Skip modifier (if exist) and parse key.
|
|
|
|
char i = strlen ( combo );
|
|
|
|
|
|
|
|
while ( i > 0 && !strchr ( "-+", combo[i - 1] ) ) {
|
|
|
|
i--;
|
|
|
|
}
|
|
|
|
|
2016-02-21 12:10:32 +00:00
|
|
|
xkb_keysym_t sym = xkb_keysym_from_name ( combo + i, XKB_KEYSYM_CASE_INSENSITIVE );
|
2015-02-09 18:35:51 +00:00
|
|
|
|
2016-02-21 12:10:32 +00:00
|
|
|
if ( sym == XKB_KEY_NoSymbol || ( !modmask && ( strchr ( combo, '-' ) || strchr ( combo, '+' ) ) ) ) {
|
2015-11-20 21:22:11 +00:00
|
|
|
g_string_append_printf ( str, "Sorry, rofi cannot understand the key combination: <i>%s</i>\n", combo );
|
2015-12-04 08:50:53 +00:00
|
|
|
g_string_append ( str, "\nRofi supports the following modifiers:\n\t" );
|
|
|
|
g_string_append ( str, "<i>Shift,Control,Alt,AltGR,SuperL,SuperR," );
|
|
|
|
g_string_append ( str, "MetaL,MetaR,HyperL,HyperR</i>" );
|
|
|
|
if ( seen_mod ) {
|
|
|
|
g_string_append ( str, "\n\n<b>Mod1,Mod2,Mod3,Mod4,Mod5 are no longer supported, use one of the above.</b>" );
|
2015-12-04 07:54:27 +00:00
|
|
|
}
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
2015-11-20 21:22:11 +00:00
|
|
|
if ( str->len > 0 ) {
|
|
|
|
show_error_message ( str->str, TRUE );
|
|
|
|
g_string_free ( str, TRUE );
|
2016-02-19 18:29:06 +00:00
|
|
|
return;
|
2015-11-20 21:22:11 +00:00
|
|
|
}
|
|
|
|
g_string_free ( str, TRUE );
|
2015-02-09 18:35:51 +00:00
|
|
|
*key = sym;
|
|
|
|
}
|
|
|
|
|
2016-02-27 23:09:05 +00:00
|
|
|
void x11_set_window_opacity ( xcb_connection_t *xcb_connection, xcb_window_t box, unsigned int opacity )
|
2015-02-09 18:35:51 +00:00
|
|
|
{
|
2015-02-10 07:12:03 +00:00
|
|
|
// Scale 0-100 to 0 - UINT32_MAX.
|
2015-02-09 18:35:51 +00:00
|
|
|
unsigned int opacity_set = ( unsigned int ) ( ( opacity / 100.0 ) * UINT32_MAX );
|
2016-02-27 20:55:43 +00:00
|
|
|
|
|
|
|
xcb_change_property( xcb_connection, XCB_PROP_MODE_REPLACE, box,
|
|
|
|
netatoms[_NET_WM_WINDOW_OPACITY], XCB_ATOM_CARDINAL, 32, 1L, &opacity_set);
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
|
|
|
|
2015-02-10 07:12:03 +00:00
|
|
|
/**
|
|
|
|
* @param display The connection to the X server.
|
|
|
|
*
|
|
|
|
* Fill in the list of Atoms.
|
|
|
|
*/
|
2016-02-27 23:09:05 +00:00
|
|
|
static void x11_create_frequently_used_atoms ( xcb_connection_t *xcb_connection )
|
2015-02-09 18:35:51 +00:00
|
|
|
{
|
2016-02-27 23:09:05 +00:00
|
|
|
// X atom values
|
2015-02-09 18:35:51 +00:00
|
|
|
for ( int i = 0; i < NUM_NETATOMS; i++ ) {
|
2016-02-27 23:09:05 +00:00
|
|
|
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);
|
|
|
|
}
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-02-27 23:09:05 +00:00
|
|
|
void x11_setup ( xcb_connection_t *xcb_connection, xkb_stuff *xkb )
|
2015-02-09 18:35:51 +00:00
|
|
|
{
|
|
|
|
// determine numlock mask so we can bind on keys with and without it
|
2016-02-22 10:39:52 +00:00
|
|
|
x11_figure_out_masks ( xkb );
|
2016-02-27 23:09:05 +00:00
|
|
|
x11_create_frequently_used_atoms ( xcb_connection );
|
2015-02-09 18:35:51 +00:00
|
|
|
}
|
2015-02-14 18:42:04 +00:00
|
|
|
|
2016-02-21 18:42:32 +00:00
|
|
|
void x11_create_visual_and_colormap ( xcb_connection_t *xcb_connection, xcb_screen_t *xcb_screen )
|
2015-02-14 18:42:04 +00:00
|
|
|
{
|
2016-02-21 18:42:32 +00:00
|
|
|
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 ( ( 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;
|
2015-02-14 18:42:04 +00:00
|
|
|
}
|
|
|
|
}
|
2015-09-27 09:46:19 +00:00
|
|
|
|
2016-02-21 18:42:32 +00:00
|
|
|
Color color_get ( const char *const name )
|
2015-02-14 18:42:04 +00:00
|
|
|
{
|
2016-02-21 18:42:32 +00:00
|
|
|
char *copy = g_strdup ( name );
|
|
|
|
char *cname = g_strstrip ( copy );
|
|
|
|
|
|
|
|
union
|
|
|
|
{
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
uint8_t b;
|
|
|
|
uint8_t g;
|
|
|
|
uint8_t r;
|
|
|
|
uint8_t a;
|
|
|
|
};
|
|
|
|
uint32_t pixel;
|
|
|
|
} color = {
|
|
|
|
.r = 0xff,
|
|
|
|
.g = 0xff,
|
|
|
|
.b = 0xff,
|
|
|
|
.a = 0xff,
|
|
|
|
};
|
2015-02-14 18:42:04 +00:00
|
|
|
// Special format.
|
2015-10-10 11:43:28 +00:00
|
|
|
if ( strncmp ( cname, "argb:", 5 ) == 0 ) {
|
|
|
|
color.pixel = strtoul ( &cname[5], NULL, 16 );
|
2015-02-14 18:42:04 +00:00
|
|
|
}
|
2016-02-21 18:42:32 +00:00
|
|
|
else if ( strncmp ( cname, "#", 1 ) == 0 ) {
|
|
|
|
color.pixel = strtoul ( &cname[1], NULL, 16 );
|
|
|
|
color.a = 0xff;
|
2015-02-14 18:42:04 +00:00
|
|
|
}
|
2015-10-10 11:43:28 +00:00
|
|
|
g_free ( copy );
|
2016-02-21 18:27:53 +00:00
|
|
|
|
|
|
|
Color ret = {
|
2016-02-21 18:42:32 +00:00
|
|
|
.red = color.r / 255.0,
|
|
|
|
.green = color.g / 255.0,
|
|
|
|
.blue = color.b / 255.0,
|
|
|
|
.alpha = color.a / 255.0,
|
2016-02-21 18:27:53 +00:00
|
|
|
};
|
|
|
|
return ret;
|
2015-02-14 18:42:04 +00:00
|
|
|
}
|
2016-02-21 18:27:53 +00:00
|
|
|
|
|
|
|
void x11_helper_set_cairo_rgba ( cairo_t *d, Color col )
|
2015-10-10 11:03:11 +00:00
|
|
|
{
|
2016-02-21 18:27:53 +00:00
|
|
|
cairo_set_source_rgba ( d, col.red, col.green, col.blue, col.alpha );
|
2015-10-10 11:03:11 +00:00
|
|
|
}
|
2015-10-10 12:15:27 +00:00
|
|
|
/**
|
|
|
|
* Color cache.
|
|
|
|
*
|
|
|
|
* This stores the current color until
|
|
|
|
*/
|
|
|
|
enum
|
|
|
|
{
|
|
|
|
BACKGROUND,
|
|
|
|
BORDER,
|
|
|
|
SEPARATOR
|
|
|
|
};
|
2016-02-21 18:27:53 +00:00
|
|
|
static struct
|
2015-10-10 12:15:27 +00:00
|
|
|
{
|
2016-02-21 18:27:53 +00:00
|
|
|
Color color;
|
2015-10-10 12:15:27 +00:00
|
|
|
unsigned int set;
|
2016-02-21 18:27:53 +00:00
|
|
|
} color_cache[3];
|
|
|
|
|
2015-10-10 12:15:27 +00:00
|
|
|
void color_cache_reset ( void )
|
|
|
|
{
|
|
|
|
color_cache[BACKGROUND].set = FALSE;
|
|
|
|
color_cache[BORDER].set = FALSE;
|
|
|
|
color_cache[SEPARATOR].set = FALSE;
|
|
|
|
}
|
2016-02-21 18:42:32 +00:00
|
|
|
void color_background ( cairo_t *d )
|
2015-04-06 15:13:26 +00:00
|
|
|
{
|
2015-10-10 12:15:27 +00:00
|
|
|
if ( !color_cache[BACKGROUND].set ) {
|
|
|
|
if ( !config.color_enabled ) {
|
2016-02-21 18:42:32 +00:00
|
|
|
color_cache[BACKGROUND].color = color_get ( config.menu_bg );
|
2015-10-10 12:15:27 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
gchar **vals = g_strsplit ( config.color_window, ",", 3 );
|
|
|
|
if ( vals != NULL && vals[0] != NULL ) {
|
2016-02-21 18:42:32 +00:00
|
|
|
color_cache[BACKGROUND].color = color_get ( vals[0] );
|
2015-10-10 12:15:27 +00:00
|
|
|
}
|
|
|
|
g_strfreev ( vals );
|
2015-04-11 10:04:14 +00:00
|
|
|
}
|
2015-10-10 12:15:27 +00:00
|
|
|
color_cache[BACKGROUND].set = TRUE;
|
2015-04-06 15:13:26 +00:00
|
|
|
}
|
2015-10-10 12:15:27 +00:00
|
|
|
|
|
|
|
x11_helper_set_cairo_rgba ( d, color_cache[BACKGROUND].color );
|
2015-04-06 15:13:26 +00:00
|
|
|
}
|
|
|
|
|
2016-02-21 18:42:32 +00:00
|
|
|
void color_border ( cairo_t *d )
|
2015-04-06 15:13:26 +00:00
|
|
|
{
|
2015-10-10 12:15:27 +00:00
|
|
|
if ( !color_cache[BORDER].set ) {
|
|
|
|
if ( !config.color_enabled ) {
|
2016-02-21 18:42:32 +00:00
|
|
|
color_cache[BORDER].color = color_get ( config.menu_bc );
|
2015-10-10 12:15:27 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
gchar **vals = g_strsplit ( config.color_window, ",", 3 );
|
|
|
|
if ( vals != NULL && vals[0] != NULL && vals[1] != NULL ) {
|
2016-02-21 18:42:32 +00:00
|
|
|
color_cache[BORDER].color = color_get ( vals[1] );
|
2015-10-10 12:15:27 +00:00
|
|
|
}
|
|
|
|
g_strfreev ( vals );
|
2015-04-11 10:04:14 +00:00
|
|
|
}
|
2015-10-10 12:15:27 +00:00
|
|
|
color_cache[BORDER].set = TRUE;
|
2015-04-06 15:13:26 +00:00
|
|
|
}
|
2015-10-10 12:15:27 +00:00
|
|
|
x11_helper_set_cairo_rgba ( d, color_cache[BORDER].color );
|
2015-04-06 15:13:26 +00:00
|
|
|
}
|
2015-08-26 16:11:53 +00:00
|
|
|
|
2016-02-21 18:42:32 +00:00
|
|
|
void color_separator ( cairo_t *d )
|
2015-08-26 16:11:53 +00:00
|
|
|
{
|
2015-10-10 12:15:27 +00:00
|
|
|
if ( !color_cache[SEPARATOR].set ) {
|
|
|
|
if ( !config.color_enabled ) {
|
2016-02-21 18:42:32 +00:00
|
|
|
color_cache[SEPARATOR].color = color_get ( config.menu_bc );
|
2015-08-26 16:11:53 +00:00
|
|
|
}
|
2015-10-10 12:15:27 +00:00
|
|
|
else {
|
|
|
|
gchar **vals = g_strsplit ( config.color_window, ",", 3 );
|
|
|
|
if ( vals != NULL && vals[0] != NULL && vals[1] != NULL && vals[2] != NULL ) {
|
2016-02-21 18:42:32 +00:00
|
|
|
color_cache[SEPARATOR].color = color_get ( vals[2] );
|
2015-10-10 12:15:27 +00:00
|
|
|
}
|
|
|
|
else if ( vals != NULL && vals[0] != NULL && vals[1] != NULL ) {
|
2016-02-21 18:42:32 +00:00
|
|
|
color_cache[SEPARATOR].color = color_get ( vals[1] );
|
2015-10-10 12:15:27 +00:00
|
|
|
}
|
|
|
|
g_strfreev ( vals );
|
2015-08-26 16:11:53 +00:00
|
|
|
}
|
2015-10-10 12:15:27 +00:00
|
|
|
color_cache[SEPARATOR].set = TRUE;
|
2015-08-26 16:11:53 +00:00
|
|
|
}
|
2015-10-10 12:15:27 +00:00
|
|
|
x11_helper_set_cairo_rgba ( d, color_cache[SEPARATOR].color );
|
2015-08-26 16:11:53 +00:00
|
|
|
}
|