rofi/source/xcb.c

/*
 * rofi
 *
 * MIT/X11 License
 * Copyright © 2012 Sean Pringle <sean.pringle@gmail.com>
 * Copyright © 2013-2021 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>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <glib.h>
#include <cairo.h>
#include <cairo-xcb.h>
#include <math.h>
#include <xcb/xcb.h>
#include <xcb/xcb_aux.h>
#include <xcb/randr.h>
#include <xcb/xinerama.h>
#include <xcb/xcb_ewmh.h>
#include <xcb/xproto.h>
#include <xcb/xcb_cursor.h>
#include <xcb/xkb.h>
#include <xkbcommon/xkbcommon.h>
#include <xkbcommon/xkbcommon-x11.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 "rofi-types.h"
#include <libsn/sn.h>
#include "display.h"
#include "xcb-internal.h"
#include "xcb.h"
#include "settings.h"
#include "helper.h"
#include "timings.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,
    .screen_nbr = -1,
    .sndisplay  = NULL,
    .sncontext  = NULL,
    .monitors   = 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 ) };

xcb_cursor_t            cursors[NUM_CURSORS] = { XCB_CURSOR_NONE, XCB_CURSOR_NONE, XCB_CURSOR_NONE };

const struct
{
    const char *css_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 );
    }
}

/**
 * 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;

    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;

    // 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 ()
{
    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 ()
{
    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, &current_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 )
{
    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 )
{
    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;
    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;
    }
    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 ) {
        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 = t->dst_x - r->x;
            mon->y = t->dst_y - r->y;
            mon->w = r->width;
            mon->h = r->height;
            retv   = TRUE;
            if ( ( current_window_manager & WM_ROOT_WINDOW_OFFSET ) == WM_ROOT_WINDOW_OFFSET ) {
                mon->x += r->x;
                mon->y += r->y;
            }
            g_debug ( "mon pos: %d %d %d-%d", mon->x, mon->y, mon->w, mon->h );
        }
        else if ( mon_id == -4 ) {
            monitor_dimensions ( t->dst_x, t->dst_y, mon );
            retv = TRUE;
        }
        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;
}
static int monitor_active_from_id ( int mon_id, workarea *mon )
{
    xcb_window_t root = xcb->screen->root;
    int          x, y;
    // 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 ) {
        // 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, &current_desktop, NULL ) ) {
            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 ) ) {
                if ( current_desktop < vp.desktop_viewport_len ) {
                    monitor_dimensions ( vp.desktop_viewport[current_desktop].x,
                                         vp.desktop_viewport[current_desktop].y, mon );
                    xcb_ewmh_get_desktop_viewport_reply_wipe ( &vp );
                    return TRUE;
                }
                else {
                    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
int monitor_active ( workarea *mon )
{
    if ( config.monitor != NULL ) {
        for ( workarea *iter = xcb->monitors; iter; iter = iter->next ) {
            if ( g_strcmp0 ( config.monitor, iter->name ) == 0 ) {
                *mon = *iter;
                return TRUE;
            }
        }
    }
    // Grab primary.
    if ( g_strcmp0 ( config.monitor, "primary" ) == 0 ) {
        for ( workarea *iter = xcb->monitors; iter; iter = iter->next ) {
            if ( iter->primary ) {
                *mon = *iter;
                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 ) ) {
                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 ) ) {
                    return TRUE;
                }
                g_warning ( "Failed to find selected monitor." );
            }
            else {
                return monitor_active_from_id ( mon_id, mon );
            }
        }
    }
    // Fallback.
    monitor_dimensions ( 0, 0, mon );
    return FALSE;
}

/**
 * @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_warning ( "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 {
        g_warning ( "Failed" );
    }
}

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;
}

/**
 * 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_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;
        if ( button_mask && config.click_to_exit == TRUE ) {
            xcb->mouse_seen = TRUE;
        }
        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 );
        }
        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 = FALSE;
        }
        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;
        gchar                 *text;

        xcb->last_timestamp = xkpe->time;
        text                = nk_bindings_seat_handle_key_with_modmask ( xcb->bindings_seat, NULL, xkpe->state, xkpe->detail, NK_BINDINGS_KEY_STATE_PRESS );
        if ( text != NULL ) {
            rofi_view_handle_text ( state, text );
        }
        break;
    }
    case XCB_KEY_RELEASE:
    {
        xcb_key_release_event_t *xkre = (xcb_key_release_event_t *) event;
        xcb->last_timestamp = xkre->time;
        nk_bindings_seat_handle_key ( xcb->bindings_seat, NULL, xkre->detail, NK_BINDINGS_KEY_STATE_RELEASE );
        break;
    }
    default:
        break;
    }
    rofi_view_maybe_update ( state );
}

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;
        }
        else {
            g_warning ( "main_loop_x11_event_handler: ev == NULL, status == %d", status );
            return G_SOURCE_CONTINUE;
        }
    }
    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 );
        }
    }
}

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 ) {
                g_debug ( "Found window manager: |%s|", wtitle.strings );
                if ( g_strcmp0 ( wtitle.strings, "i3" ) == 0 ) {
                    current_window_manager = WM_DO_NOT_CHANGE_CURRENT_DESKTOP | WM_PANGO_WORKSPACE_NAMES;
                }
                else if ( g_strcmp0 ( wtitle.strings, "bspwm" ) == 0 ) {
                    current_window_manager = WM_ROOT_WINDOW_OFFSET;
                }
            }
            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;
    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 );

    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;
    }

    // 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 ) {
        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 );
    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] ) );
}