display-x11-xcb.c

   1 /*
   2  * Copyright Neil Brown ©2021-2023 <neil@brown.name>
   3  * May be distributed under terms of GPLv2 - see file:COPYING
   4  *
   5  * X11 display driver for edlib, using xcb, cairopango, libxkbcommon etc.
   6  *
   7  * A different connection to the server will be created for each
   8  * display.  Maybe that can be optimised one day.
   9  */
  10
  11 #include <unistd.h>
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <stdint.h>
  15 #include <fcntl.h>
  16 #include <string.h>
  17 #include <xcb/xcb.h>
  18 #include <stdarg.h>
  19 #include <sys/wait.h>
  20 #ifndef __CHECKER__
  21 #include <xcb/xkb.h>
  22 #else
  23 /* xkb.h has a 'long' in an enum :-( */
  24 enum {
  25         XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY,
  26         XCB_XKB_EVENT_TYPE_MAP_NOTIFY,
  27         XCB_XKB_NEW_KEYBOARD_NOTIFY,
  28         XCB_XKB_EVENT_TYPE_STATE_NOTIFY,
  29         XCB_XKB_MAP_PART_MODIFIER_MAP,
  30         XCB_XKB_STATE_PART_MODIFIER_LOCK,
  31         XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS,
  32         XCB_XKB_STATE_PART_GROUP_BASE,
  33         XCB_XKB_MAP_PART_KEY_ACTIONS,
  34         XCB_XKB_STATE_PART_GROUP_LATCH,
  35         XCB_XKB_MAP_PART_VIRTUAL_MODS,
  36         XCB_XKB_STATE_PART_GROUP_LOCK,
  37         XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP,
  38         XCB_XKB_NKN_DETAIL_KEYCODES,
  39         XCB_XKB_MAP_PART_KEY_TYPES,
  40         XCB_XKB_MAP_PART_KEY_SYMS,
  41         XCB_XKB_STATE_PART_MODIFIER_BASE,
  42         XCB_XKB_STATE_PART_MODIFIER_LATCH,
  43         XCB_XKB_MAP_NOTIFY,
  44         XCB_XKB_STATE_NOTIFY,
  45 };
  46 typedef uint16_t xcb_xkb_device_spec_t;
  47 typedef struct xcb_xkb_select_events_details_t {
  48         uint16_t affectNewKeyboard;
  49         uint16_t newKeyboardDetails;
  50         uint16_t affectState;
  51         uint16_t stateDetails;
  52         /* and other fields */
  53 } xcb_xkb_select_events_details_t;
  54 typedef struct xcb_xkb_new_keyboard_notify_event_t {
  55         uint8_t         deviceID;
  56         uint16_t        changed;
  57         /* and other fields */
  58 } xcb_xkb_new_keyboard_notify_event_t;
  59 typedef struct xcb_xkb_state_notify_event_t {
  60         uint8_t         deviceID;
  61         uint8_t         baseMods;
  62         uint8_t         latchedMods;
  63         uint8_t         lockedMods;
  64         int16_t         baseGroup;
  65         int16_t         latchedGroup;
  66         uint8_t         lockedGroup;
  67         /* and other fields */
  68 } xcb_xkb_state_notify_event_t;
  69 typedef struct xcb_xkb_map_notify_event_t {
  70         uint8_t         deviceID;
  71 } xcb_xkb_map_notify_event_t;
  72 xcb_void_cookie_t
  73 xcb_xkb_select_events_aux_checked(xcb_connection_t              *c,
  74                                   xcb_xkb_device_spec_t         deviceSpec,
  75                                   uint16_t                      affectWhich,
  76                                   uint16_t                      clear,
  77                                   uint16_t                      selectAll,
  78                                   uint16_t                      affectMap,
  79                                   uint16_t                      map,
  80                                   const xcb_xkb_select_events_details_t *details);
  81
  82 #endif
  83 #include <xcb/xcbext.h>
  84 #include <ctype.h>
  85 #include <math.h>
  86 #include <locale.h>
  87
  88 #include <cairo.h>
  89 #include <cairo-xcb.h>
  90
  91 #include <wand/MagickWand.h>
  92 #ifdef __CHECKER__
  93 // enums confuse sparse...
  94 #define MagickBooleanType int
  95 #endif
  96
  97 #ifndef __CHECKER__
  98 #include <pango/pango.h>
  99 #include <pango/pangocairo.h>
 100 #else
 101 typedef struct PangoFontDescription {} PangoFontDescription;
 102 typedef struct PangoLayout {} PangoLayout;
 103 typedef struct PangoContext {} PangoContext;
 104 typedef struct PangoFontMetrics {} PangoFontMetrics;
 105 typedef struct PangoRectangle { int x,y,width,height;} PangoRectangle;
 106 typedef enum { PANGO_STYLE_NORMAL, PANGO_STYLE_OBLIQUE, PANGO_STYLE_ITALIC
 107 } PangoStyle;
 108 typedef enum { PANGO_VARIANT_NORMAL, PANGO_VARIANT_SMALL_CAPS } PangoVariant;
 109 typedef enum { PANGO_WEIGHT_NORMAL, PANGO_WEIGHT_BOLD } PangoWeight;
 110 PangoFontDescription *pango_font_description_new(void);
 111 void pango_font_description_set_family_static(PangoFontDescription*, char*);
 112 void pango_font_description_set_family(PangoFontDescription*, char*);
 113 void pango_font_description_set_size(PangoFontDescription*, int);
 114 void pango_font_description_set_style(PangoFontDescription*, PangoStyle);
 115 void pango_font_description_set_variant(PangoFontDescription*, PangoVariant);
 116 void pango_font_description_set_weight(PangoFontDescription*, PangoWeight);
 117 #define PANGO_SCALE (1024)
 118
 119 PangoLayout *pango_cairo_create_layout(cairo_t*);
 120 void g_object_unref(PangoLayout*);
 121 PangoContext *pango_cairo_create_context(cairo_t *);
 122 void pango_cairo_show_layout(cairo_t *, PangoLayout *);
 123 PangoFontMetrics *pango_context_get_metrics(PangoContext*, PangoFontDescription*, void*);
 124 void pango_font_description_free(PangoFontDescription*);
 125 int pango_font_metrics_get_approximate_char_width(PangoFontMetrics *);
 126 int pango_font_metrics_get_ascent(PangoFontMetrics *);
 127 int pango_font_metrics_get_descent(PangoFontMetrics *);
 128 void pango_font_metrics_unref(PangoFontMetrics *);
 129 PangoContext* pango_layout_get_context(PangoLayout *);
 130 int pango_layout_get_baseline(PangoLayout *);
 131 void pango_layout_get_extents(PangoLayout *, PangoRectangle *, PangoRectangle *);
 132 void pango_layout_get_pixel_extents(PangoLayout *, PangoRectangle *, PangoRectangle *);
 133 void pango_layout_set_font_description(PangoLayout *, PangoFontDescription *);
 134 void pango_layout_set_text(PangoLayout*, const char *, int);
 135 void pango_layout_xy_to_index(PangoLayout*, int, int, int*, int*);
 136 void pango_layout_index_to_pos(PangoLayout*, int, PangoRectangle*);
 137 #endif
 138
 139 #include <xkbcommon/xkbcommon.h>
 140 #include <xkbcommon/xkbcommon-compose.h>
 141 #include <xkbcommon/xkbcommon-x11.h>
 142
 143 #include "xcb.h"
 144
 145 #undef True
 146 #undef False
 147
 148 #define PANE_DATA_TYPE struct xcb_data
 149 #include "core.h"
 150
 151 enum my_atoms {
 152         a_NONE = 0,
 153         a_WM_STATE, a_STATE_FULLSCREEN,
 154         a_WM_NAME, a_NET_WM_NAME,
 155         a_WM_ICON_NAME, a_NET_WM_ICON_NAME,
 156         a_WM_PROTOCOLS, a_WM_DELETE_WINDOW,
 157         a_NET_WM_PING,
 158         a_NET_WM_ICON,
 159         a_WM_CLIENT_MACHINE,
 160         a_UTF8_STRING,
 161         NR_ATOMS
 162 };
 163 static const char *atom_names[NR_ATOMS] = {
 164         [a_NONE]                = "NONE",
 165         [a_WM_STATE]            = "_NET_WM_STATE",
 166         [a_STATE_FULLSCREEN]    = "_NET_WM_STATE_FULLSCREEN",
 167         [a_WM_NAME]             = "WM_NAME",
 168         [a_NET_WM_NAME]         = "_NET_WM_NAME",
 169         [a_WM_ICON_NAME]        = "WM_ICON_NAME",
 170         [a_NET_WM_ICON_NAME]    = "_NET_WM_ICON_NAME",
 171         [a_WM_PROTOCOLS]        = "WM_PROTOCOLS",
 172         [a_WM_DELETE_WINDOW]    = "WM_DELETE_WINDOW",
 173         [a_NET_WM_PING]         = "_NET_WM_PING",
 174         [a_NET_WM_ICON]         = "_NET_WM_ICON",
 175         [a_WM_CLIENT_MACHINE]   = "WM_CLIENT_MACHINE",
 176         [a_UTF8_STRING]         = "UTF8_STRING",
 177 };
 178
 179 struct rgb {
 180         double r,g,b;
 181 };
 182
 183 struct xcb_data {
 184         xcb_connection_t        *conn safe;
 185         char                    *display safe;
 186         char                    *disp_auth;
 187
 188         const xcb_setup_t       *setup safe;
 189         const xcb_screen_t      *screen safe;
 190         xcb_atom_t              atoms[NR_ATOMS];
 191
 192         long                    last_event;
 193         xcb_window_t            win;
 194         xcb_visualtype_t        *visual;
 195         cairo_t                 *cairo safe;
 196         cairo_surface_t         *surface safe;
 197         PangoFontDescription    *fd safe;
 198         int                     charwidth, lineheight;
 199         cairo_region_t          *need_update;
 200
 201         bool                    motion_blocked;
 202         bool                    in_focus;
 203
 204         struct xkb_context      *xkb;
 205         uint8_t                 first_xkb_event;
 206         int32_t                 xkb_device_id;
 207         struct xkb_state        *xkb_state;
 208         struct xkb_compose_state *compose_state;
 209         struct xkb_compose_table *compose_table;
 210         struct xkb_keymap       *xkb_keymap;
 211
 212         struct pids {
 213                 pid_t           pid;
 214                 struct pids     *next;
 215         }                       *pids;
 216
 217         /* FIXME use hash?? */
 218         struct panes {
 219                 struct panes    *next;
 220                 struct pane     *p safe;
 221                 cairo_rectangle_int_t r;
 222                 cairo_t         *ctx;
 223                 struct rgb      bg;
 224                 xcb_pixmap_t    draw;
 225                 cairo_surface_t *surface;
 226                 cairo_region_t  *need_update;
 227         } *panes;
 228 };
 229 #include "core-pane.h"
 230
 231 /* panes->r.x is NEVER_DRAWN if the pane has not been drawn */
 232 #define NEVER_DRAWN (-60000)
 233
 234 static struct map *xcb_map;
 235 DEF_LOOKUP_CMD(xcb_handle, xcb_map);
 236
 237 static struct panes *get_pixmap(struct pane *home safe,
 238                                 struct pane *p safe)
 239 {
 240         struct xcb_data *xd = home->data;
 241         struct panes **pp, *ps;
 242
 243         for (pp = &xd->panes; (ps = *pp) != NULL; pp = &(*pp)->next) {
 244                 if (ps->p != p)
 245                         continue;
 246                 if (ps->r.width == p->w && ps->r.height == p->h)
 247                         return ps;
 248                 *pp = ps->next;
 249                 if (ps->r.x != NEVER_DRAWN) {
 250                         if (!xd->need_update)
 251                                 xd->need_update = cairo_region_create();
 252                         cairo_region_union_rectangle(xd->need_update, &ps->r);
 253                 }
 254                 if (ps->ctx)
 255                         cairo_destroy(ps->ctx);
 256                 if (ps->surface)
 257                         cairo_surface_destroy(ps->surface);
 258                 if (ps->draw)
 259                         xcb_free_pixmap(xd->conn, ps->draw);
 260                 free(ps);
 261                 break;
 262         }
 263         alloc(ps, pane);
 264         ps->p = p;
 265         ps->r.x = ps->r.y = NEVER_DRAWN;
 266         ps->r.width = p->w;
 267         ps->r.height = p->h;
 268         ps->bg.r = ps->bg.g = ps->bg.b = 0;
 269
 270         pane_add_notify(home, p, "Notify:Close");
 271         ps->next = *pp;
 272         *pp = ps;
 273         return ps;
 274 }
 275
 276 static void instantiate_pixmap(struct xcb_data *xd safe,
 277                           struct panes *ps safe)
 278 {
 279         ps->draw = xcb_generate_id(xd->conn);
 280         xcb_create_pixmap(xd->conn, xd->screen->root_depth, ps->draw,
 281                           xd->win, ps->r.width, ps->r.height);
 282         ps->surface = cairo_xcb_surface_create(
 283                 xd->conn, ps->draw, xd->visual, ps->r.width, ps->r.height);
 284         if (!ps->surface)
 285                 goto free_ps;
 286         ps->ctx = cairo_create(ps->surface);
 287         if (!ps->ctx)
 288                 goto free_surface;
 289         cairo_set_source_rgb(ps->ctx, ps->bg.r, ps->bg.g, ps->bg.b);
 290         cairo_paint(ps->ctx);
 291         return;
 292
 293 free_surface:
 294         cairo_surface_destroy(ps->surface);
 295         ps->surface = NULL;
 296 free_ps:
 297         xcb_free_pixmap(xd->conn, ps->draw);
 298         ps->draw = 0;
 299 }
 300
 301 static struct panes *find_pixmap(struct xcb_data *xd safe, struct pane *p safe,
 302                                  int *xp safe, int *yp safe)
 303 {
 304         int x = 0, y = 0;
 305         struct panes *ret = NULL;
 306
 307         while (!ret && p->parent != p) {
 308                 struct panes *ps;
 309                 for (ps = xd->panes; ps ; ps = ps->next)
 310                         if (ps->p == p) {
 311                                 ret = ps;
 312                                 break;
 313                         }
 314                 if (!ret) {
 315                         x += p->x;
 316                         y += p->y;
 317                         p = p->parent;
 318                 }
 319         }
 320         *xp = x;
 321         *yp = y;
 322         return ret;
 323 }
 324
 325 static inline double cvt(int i)
 326 {
 327         return (float)i / 1000.0;
 328 }
 329
 330 static void parse_attrs(
 331         struct pane *home safe, const char *cattrs, int scale,
 332         struct rgb *fgp, struct rgb *bgp, bool *underline,
 333         PangoFontDescription **fdp)
 334 {
 335         char *attrs = strdup(cattrs ?: "");
 336         char *ap = attrs;
 337         char *word;
 338         char *fg = NULL, *bg = NULL;
 339         bool ul = False;
 340         bool inv = False;
 341         int size = 12*1000;
 342         PangoFontDescription *fd = NULL;
 343         PangoStyle style = PANGO_STYLE_NORMAL;
 344         PangoVariant variant = PANGO_VARIANT_NORMAL;
 345         PangoWeight weight = PANGO_WEIGHT_NORMAL;
 346
 347         if (fdp) {
 348                 fd = pango_font_description_new();
 349                 *fdp = fd;
 350                 pango_font_description_set_family_static(fd, "monospace");
 351         }
 352
 353         while ((word = strsep(&ap, ",")) != NULL) {
 354                 if (fd && strstarts(word, "family:"))
 355                         pango_font_description_set_family(fd, word+7);
 356                 if (strcmp(word, "large") == 0)
 357                         size = 14 * 1000;
 358                 if (strcmp(word, "small") == 0)
 359                         size = 9 * 1000;
 360                 if (isdigit(word[0])) {
 361                         char *end = NULL;
 362                         double s = strtod(word, &end);
 363                         if (end && end != word && !*end)
 364                                 size = trunc(s * 1000.0);
 365                         else
 366                                 size = 10*1000;
 367                 }
 368                 if (strcmp(word, "oblique") == 0)
 369                         style = PANGO_STYLE_OBLIQUE;
 370                 if (strcmp(word, "italic") == 0)
 371                         style = PANGO_STYLE_ITALIC;
 372                 if (strcmp(word, "normal") == 0)
 373                         style = PANGO_STYLE_NORMAL;
 374                 if (strcmp(word, "small-caps") == 0)
 375                         variant = PANGO_VARIANT_SMALL_CAPS;
 376
 377                 if (strcmp(word, "bold") == 0)
 378                         weight = PANGO_WEIGHT_BOLD;
 379                 if (strcmp(word, "nobold") == 0)
 380                         weight = PANGO_WEIGHT_NORMAL;
 381
 382                 if (strstarts(word, "fg:"))
 383                         fg = word + 3;
 384                 if (strstarts(word, "bg:"))
 385                         bg = word + 3;
 386                 if (strcmp(word, "inverse") == 0)
 387                         inv = True;
 388                 if (strcmp(word, "noinverse") == 0)
 389                         inv = False;
 390                 if (strcmp(word, "underline") == 0)
 391                         ul = True;
 392                 if (strcmp(word, "nounderline") == 0)
 393                         ul = False;
 394         }
 395
 396         if (inv) {
 397                 char *t = bg;
 398                 bg = fg;
 399                 fg = t;
 400                 if (!fg)
 401                         fg = "white";
 402                 if (!bg)
 403                         bg = "black";
 404         } else if (!fg)
 405                 fg = "black";
 406
 407         if (fg && fgp) {
 408                 struct call_return ret = call_ret(all, "colour:map", home,
 409                                                   0, NULL, fg);
 410                 fgp->r = cvt(ret.i);
 411                 fgp->g = cvt(ret.i2);
 412                 fgp->b = cvt(ret.x);
 413         } else if (fgp)
 414                 fgp->g = -1;
 415         if (bg && bgp) {
 416                 struct call_return ret = call_ret(all, "colour:map", home,
 417                                                   0, NULL, bg);
 418                 bgp->r = cvt(ret.i);
 419                 bgp->g = cvt(ret.i2);
 420                 bgp->b = cvt(ret.x);
 421         } else if (bgp)
 422                 bgp->g = -1;
 423         if (fd) {
 424                 pango_font_description_set_size(fd, PANGO_SCALE * size /1000 * scale / 1000);
 425                 if (style != PANGO_STYLE_NORMAL)
 426                         pango_font_description_set_style(fd, style);
 427                 if (variant != PANGO_VARIANT_NORMAL)
 428                         pango_font_description_set_variant(fd, variant);
 429                 if (weight != PANGO_WEIGHT_NORMAL)
 430                         pango_font_description_set_weight(fd, weight);
 431         }
 432         if (underline)
 433                 *underline = ul;
 434         free(attrs);
 435 }
 436
 437 DEF_CB(cnt_disp)
 438 {
 439         struct call_return *cr = container_of(ci->comm, struct call_return, c);
 440
 441         cr->i += 1;
 442         return 1;
 443 }
 444
 445 DEF_CMD_CLOSED(xcb_close_display)
 446 {
 447         /* If this is only display, then refuse to close this one */
 448         struct call_return cr;
 449         char *nc = pane_attr_get(ci->home, "no-close");
 450
 451         if (nc) {
 452                 call("Message", ci->focus, 0, NULL, nc);
 453                 return 1;
 454         }
 455         cr.c = cnt_disp;
 456         cr.i = 0;
 457         call_comm("editor:notify:all-displays", ci->focus, &cr.c);
 458         if (cr.i > 1)
 459                 return Efallthrough;
 460         else
 461                 call("Message", ci->focus, 0, NULL,
 462                      "Cannot close only window.");
 463         return 1;
 464 }
 465
 466 static void wait_for(struct xcb_data *xd safe)
 467 {
 468         struct pids **pp = &xd->pids;
 469
 470         while (*pp) {
 471                 struct pids *p = *pp;
 472                 if (waitpid(p->pid, NULL, WNOHANG) > 0) {
 473                         *pp = p->next;
 474                         free(p);
 475                 } else
 476                         pp = &p->next;
 477         }
 478 }
 479
 480 DEF_CMD(xcb_external_viewer)
 481 {
 482         struct xcb_data *xd = ci->home->data;
 483         const char *path = ci->str;
 484         struct pids *p;
 485         int pid;
 486         int fd;
 487
 488         if (!path)
 489                 return Enoarg;
 490         switch (pid = fork()) {
 491         case -1:
 492                 return Efail;
 493         case 0: /* Child */
 494                 setenv("DISPLAY", xd->display, 1);
 495                 if (xd->disp_auth)
 496                         setenv("XAUTHORITY", xd->disp_auth, 1);
 497                 fd = open("/dev/null", O_RDWR);
 498                 if (fd) {
 499                         dup2(fd, 0);
 500                         dup2(fd, 1);
 501                         dup2(fd, 2);
 502                         if (fd > 2)
 503                                 close(fd);
 504                 }
 505                 execlp("xdg-open", "xdg-open", path, NULL);
 506                 exit(1);
 507         default: /* parent */
 508                 p = malloc(sizeof(*p));
 509                 p->pid = pid;
 510                 p->next = xd->pids;
 511                 xd->pids = p;
 512                 break;
 513         }
 514         wait_for(xd);
 515         return 1;
 516 }
 517
 518 DEF_CMD(xcb_fullscreen)
 519 {
 520         struct xcb_data *xd = ci->home->data;
 521         xcb_client_message_event_t msg = {};
 522
 523         msg.response_type = XCB_CLIENT_MESSAGE;
 524         msg.format = 32;
 525         msg.window = xd->win;
 526         msg.type = xd->atoms[a_WM_STATE];
 527         if (ci->num > 0)
 528                 msg.data.data32[0] = 1; /* ADD */
 529         else
 530                 msg.data.data32[0] = 0; /* REMOVE */
 531         msg.data.data32[1] = xd->atoms[a_STATE_FULLSCREEN];
 532         msg.data.data32[2] = 0;
 533         msg.data.data32[3] = 1; /* source indicator */
 534
 535         xcb_send_event(xd->conn, 0, xd->screen->root,
 536                        XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
 537                        XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
 538                        (void*)&msg);
 539         xcb_flush(xd->conn);
 540         return 1;
 541 }
 542
 543 static void panes_free(struct xcb_data *xd safe)
 544 {
 545         while (xd->panes) {
 546                 struct panes *ps = xd->panes;
 547                 xd->panes = ps->next;
 548                 if (ps->ctx)
 549                         cairo_destroy(ps->ctx);
 550                 if (ps->surface)
 551                         cairo_surface_destroy(ps->surface);
 552                 if (ps->draw)
 553                         xcb_free_pixmap(xd->conn, ps->draw);
 554                 free(ps);
 555         }
 556 }
 557
 558 static void kbd_free(struct xcb_data *xd safe);
 559
 560 DEF_CMD_CLOSED(xcb_close)
 561 {
 562         struct xcb_data *xd = ci->home->data;
 563
 564         xcb_destroy_window(xd->conn, xd->win);
 565         kbd_free(xd);
 566         panes_free(xd);
 567
 568         pango_font_description_free(xd->fd);
 569         cairo_destroy(xd->cairo);
 570         cairo_device_finish(cairo_surface_get_device(xd->surface));
 571         cairo_surface_destroy(xd->surface);
 572         free(xd->display);
 573         free(xd->disp_auth);
 574         xcb_disconnect(xd->conn);
 575         if (xd->need_update)
 576                 cairo_region_destroy(xd->need_update);
 577         return 1;
 578 }
 579
 580 DEF_CMD(xcb_clear)
 581 {
 582         struct xcb_data *xd = ci->home->data;
 583         const char *attr = ci->str;
 584         struct panes *src = NULL, *dest;
 585         struct rgb bg;
 586         int x=0, y=0;
 587         cairo_rectangle_int_t r;
 588
 589         if (attr) {
 590                 parse_attrs(ci->home, attr, PANGO_SCALE, NULL, &bg, NULL, NULL);
 591                 if (bg.g < 0)
 592                         bg.r = bg.g = bg.b = 1.0;
 593         } else {
 594                 src = find_pixmap(xd, ci->focus->parent, &x, &y);
 595                 x += ci->focus->x;
 596                 y += ci->focus->y;
 597                 if (!src)
 598                         bg.r = bg.g = bg.b = 1.0;
 599                 else if (src->bg.g >= 0)
 600                         bg = src->bg;
 601                 else if (src->surface == NULL)
 602                         bg.r = bg.g = bg.b = 1.0;
 603                 else
 604                         bg.g = -1;
 605         }
 606
 607         dest = get_pixmap(ci->home, ci->focus);
 608         if (!dest)
 609                 return 1;
 610         if (bg.g >= 0) {
 611                 if (dest->ctx) {
 612                         cairo_set_source_rgb(dest->ctx, bg.r, bg.g, bg.b);
 613                         cairo_paint(dest->ctx);
 614                 }
 615                 dest->bg = bg;
 616         } else if (src) {
 617                 if (!dest->ctx)
 618                         instantiate_pixmap(xd, dest);
 619                 if (dest->ctx) {
 620                         cairo_set_source_surface(dest->ctx, src->surface, -x, -y);
 621                         cairo_paint(dest->ctx);
 622                         dest->bg.g = -1;
 623                 }
 624         }
 625         pane_damaged(ci->home, DAMAGED_POSTORDER);
 626
 627         if (!dest->need_update)
 628                 dest->need_update = cairo_region_create();
 629         r.x = 0;
 630         r.y = 0;
 631         r.width = ci->focus->w;
 632         r.height = ci->focus->h;
 633         cairo_region_union_rectangle(dest->need_update, &r);
 634         return 1;
 635 }
 636
 637 DEF_CMD(xcb_text_size)
 638 {
 639         struct xcb_data *xd = ci->home->data;
 640         const char *attr = ci->str2 ?: "";
 641         const char *str = ci->str ?: "";
 642         int scale = ci->num2;
 643         PangoLayout *layout;
 644         PangoFontDescription *fd;
 645         PangoRectangle log;
 646         int baseline;
 647         int max_bytes;
 648
 649         if (scale <= 0)
 650                 scale = 1000;
 651         if (!utf8_valid(str))
 652                 str = "*INV*";
 653         parse_attrs(ci->home, attr, scale, NULL, NULL, NULL, &fd);
 654         /* If we use an empty string, line-height is wrong */
 655         layout = pango_cairo_create_layout(xd->cairo);
 656         pango_layout_set_text(layout, *str ? str : "M", -1);
 657         pango_layout_set_font_description(layout, fd);
 658         pango_layout_get_pixel_extents(layout, NULL, &log);
 659         baseline = pango_layout_get_baseline(layout) / PANGO_SCALE;
 660
 661         if (ci->num < 0)
 662                 max_bytes = 0;
 663         else if (log.width <= ci->num)
 664                 max_bytes = strlen(str);
 665         else
 666                 pango_layout_xy_to_index(layout, PANGO_SCALE*ci->num,
 667                                          baseline, &max_bytes, NULL);
 668
 669         comm_call(ci->comm2, "cb", ci->focus, max_bytes, NULL, NULL,
 670                   baseline, NULL, NULL,
 671                   str && *str ? log.width : 0,
 672                   log.height);
 673
 674         pango_font_description_free(fd);
 675         g_object_unref(layout);
 676         return 1;
 677 }
 678
 679 DEF_CMD(xcb_draw_text)
 680 {
 681         struct xcb_data *xd = ci->home->data;
 682         const char *str = ci->str;
 683         const char *attr = ci->str2;
 684         int scale = 1000;
 685         struct panes *ps;
 686         cairo_t *ctx;
 687         PangoLayout *layout;
 688         PangoFontDescription *fd;
 689         PangoRectangle log;
 690         struct rgb fg, bg;
 691         bool ul;
 692         int baseline;
 693         int xo = 0, yo = 0;
 694         int x,y;
 695
 696         if (!str)
 697                 return Enoarg;
 698         ps = find_pixmap(xd, ci->focus, &xo, &yo);
 699         if (!ps)
 700                 return Einval;
 701         if (!ps->ctx)
 702                 instantiate_pixmap(xd, ps);
 703         ps->bg.g = -1;
 704         ctx = ps->ctx;
 705         if (!ctx)
 706                 return Efail;
 707
 708         if (!utf8_valid(str))
 709                 str = "*INV*";
 710
 711         pane_damaged(ci->home, DAMAGED_POSTORDER);
 712
 713         if (ci->num2 > 0)
 714                 scale = ci->num2 * 10 / xd->charwidth;
 715
 716         parse_attrs(ci->home, attr, scale, &fg, &bg, &ul, &fd);
 717
 718         x = ci->x + xo;
 719         y = ci->y + yo;
 720         layout = pango_cairo_create_layout(ctx);
 721         pango_layout_set_text(layout, str, -1);
 722         pango_layout_set_font_description(layout, fd);
 723         pango_layout_get_pixel_extents(layout, NULL, &log);
 724         baseline = pango_layout_get_baseline(layout) / PANGO_SCALE;
 725         cairo_save(ctx);
 726         if (bg.g >= 0) {
 727                 cairo_set_source_rgb(ctx, bg.r, bg.g, bg.b);
 728                 cairo_rectangle(ctx, x+log.x, y - baseline + log.y,
 729                                 log.width, log.height);
 730                 cairo_fill(ctx);
 731         }
 732         cairo_set_source_rgb(ctx, fg.r, fg.g, fg.b);
 733         if (ul) {
 734                 /* Draw an underline */
 735                 cairo_rectangle(ctx, x+log.x, y+2+log.y,
 736                                 log.width, 1);
 737                 cairo_fill(ctx);
 738         }
 739
 740         cairo_move_to(ctx, x, y - baseline);
 741         pango_cairo_show_layout(ctx, layout);
 742         cairo_stroke(ctx);
 743
 744         if (ci->num >= 0) {
 745                 /* draw a cursor - outline box if not in-focus,
 746                  * inverse-video if it is.
 747                  */
 748                 PangoRectangle curs;
 749                 bool in_focus = xd->in_focus;
 750                 struct pane *f = ci->focus;
 751                 double cx, cy, cw, ch;
 752
 753                 pango_layout_index_to_pos(layout, ci->num, &curs);
 754                 if (curs.width <= 0) {
 755                         /* EOL?*/
 756                         pango_layout_set_text(layout, "M", 1);
 757                         pango_layout_get_extents(layout, NULL, &log);
 758                         curs.width = log.width;
 759                 }
 760
 761                 while (in_focus && f->parent->parent != f &&
 762                        f->parent != ci->home) {
 763                         if (f->parent->focus != f && f->z >= 0)
 764                                 in_focus = False;
 765                         f = f->parent;
 766                 }
 767                 if (!in_focus) {
 768                         /* Just an fg:rectangle around the fg:text */
 769                         /* Add half to x,y as stroke is either side of the line */
 770                         cx = x * PANGO_SCALE + curs.x + PANGO_SCALE/2;
 771                         cy = (y - baseline) * PANGO_SCALE + curs.y + PANGO_SCALE/2;
 772                         ch = curs.height - PANGO_SCALE;
 773                         cw = curs.width - PANGO_SCALE;
 774                         cairo_rectangle(ctx, cx/PANGO_SCALE, cy/PANGO_SCALE,
 775                                         cw/PANGO_SCALE, ch/PANGO_SCALE);
 776                         cairo_set_line_width(ctx, 1.0);
 777                         cairo_stroke(ctx);
 778                 } else {
 779                         /* solid fd:block with txt in bg color */
 780                         cairo_rectangle(ctx,
 781                                         x+curs.x/PANGO_SCALE,
 782                                         y-baseline+curs.y/PANGO_SCALE,
 783                                         curs.width / PANGO_SCALE,
 784                                         curs.height / PANGO_SCALE);
 785                         cairo_fill(ctx);
 786                         if (ci->num < (int)strlen(str)) {
 787                                 const char *cp = str + ci->num;
 788                                 get_utf8(&cp, NULL);
 789                                 pango_layout_set_text(layout, str + ci->num,
 790                                                       cp - (str + ci->num));
 791                                 if (bg.g >= 0)
 792                                         cairo_set_source_rgb(ctx, bg.r, bg.g, bg.b);
 793                                 else
 794                                         cairo_set_source_rgb(ctx, 1.0, 1.0, 1.0);
 795                                 cairo_move_to(ctx,
 796                                               x + curs.x / PANGO_SCALE,
 797                                               y - baseline + curs.y / PANGO_SCALE);
 798                                 pango_cairo_show_layout(ctx, layout);
 799                         }
 800                 }
 801         }
 802         cairo_restore(ctx);
 803         pango_font_description_free(fd);
 804         g_object_unref(layout);
 805         return 1;
 806 }
 807
 808 DEF_CMD(xcb_draw_image)
 809 {
 810         /* 'str' identifies the image. Options are:
 811          *     file:filename  - load file from fs
 812          *     comm:command   - run command collecting bytes
 813          * 'num' is '16' if image should be stretched to fill pane
 814          * Otherwise it is the 'or' of
 815          *   0,1,2 for left/middle/right in x direction
 816          *   0,4,8 for top/middle/bottom in y direction
 817          * only one of these can be used as image will fill pane
 818          * in other direction.
 819          * If 'x' and 'y' are both positive, draw cursor box at
 820          * p->cx, p->cy of a size so that 'x' will fit across and
 821          * 'y' will fit down.
 822          */
 823         struct xcb_data *xd = ci->home->data;
 824         bool stretch = ci->num & 16;
 825         int pos = ci->num;
 826         int w = ci->focus->w, h = ci->focus->h;
 827         int x = 0, y = 0;
 828         int xo, yo;
 829         int stride;
 830         struct panes *ps;
 831         MagickBooleanType status;
 832         MagickWand *wd;
 833         int fmt[2];
 834         unsigned char *buf;
 835         cairo_surface_t *surface;
 836
 837         if (!ci->str)
 838                 return Enoarg;
 839         ps = find_pixmap(xd, ci->focus, &xo, &yo);
 840         if (!ps)
 841                 return Einval;
 842         if (!ps->ctx)
 843                 instantiate_pixmap(xd, ps);
 844         ps->bg.g = -1;
 845         if (!ps->ctx)
 846                 return Efail;
 847         if (strstarts(ci->str, "file:")) {
 848                 wd = NewMagickWand();
 849                 status = MagickReadImage(wd, ci->str + 5);
 850                 if (status == MagickFalse) {
 851                         DestroyMagickWand(wd);
 852                         return Efail;
 853                 }
 854         } else if (strstarts(ci->str, "comm:")) {
 855                 struct call_return cr;
 856                 wd = NewMagickWand();
 857                 cr = call_ret(bytes, ci->str+5, ci->focus, 0, NULL, ci->str2);
 858                 if (!cr.s) {
 859                         DestroyMagickWand(wd);
 860                         return Efail;
 861                 }
 862                 status = MagickReadImageBlob(wd, cr.s, cr.i);
 863                 free(cr.s);
 864                 if (status == MagickFalse) {
 865                         DestroyMagickWand(wd);
 866                         return Efail;
 867                 }
 868         } else
 869                 return Einval;
 870
 871         MagickAutoOrientImage(wd);
 872         if (!stretch) {
 873                 int ih = MagickGetImageHeight(wd);
 874                 int iw = MagickGetImageWidth(wd);
 875
 876                 if (iw <= 0 || iw <= 0) {
 877                         DestroyMagickWand(wd);
 878                         return Efail;
 879                 }
 880                 if (iw * h > ih * w) {
 881                         /* Image is wider than space, use less height */
 882                         ih = ih * w / iw;
 883                         switch(pos & (8+4)) {
 884                         case 4: /* center */
 885                                 y = (h - ih) / 2; break;
 886                         case 8: /* bottom */
 887                                 y = h - ih; break;
 888                         }
 889                         h = ih;
 890                 } else {
 891                         /* image is too tall, use less width */
 892                         iw = iw * h / ih;
 893                         switch (pos & (1+2)) {
 894                         case 1: /* center */
 895                                 x = (w - iw) / 2; break;
 896                         case 2: /* right */
 897                                 x = w - iw ; break;
 898                         }
 899                         w = iw;
 900                 }
 901         }
 902         MagickAdaptiveResizeImage(wd, w, h);
 903         stride = cairo_format_stride_for_width(CAIRO_FORMAT_RGB24, w);
 904         buf = malloc(h * stride);
 905         // Cairo expects 32bit values with A in the high byte, then RGB.
 906         // Magick provides 8bit values in the order requests.
 907         // So depending on byte order, a different string is needed
 908
 909         fmt[0] = ('A'<<24) | ('R' << 16) | ('G' << 8) | ('B' << 0);
 910         fmt[1] = 0;
 911         MagickExportImagePixels(wd, 0, 0, w, h, (char*)fmt, CharPixel, buf);
 912         surface = cairo_image_surface_create_for_data(buf, CAIRO_FORMAT_ARGB32,
 913                                                       w, h, stride);
 914         cairo_set_source_surface(ps->ctx, surface, x + xo, y + yo);
 915         cairo_paint(ps->ctx);
 916         cairo_surface_destroy(surface);
 917         free(buf);
 918
 919         if (ci->x > 0 && ci->y > 0 && ci->focus->cx >= 0) {
 920                 struct pane *p = ci->focus;
 921                 cairo_rectangle(ps->ctx, p->cx + xo, p->cy + yo,
 922                                 w/ci->x, h/ci->y);
 923                 cairo_set_line_width(ps->ctx, 1.0);
 924                 cairo_set_source_rgb(ps->ctx, 1.0, 0.0, 0.0);
 925                 cairo_stroke(ps->ctx);
 926         }
 927         DestroyMagickWand(wd);
 928
 929         pane_damaged(ci->home, DAMAGED_POSTORDER);
 930
 931         return 1;
 932 }
 933
 934 DEF_CMD(xcb_image_size)
 935 {
 936         MagickBooleanType status;
 937         MagickWand *wd;
 938         int ih, iw;
 939
 940         if (!ci->str)
 941                 return Enoarg;
 942         if (strstarts(ci->str, "file:")) {
 943                 wd = NewMagickWand();
 944                 status = MagickReadImage(wd, ci->str + 5);
 945                 if (status == MagickFalse) {
 946                         DestroyMagickWand(wd);
 947                         return Efail;
 948                 }
 949         } else if (strstarts(ci->str, "comm:")) {
 950                 struct call_return cr;
 951                 wd = NewMagickWand();
 952                 cr = call_ret(bytes, ci->str+5, ci->focus, 0, NULL, ci->str2);
 953                 if (!cr.s) {
 954                         DestroyMagickWand(wd);
 955                         return Efail;
 956                 }
 957                 status = MagickReadImageBlob(wd, cr.s, cr.i);
 958                 free(cr.s);
 959                 if (status == MagickFalse) {
 960                         DestroyMagickWand(wd);
 961                         return Efail;
 962                 }
 963         } else
 964                 return Einval;
 965
 966         MagickAutoOrientImage(wd);
 967         ih = MagickGetImageHeight(wd);
 968         iw = MagickGetImageWidth(wd);
 969
 970         DestroyMagickWand(wd);
 971         comm_call(ci->comm2, "callback:size", ci->focus,
 972                   0, NULL, NULL, 0, NULL, NULL,
 973                   iw, ih);
 974         return 1;
 975 }
 976
 977 static struct panes *sort_split(struct panes *p)
 978 {
 979         /* consider 'p' to be a list of panes with
 980          * ordered subsets (ordered by p->abs_z).
 981          * Remove every other such subset and return them
 982          * linked together.
 983          * If p is ordered, this means we return NULL.
 984          */
 985         struct panes *ret, **end = &ret;
 986         struct panes *next;
 987
 988         for (; p && p->next; p = next) {
 989                 /* If these are not ordered, attach p->next at
 990                  * 'end', and make 'end' point to &p->next.
 991                  */
 992                 next = p->next;
 993                 if (p->p->abs_z < next->p->abs_z) {
 994                         *end = next;
 995                         end = &p->next;
 996                 }
 997         }
 998         *end = NULL;
 999         return ret;
1000 }
1001
1002 static struct panes *sort_merge(struct panes *p1, struct panes *p2)
1003 {
1004         /* merge p1 and p2 and return result */
1005         struct panes *ret, **end = &ret;
1006         struct panes *prev = NULL;
1007
1008         while (p1 && p2) {
1009                 /* Make p1 the largest (or be added first.
1010                  * Then in prev is between them add p2, else p1
1011                  */
1012                 if (p1->p->abs_z < p2->p->abs_z) {
1013                         struct panes *t = p1;
1014                         p1 = p2;
1015                         p2 = t;
1016                 }
1017                 if (prev &&
1018                     p1->p->abs_z > prev->p->abs_z &&
1019                     prev->p->abs_z >= p2->p->abs_z) {
1020                         /* p2 is the better choice */
1021                         prev = p2;
1022                         p2 = p2->next;
1023                 } else {
1024                         prev = p1;
1025                         p1 = p1->next;
1026                 }
1027                 *end = prev;
1028                 end = &prev->next;
1029         }
1030         if (p1)
1031                 *end = p1;
1032         else
1033                 *end = p2;
1034         return ret;
1035 }
1036
1037 DEF_CMD(xcb_refresh_post)
1038 {
1039         struct xcb_data *xd = ci->home->data;
1040         struct panes *ps;
1041
1042         time_start(TIME_WINDOW);
1043         /* First: ensure panes are sorted */
1044         while ((ps = sort_split(xd->panes)) != NULL)
1045                 xd->panes = sort_merge(xd->panes, ps);
1046
1047         /* Then merge all update rectanges, checking for movement */
1048         if (!xd->need_update)
1049                 xd->need_update = cairo_region_create();
1050         for (ps = xd->panes; ps ; ps = ps->next)
1051         {
1052                 struct xy rel;
1053
1054                 rel = pane_mapxy(ps->p, ci->home, 0, 0, False);
1055                 if (ps->r.x == NEVER_DRAWN) {
1056                         ps->r.x = rel.x;
1057                         ps->r.y = rel.y;
1058                         cairo_region_union_rectangle(xd->need_update, &ps->r);
1059                 } else if (rel.x != ps->r.x || rel.y != ps->r.y) {
1060                         /* Moved, so refresh all.
1061                          * This rectangle might be too big if it is clipped,
1062                          * but that doesn't really matter.
1063                          */
1064                         cairo_region_union_rectangle(xd->need_update, &ps->r);
1065                         ps->r.x = rel.x;
1066                         ps->r.y = rel.y;
1067                         cairo_region_union_rectangle(xd->need_update, &ps->r);
1068                 } else if (ps->need_update) {
1069                         cairo_region_translate(ps->need_update, rel.x, rel.y);
1070                         cairo_region_union(xd->need_update, ps->need_update);
1071                 }
1072                 if (ps->need_update)
1073                         cairo_region_destroy(ps->need_update);
1074                 ps->need_update = NULL;
1075         }
1076         /* Now copy all panes onto the window where an update is needed */
1077         for (ps = xd->panes; ps ; ps = ps->next) {
1078                 struct xy rel, lo, hi;
1079                 cairo_region_t *cr;
1080                 cairo_rectangle_int_t r;
1081                 int nr, i;
1082
1083                 cr = cairo_region_copy(xd->need_update);
1084
1085                 rel = pane_mapxy(ps->p, ci->home, 0, 0, False);
1086
1087                 cairo_save(xd->cairo);
1088                 if (ps->bg.g >= 0)
1089                         cairo_set_source_rgb(xd->cairo,
1090                                              ps->bg.r, ps->bg.g, ps->bg.b);
1091                 else
1092                         cairo_set_source_surface(xd->cairo, ps->surface,
1093                                                  rel.x, rel.y);
1094
1095                 lo = pane_mapxy(ps->p, ci->home, 0, 0, True);
1096                 hi = pane_mapxy(ps->p, ci->home, ps->r.width, ps->r.height, True);
1097                 r.x = lo.x; r.y = lo.y;
1098                 r.width = hi.x - lo.x; r.height = hi.y - lo.y;
1099                 cairo_region_intersect_rectangle(cr, &r);
1100                 cairo_region_subtract_rectangle(xd->need_update, &r);
1101                 nr = cairo_region_num_rectangles(cr);
1102                 for (i = 0; i < nr; i++) {
1103                         cairo_region_get_rectangle(cr, i, &r);
1104                         cairo_rectangle(xd->cairo, r.x, r.y, r.width, r.height);
1105                         cairo_fill(xd->cairo);
1106                 }
1107                 cairo_restore(xd->cairo);
1108         }
1109
1110         cairo_region_destroy(xd->need_update);
1111         xd->need_update = NULL;
1112         time_stop(TIME_WINDOW);
1113         xcb_flush(xd->conn);
1114         return 1;
1115 }
1116
1117 DEF_CMD(xcb_refresh_size)
1118 {
1119         /* FIXME: should I consider resizing the window?
1120          * For now, just ensure we redraw everything.
1121          */
1122         struct xcb_data *xd = ci->home->data;
1123         cairo_rectangle_int_t r = {
1124                 .x = 0,
1125                 .y = 0,
1126                 .width = ci->home->w,
1127                 .height = ci->home->h,
1128         };
1129
1130         if (!xd->need_update)
1131                 xd->need_update = cairo_region_create();
1132         cairo_region_union_rectangle(xd->need_update, &r);
1133         /* Ask common code to notify children */
1134         return Efallthrough;
1135 }
1136
1137 DEF_CMD(xcb_pane_close)
1138 {
1139         struct xcb_data *xd = ci->home->data;
1140         struct panes **pp, *ps;
1141
1142         for (pp = &xd->panes; (ps = *pp) != NULL; pp = &(*pp)->next) {
1143                 if (ps->p != ci->focus)
1144                         continue;
1145
1146                 if (!xd->need_update)
1147                         xd->need_update = cairo_region_create();
1148                 if (ps->r.x != NEVER_DRAWN)
1149                         cairo_region_union_rectangle(xd->need_update, &ps->r);
1150
1151                 *pp = ps->next;
1152                 ps->next = NULL;
1153                 if (ps->need_update)
1154                         cairo_region_destroy(ps->need_update);
1155                 cairo_destroy(ps->ctx);
1156                 cairo_surface_destroy(ps->surface);
1157                 xcb_free_pixmap(xd->conn, ps->draw);
1158                 free(ps);
1159                 pane_damaged(ci->home, DAMAGED_POSTORDER);
1160                 break;
1161         }
1162         return 1;
1163 }
1164
1165 DEF_CMD(xcb_notify_display)
1166 {
1167         struct xcb_data *xd = ci->home->data;
1168         comm_call(ci->comm2, "callback:display", ci->home, xd->last_event);
1169         return 1;
1170 }
1171
1172 static void handle_button(struct pane *home safe,
1173                           xcb_button_press_event_t *be safe)
1174 {
1175         struct xcb_data *xd = home->data;
1176         bool press = (be->response_type & 0x7f) == XCB_BUTTON_PRESS;
1177         char mod[2+2+2+1];
1178         char key[2+2+2+9+1+1];
1179
1180         xcb_set_input_focus(xd->conn, XCB_INPUT_FOCUS_POINTER_ROOT,
1181                             xd->win, XCB_CURRENT_TIME);
1182         mod[0] = 0;
1183         if (press) {
1184                 xd->motion_blocked = False;
1185                 if (be->state & XCB_KEY_BUT_MASK_MOD_1)
1186                         strcat(mod, ":A");
1187                 if (be->state & XCB_KEY_BUT_MASK_CONTROL)
1188                         strcat(mod, ":C");
1189                 if (be->state & XCB_KEY_BUT_MASK_SHIFT)
1190                         strcat(mod, ":S");
1191                 strcpy(key, mod);
1192                 strcat(key, ":Press-X");
1193         } else if (be->detail >= 4)
1194                 /* ignore 'release' for scroll wheel */
1195                 return;
1196         else
1197                 strcpy(key, ":Release-X");
1198
1199         key[strlen(key) - 1] = '0' + be->detail;
1200         xd->last_event = time(NULL);
1201         call("Mouse-event", home, be->detail, NULL, key,
1202              press?1:2, NULL, mod,
1203              be->event_x, be->event_y);
1204 }
1205
1206 static void handle_motion(struct pane *home safe,
1207                           xcb_motion_notify_event_t *mne safe)
1208 {
1209         struct xcb_data *xd = home->data;
1210         xcb_query_pointer_cookie_t c;
1211         xcb_query_pointer_reply_t *qpr;
1212         int ret;
1213         int x = mne->event_x, y = mne->event_y;
1214
1215         if (xd->motion_blocked)
1216                 return;
1217         ret = call("Mouse-event", home, 0, NULL, ":Motion",
1218                    3, NULL, NULL, x, y);
1219         if (ret <= 0)
1220                 xd->motion_blocked = True;
1221
1222         /* This doesn't seem to be needed, but the spec says
1223          * I should do this when using POINTER_MOTION_HINT
1224          */
1225         c = xcb_query_pointer(xd->conn, xd->win);
1226         qpr = xcb_query_pointer_reply(xd->conn, c, NULL);
1227         free(qpr);
1228 }
1229
1230 static void handle_focus(struct pane *home safe, xcb_focus_in_event_t *fie safe)
1231 {
1232         struct xcb_data *xd = home->data;
1233         bool in = (fie->response_type & 0x7f) == XCB_FOCUS_IN;
1234         struct pane *p;
1235         struct mark *pt;
1236
1237         xd->in_focus = in;
1238         p = pane_focus(home);
1239         pt = call_ret(mark, "doc:point", p);
1240         if (pt)
1241                 call("view:changed", p, 0, pt);
1242         if (in)
1243                 call("pane:refocus", home);
1244 }
1245
1246 static bool select_xkb_events_for_device(xcb_connection_t *conn,
1247                                          int32_t device_id)
1248 {
1249         xcb_generic_error_t *error;
1250         xcb_void_cookie_t cookie;
1251
1252         enum {
1253                 required_events =
1254                         (XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY |
1255                          XCB_XKB_EVENT_TYPE_MAP_NOTIFY |
1256                          XCB_XKB_EVENT_TYPE_STATE_NOTIFY),
1257
1258                 required_nkn_details =
1259                         (XCB_XKB_NKN_DETAIL_KEYCODES),
1260
1261                 required_map_parts =
1262                         (XCB_XKB_MAP_PART_KEY_TYPES |
1263                          XCB_XKB_MAP_PART_KEY_SYMS |
1264                          XCB_XKB_MAP_PART_MODIFIER_MAP |
1265                          XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS |
1266                          XCB_XKB_MAP_PART_KEY_ACTIONS |
1267                          XCB_XKB_MAP_PART_VIRTUAL_MODS |
1268                          XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP),
1269
1270                 required_state_details =
1271                         (XCB_XKB_STATE_PART_MODIFIER_BASE |
1272                          XCB_XKB_STATE_PART_MODIFIER_LATCH |
1273                          XCB_XKB_STATE_PART_MODIFIER_LOCK |
1274                          XCB_XKB_STATE_PART_GROUP_BASE |
1275                          XCB_XKB_STATE_PART_GROUP_LATCH |
1276                          XCB_XKB_STATE_PART_GROUP_LOCK),
1277         };
1278
1279         static const xcb_xkb_select_events_details_t details = {
1280                 .affectNewKeyboard = required_nkn_details,
1281                 .newKeyboardDetails = required_nkn_details,
1282                 .affectState = required_state_details,
1283                 .stateDetails = required_state_details,
1284         };
1285
1286         cookie = xcb_xkb_select_events_aux_checked(
1287                 conn,
1288                 device_id,
1289                 required_events,        /* affectWhich */
1290                 0,                      /* clear */
1291                 0,                      /* selectAll */
1292                 required_map_parts,     /* affectMap */
1293                 required_map_parts,     /* map */
1294                 &details);              /* details */
1295
1296         error = xcb_request_check(conn, cookie);
1297         if (error) {
1298                 free(error);
1299                 return False;
1300         }
1301
1302         return True;
1303 }
1304
1305 static bool update_keymap(struct xcb_data *xd safe)
1306 {
1307         struct xkb_keymap *new_keymap;
1308         struct xkb_state *new_state;
1309
1310         new_keymap = xkb_x11_keymap_new_from_device(xd->xkb, xd->conn,
1311                                                     xd->xkb_device_id,
1312                                                     XKB_KEYMAP_COMPILE_NO_FLAGS);
1313         if (!new_keymap)
1314                 return False;
1315
1316         new_state = xkb_x11_state_new_from_device(new_keymap, xd->conn,
1317                                                   xd->xkb_device_id);
1318         if (!new_state) {
1319                 xkb_keymap_unref(new_keymap);
1320                 return False;
1321         }
1322
1323         xkb_state_unref(xd->xkb_state);
1324         xkb_keymap_unref(xd->xkb_keymap);
1325         xd->xkb_keymap = new_keymap;
1326         xd->xkb_state = new_state;
1327         return True;
1328 }
1329
1330 static bool kbd_setup(struct xcb_data *xd safe)
1331 {
1332         int ret;
1333         const char *locale;
1334
1335         ret = xkb_x11_setup_xkb_extension(xd->conn,
1336                                           XKB_X11_MIN_MAJOR_XKB_VERSION,
1337                                           XKB_X11_MIN_MINOR_XKB_VERSION,
1338                                           XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS,
1339                                           NULL, NULL, &xd->first_xkb_event,
1340                                           NULL);
1341
1342         if (!ret)
1343                 return False;
1344         xd->xkb = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
1345         if (!xd->xkb)
1346                 return False;
1347         xd->xkb_device_id = xkb_x11_get_core_keyboard_device_id(xd->conn);
1348         if (xd->xkb_device_id == -1)
1349                 return False;
1350
1351         if (!update_keymap(xd))
1352                 return False;
1353
1354         if (!select_xkb_events_for_device(xd->conn, xd->xkb_device_id))
1355                 return False;
1356
1357         locale = setlocale(LC_CTYPE, NULL);
1358         xd->compose_table =
1359                 xkb_compose_table_new_from_locale(xd->xkb, locale,
1360                                                   XKB_COMPOSE_COMPILE_NO_FLAGS);
1361         if (xd->compose_table)
1362                 xd->compose_state =
1363                         xkb_compose_state_new(xd->compose_table,
1364                                               XKB_COMPOSE_STATE_NO_FLAGS);
1365         return True;
1366 }
1367
1368 static void kbd_free(struct xcb_data *xd safe)
1369 {
1370         if (xd->compose_table)
1371                 xkb_compose_table_unref(xd->compose_table);
1372         if (xd->xkb_keymap)
1373                 xkb_keymap_unref(xd->xkb_keymap);
1374         if (xd->xkb)
1375                 xkb_context_unref(xd->xkb);
1376 }
1377
1378 static struct {
1379         char *from safe, *to safe;
1380 } key_map[] = {
1381         { "Return",      ":Enter"},
1382         { "Tab",         ":Tab"},
1383         { "ISO_Left_Tab",":Tab"},
1384         { "Escape",      ":ESC"},
1385         { "Linefeed",    ":LF"},
1386         { "Down",        ":Down"},
1387         { "Up",          ":Up"},
1388         { "Left",        ":Left"},
1389         { "Right",       ":Right"},
1390         { "Home",        ":Home"},
1391         { "End",         ":End"},
1392         { "BackSpace",   ":Backspace"},
1393         { "Delete",      ":Del"},
1394         { "Insert",      ":Ins"},
1395         { "Next",        ":Prior"},
1396         { "Prior",       ":Next"},
1397         { "F1",          ":F1"},
1398         { "F2",          ":F2"},
1399         { "F3",          ":F3"},
1400         { "F4",          ":F4"},
1401         { "F5",          ":F5"},
1402         { "F6",          ":F6"},
1403         { "F7",          ":F7"},
1404         { "F8",          ":F8"},
1405         { "F9",          ":F9"},
1406         { "F10",         ":F11"},
1407         { "F11",         ":F11"},
1408         { "F12",         ":F12"},
1409 };
1410
1411 static void handle_key_press(struct pane *home safe,
1412                              xcb_key_press_event_t *kpe safe)
1413 {
1414         struct xcb_data                 *xd = home->data;
1415         xkb_keycode_t                   keycode = kpe->detail;
1416         xcb_keysym_t                    keysym;
1417         xkb_keysym_t                    sym;
1418         const xkb_keysym_t              *syms;
1419         int                             nsyms;
1420         enum xkb_compose_status         status;
1421         xkb_mod_index_t                 mod;
1422         char                            s[16];
1423         char                            key[16];
1424         char                            mods[32];
1425         bool                            shift=False, ctrl=False, alt=False;
1426
1427         xd->last_event = time(NULL);
1428
1429         keysym = xkb_state_key_get_one_sym(xd->xkb_state,
1430                                            keycode);
1431         if (xd->compose_state)
1432                 xkb_compose_state_feed(xd->compose_state, keysym);
1433         nsyms = xkb_state_key_get_syms(xd->xkb_state, keycode,
1434                                        &syms);
1435         if (nsyms <= 0)
1436                 return;
1437         status = XKB_COMPOSE_NOTHING;
1438         if (xd->compose_state)
1439                 status = xkb_compose_state_get_status(xd->compose_state);
1440         if (status == XKB_COMPOSE_COMPOSING ||
1441             status == XKB_COMPOSE_CANCELLED)
1442                 return;
1443
1444         for (mod = 0; mod < xkb_keymap_num_mods(xd->xkb_keymap); mod++) {
1445                 const char *n;
1446                 if (xkb_state_mod_index_is_active(
1447                             xd->xkb_state, mod,
1448                             XKB_STATE_MODS_EFFECTIVE) <= 0)
1449                         continue;
1450                 /* This does tells me "shift" is consumed for :C:S-l ...
1451                 if (xkb_state_mod_index_is_consumed2(
1452                             xd->xkb_state, keycode, mod,
1453                             XKB_CONSUMED_MODE_XKB))
1454                         continue;
1455                  */
1456                 n = xkb_keymap_mod_get_name(xd->xkb_keymap, mod);
1457                 if (n && strcmp(n, "Shift") == 0)
1458                         shift = True;
1459                 if (n && strcmp(n, "Control") == 0)
1460                         ctrl = True;
1461                 if (n && strcmp(n, "Mod1") == 0)
1462                         alt = True;
1463         }
1464
1465         if (status == XKB_COMPOSE_COMPOSED) {
1466                 sym = xkb_compose_state_get_one_sym(xd->compose_state);
1467                 syms = &sym;
1468                 nsyms = 1;
1469                 s[0] = '-';
1470                 xkb_compose_state_get_utf8(xd->compose_state,
1471                                            s+1, sizeof(s)-1);
1472                 key[0] = 0;
1473                 shift = False;
1474                 ctrl = False;
1475                 /* Mod1 can still apply to a composed char */
1476         } else if (nsyms == 1) {
1477                 unsigned int i;
1478                 sym = xkb_state_key_get_one_sym(xd->xkb_state, keycode);
1479                 syms = &sym;
1480                 s[0] = '-';
1481                 xkb_state_key_get_utf8(xd->xkb_state, keycode,
1482                                        s+1, sizeof(s)-1);
1483                 xkb_keysym_get_name(syms[0], key, sizeof(key));
1484                 for (i = 0; i < ARRAY_SIZE(key_map); i++) {
1485                         if (strcmp(key, key_map[i].from) == 0) {
1486                                 strcpy(s, key_map[i].to);
1487                                 break;
1488                         }
1489                 }
1490                 if (s[0] == '-' && s[1] >= ' ' && s[1] < 0x7f)
1491                         /* Shift is included */
1492                         shift = False;
1493                 if (s[0] == '-' && s[1] && (unsigned char)(s[1]) < ' ') {
1494                         ctrl = True;
1495                         s[1] += '@';
1496                         if (s[1] < 'A' || s[1] > 'Z')
1497                                 shift = False;
1498                 } else if (s[0] == '-' && !s[1] && strcmp(key, "space") == 0) {
1499                         /* 'nul' becomes "C- " (ctrl-space) */
1500                         ctrl = True;
1501                         s[1] = ' ';
1502                         s[2] = 0;
1503                 }
1504         }
1505
1506         if (xd->compose_state &&
1507             (status == XKB_COMPOSE_CANCELLED ||
1508              status == XKB_COMPOSE_COMPOSED))
1509                 xkb_compose_state_reset(xd->compose_state);
1510
1511         if (s[1]) {
1512                 mods[0] = 0;
1513                 if (alt)
1514                         strcat(mods, ":A");
1515                 if (ctrl)
1516                         strcat(mods, ":C");
1517                 if (shift)
1518                         strcat(mods, ":S");
1519                 strcat(mods, s);
1520                 call("Keystroke", home, 0, NULL, mods);
1521         }
1522 }
1523
1524 static void handle_xkb_event(struct pane *home safe,
1525                              xcb_generic_event_t *ev safe)
1526 {
1527         struct xcb_data *xd = home->data;
1528
1529         switch (ev->pad0) {
1530                 xcb_xkb_new_keyboard_notify_event_t     *nkne;
1531                 xcb_xkb_state_notify_event_t            *sne;
1532                 xcb_xkb_map_notify_event_t              *mne;
1533         case XCB_XKB_NEW_KEYBOARD_NOTIFY:
1534                 nkne = (void*)ev;
1535                 if (nkne->deviceID == xd->xkb_device_id &&
1536                     nkne->changed & XCB_XKB_NKN_DETAIL_KEYCODES)
1537                         update_keymap(xd);
1538                 break;
1539         case XCB_XKB_MAP_NOTIFY:
1540                 mne = (void*)ev;
1541                 if (mne->deviceID == xd->xkb_device_id)
1542                         update_keymap(xd);
1543                 break;
1544         case XCB_XKB_STATE_NOTIFY:
1545                 sne = (void*)ev;
1546                 if (sne->deviceID == xd->xkb_device_id)
1547                         xkb_state_update_mask(xd->xkb_state,
1548                                               sne->baseMods,
1549                                               sne->latchedMods,
1550                                               sne->lockedMods,
1551                                               sne->baseGroup,
1552                                               sne->latchedGroup,
1553                                               sne->lockedGroup);
1554                 break;
1555         }
1556 }
1557
1558 static void handle_configure(struct pane *home safe,
1559                              xcb_configure_notify_event_t *cne safe)
1560 {
1561         struct xcb_data *xd = home->data;
1562
1563         pane_resize(home, 0, 0, cne->width, cne->height);
1564         cairo_xcb_surface_set_size(xd->surface, cne->width, cne->height);
1565 }
1566
1567 static void handle_expose(struct pane *home safe,
1568                           xcb_expose_event_t *ee safe)
1569 {
1570         struct xcb_data *xd = home->data;
1571         cairo_rectangle_int_t r = {
1572                 .x = ee->x,
1573                 .y = ee->y,
1574                 .width = ee->width,
1575                 .height = ee->height,
1576         };
1577
1578         if (!xd->need_update)
1579                 xd->need_update = cairo_region_create();
1580         cairo_region_union_rectangle(xd->need_update, &r);
1581         if (ee->count == 0)
1582                 pane_damaged(home, DAMAGED_POSTORDER);
1583 }
1584
1585 static void handle_client_message(struct pane *home safe,
1586                                   xcb_client_message_event_t *cme safe)
1587 {
1588         struct xcb_data *xd = home->data;
1589
1590         if (cme->type == xd->atoms[a_WM_PROTOCOLS] &&
1591             cme->format == 32 &&
1592             cme->window == xd->win &&
1593             cme->data.data32[0] == xd->atoms[a_WM_DELETE_WINDOW]) {
1594                 call("window:close", pane_focus(home));
1595                 return;
1596         }
1597
1598         if (cme->type == xd->atoms[a_WM_PROTOCOLS] &&
1599             cme->format == 32 &&
1600             cme->window == xd->win &&
1601             cme->data.data32[0] == xd->atoms[a_NET_WM_PING]) {
1602                 cme->window = xd->screen->root;
1603                 xcb_send_event(xd->conn, 0, xd->screen->root,
1604                                XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
1605                                XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
1606                                (void*)cme);
1607                 return;
1608         }
1609         LOG("x11 %s got unexpected client message type=%d/%d win=%x data=%d",
1610             xd->display,
1611             cme->type, cme->format, cme->window, cme->data.data32[0]);
1612
1613 }
1614
1615 DEF_CMD(xcb_input)
1616 {
1617         struct xcb_data *xd = ci->home->data;
1618         xcb_generic_event_t *ev;
1619         int ret = 1;
1620
1621         wait_for(xd);
1622         if (ci->num < 0)
1623                 /* This is a poll - only return 1 on something happening */
1624                 ret = Efalse;
1625
1626         while ((ev = xcb_poll_for_event(xd->conn)) != NULL) {
1627                 ret = 1;
1628                 switch (ev->response_type & 0x7f) {
1629                 case XCB_KEY_PRESS:
1630                         time_start(TIME_KEY);
1631                         handle_key_press(ci->home, safe_cast (void*)ev);
1632                         time_stop(TIME_KEY);
1633                         break;
1634                 case XCB_KEY_RELEASE:
1635                         /* Ignore for now */
1636                         break;
1637                 case XCB_BUTTON_PRESS:
1638                 case XCB_BUTTON_RELEASE:
1639                         time_start(TIME_KEY);
1640                         handle_button(ci->home, (void*)ev);
1641                         time_stop(TIME_KEY);
1642                         break;
1643                 case XCB_MOTION_NOTIFY:
1644                         time_start(TIME_KEY);
1645                         handle_motion(ci->home, (void*)ev);
1646                         time_stop(TIME_KEY);
1647                         break;
1648                 case XCB_FOCUS_IN:
1649                 case XCB_FOCUS_OUT:
1650                         time_start(TIME_WINDOW);
1651                         handle_focus(ci->home, (void*)ev);
1652                         time_stop(TIME_WINDOW);
1653                         break;
1654                 case XCB_EXPOSE:
1655                         time_start(TIME_WINDOW);
1656                         handle_expose(ci->home, (void*)ev);
1657                         time_stop(TIME_WINDOW);
1658                         break;
1659                 case XCB_CONFIGURE_NOTIFY:
1660                         time_start(TIME_WINDOW);
1661                         handle_configure(ci->home, (void*)ev);
1662                         time_stop(TIME_WINDOW);
1663                         break;
1664                 case XCB_CLIENT_MESSAGE:
1665                         time_start(TIME_WINDOW);
1666                         handle_client_message(ci->home, (void*)ev);
1667                         time_stop(TIME_WINDOW);
1668                         break;
1669                 case XCB_REPARENT_NOTIFY:
1670                         /* Not interested */
1671                         break;
1672                 case XCB_MAP_NOTIFY:
1673                 case XCB_UNMAP_NOTIFY:
1674                 case XCB_MAPPING_NOTIFY:
1675                         /* FIXME what to do?? */
1676                         break;
1677                 case 0:
1678                         /* Don't know what this means, but I get a lot
1679                          * of them so I don't want to log that it was
1680                          * ignored.
1681                          */
1682                         break;
1683                 default:
1684                         if ((ev->response_type & 0x7f) ==
1685                             xd->first_xkb_event) {
1686                                 handle_xkb_event(ci->home, ev);
1687                                 break;
1688                         }
1689                         LOG("Ignored X11 event %d", ev->response_type);
1690                 }
1691                 xcb_flush(xd->conn);
1692         }
1693         if (xcb_connection_has_error(xd->conn)) {
1694                 call("window:close", ci->home->parent);
1695                 pane_close(ci->home);
1696         }
1697         return ret;
1698 }
1699
1700 static void set_str_prop(struct xcb_data *xd safe,
1701                          enum my_atoms a, const char *str safe)
1702 {
1703         xcb_change_property(xd->conn,
1704                             XCB_PROP_MODE_REPLACE,
1705                             xd->win, xd->atoms[a], XCB_ATOM_STRING,
1706                             8, strlen(str), str);
1707 }
1708
1709 static void set_utf8_prop(struct xcb_data *xd safe,
1710                          enum my_atoms a, const char *str safe)
1711 {
1712         xcb_change_property(xd->conn,
1713                             XCB_PROP_MODE_REPLACE,
1714                             xd->win, xd->atoms[a],
1715                             xd->atoms[a_UTF8_STRING],
1716                             8, strlen(str), str);
1717 }
1718
1719 static void set_card32_property(struct xcb_data *xd safe,
1720                                 enum my_atoms a,
1721                                 const uint32_t *data, int cnt)
1722 {
1723         xcb_change_property(xd->conn,
1724                             XCB_PROP_MODE_REPLACE,
1725                             xd->win, xd->atoms[a],
1726                             XCB_ATOM_CARDINAL, 32,
1727                             cnt, data);
1728 }
1729
1730 static void set_atom_prop(struct xcb_data *xd safe,
1731                           enum my_atoms prop, enum my_atoms alist, ...)
1732 {
1733         uint32_t atoms[16];
1734         int anum = 0;
1735         va_list ap;
1736         enum my_atoms a;
1737
1738         atoms[anum++] = xd->atoms[alist];
1739         va_start(ap, alist);
1740         while ((a = va_arg(ap, enum my_atoms)) != a_NONE)
1741                 if (anum < 16)
1742                         atoms[anum++] = xd->atoms[a];
1743         va_end(ap);
1744         xcb_change_property(xd->conn,
1745                             XCB_PROP_MODE_REPLACE,
1746                             xd->win, xd->atoms[prop],
1747                             XCB_ATOM_ATOM,
1748                             32, anum, atoms);
1749 }
1750
1751 static void xcb_load_icon(struct pane *p safe,
1752                           struct xcb_data *xd safe,
1753                           char *file safe)
1754 {
1755         char *path;
1756         int h, w, n;
1757         unsigned int *data;
1758         MagickBooleanType status;
1759         MagickWand *wd;
1760         uint32_t fmt[2];
1761
1762         path = call_ret(str, "xdg-find-edlib-file", p, 0, NULL,
1763                         file, 0, NULL, "data");
1764         if (!path)
1765                 return;
1766
1767         wd = NewMagickWand();
1768         status = MagickReadImage(wd, path);
1769         free(path);
1770         if (status == MagickFalse)
1771                 goto done;
1772
1773         h = MagickGetImageHeight(wd);
1774         w = MagickGetImageWidth(wd);
1775         n = 2 + w*h;
1776         data = malloc(sizeof(data[0]) * n);
1777         if (!data)
1778                 goto done;
1779         data[0] = w;
1780         data[1] = h;
1781         /* Need host-endian ARGB data */
1782         fmt[0] = ('A'<<24) | ('R' << 16) | ('G' << 8) | ('B' << 0);
1783         fmt[1] = 0;
1784         MagickExportImagePixels(wd, 0, 0, w, h, (char*)fmt,
1785                                 CharPixel, data+2);
1786         set_card32_property(xd, a_NET_WM_ICON, data, n);
1787         free(data);
1788 done:
1789         DestroyMagickWand(wd);
1790         return;
1791 }
1792
1793 static struct pane *xcb_display_init(const char *d safe,
1794                                      const char *disp_auth,
1795                                      struct pane *focus safe)
1796 {
1797         struct xcb_data *xd;
1798         struct pane *p;
1799         xcb_connection_t *conn;
1800         xcb_intern_atom_cookie_t cookies[NR_ATOMS];
1801         xcb_screen_iterator_t iter;
1802         xcb_depth_iterator_t di;
1803         char scale[20];
1804         char hostname[128];
1805         uint32_t valwin[2];
1806         int screen = 0;
1807         int i;
1808         PangoLayout *layout;
1809         PangoRectangle log;
1810         cairo_t *cairo;
1811         cairo_surface_t *surface;
1812         PangoFontDescription *fd;
1813         // FIXME SCALE from environ?? or pango_cairo_context_set_resolution dpi
1814         // 254 * width_in_pixels / width_in_millimeters / 10
1815
1816         conn = safe_cast xcb_connect_auth(d, disp_auth, &screen);
1817         if (xcb_connection_has_error(conn))
1818                 return NULL;
1819
1820         p = pane_register(pane_root(focus), 1, &xcb_handle.c);
1821         if (!p)
1822                 return NULL;
1823         xd = p->data;
1824
1825         xd->motion_blocked = True;
1826         xd->in_focus = True;
1827
1828         xd->conn = conn;
1829         xd->display = strdup(d);
1830         if (disp_auth)
1831                 xd->disp_auth = strdup(disp_auth);
1832         xd->setup = safe_cast xcb_get_setup(conn);
1833         iter = xcb_setup_roots_iterator(xd->setup);
1834         for (i = 0; i < screen; i++)
1835                 xcb_screen_next(&iter);
1836         xd->screen = safe_cast iter.data;
1837
1838         di = xcb_screen_allowed_depths_iterator(xd->screen);
1839         while (di.data && di.data->depth < 24)
1840                 xcb_depth_next(&di);
1841         //?? look for class = TrueColor??
1842         xd->visual = xcb_depth_visuals(di.data);
1843
1844         for (i = 0; i < NR_ATOMS; i++) {
1845                 const char *n = atom_names[i];
1846                 if (!n)
1847                         continue;
1848                 cookies[i] = xcb_intern_atom(conn, 0, strlen(n), n);
1849         }
1850
1851         xd->win = xcb_generate_id(conn);
1852         valwin[0] = xd->screen->white_pixel;
1853         valwin[1] = (XCB_EVENT_MASK_KEY_PRESS |
1854                      XCB_EVENT_MASK_KEY_RELEASE |
1855                      XCB_EVENT_MASK_BUTTON_PRESS |
1856                      XCB_EVENT_MASK_BUTTON_RELEASE |
1857                      // XCB_EVENT_MASK_ENTER_WINDOW |
1858                      // XCB_EVENT_MASK_LEAVE_WINDOW |
1859                      XCB_EVENT_MASK_FOCUS_CHANGE |
1860                      XCB_EVENT_MASK_STRUCTURE_NOTIFY |
1861                      XCB_EVENT_MASK_EXPOSURE |
1862                      XCB_EVENT_MASK_BUTTON_MOTION |
1863                      XCB_EVENT_MASK_POINTER_MOTION_HINT |
1864                      0);
1865
1866         xcb_create_window(conn, XCB_COPY_FROM_PARENT, xd->win,
1867                           xd->screen->root,
1868                           0, 0,
1869                           100, 100,
1870                           0, XCB_WINDOW_CLASS_INPUT_OUTPUT,
1871                           xd->screen->root_visual,
1872                           XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK,
1873                           valwin);
1874         xcb_flush(conn);
1875         kbd_setup(xd);
1876
1877         surface = cairo_xcb_surface_create(
1878                 conn, xd->win, xd->visual, 100, 100);
1879         if (!surface)
1880                 goto abort;
1881         xd->surface = surface;
1882         cairo = safe_cast cairo_create(xd->surface);
1883         if (cairo_status(cairo) != CAIRO_STATUS_SUCCESS)
1884                 goto abort;
1885         xd->cairo = cairo;
1886         fd = pango_font_description_new();
1887         if (!fd)
1888                 goto abort;
1889         xd->fd = fd;
1890         pango_font_description_set_family(xd->fd, "monospace");
1891         pango_font_description_set_size(xd->fd, 12 * PANGO_SCALE);
1892
1893         layout = pango_cairo_create_layout(xd->cairo);
1894         pango_layout_set_font_description(layout, fd);
1895         pango_layout_set_text(layout, "M", 1);
1896         pango_layout_get_pixel_extents(layout, NULL, &log);
1897         g_object_unref(layout);
1898         xd->lineheight = log.height;
1899         xd->charwidth = log.width;
1900
1901         valwin[0] = xd->charwidth * 80;
1902         valwin[1] = xd->lineheight * 26;
1903         xcb_configure_window(conn, xd->win,
1904                              XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,
1905                              valwin);
1906         cairo_xcb_surface_set_size(xd->surface, valwin[0], valwin[1]);
1907
1908         /* Now resolve all those cookies */
1909         for (i = 0; i < NR_ATOMS; i++) {
1910                 xcb_intern_atom_reply_t *r;
1911                 r = xcb_intern_atom_reply(conn, cookies[i], NULL);
1912                 if (!r)
1913                         goto abort;
1914                 xd->atoms[i] = r->atom;
1915                 free(r);
1916         }
1917
1918         /* FIXME set:
1919          *
1920          * WM_PROTOCOLS _NET_WM_SYN_REQUEST??
1921          * WM_NORMAL_HINTS WM_HINTS
1922          * WM_CLIENT_MACHINE
1923          */
1924         set_str_prop(xd, a_WM_NAME, "EdLib");
1925         set_utf8_prop(xd, a_NET_WM_NAME, "EdLib");
1926         set_str_prop(xd, a_WM_ICON_NAME, "EdLib");
1927         set_utf8_prop(xd, a_NET_WM_ICON_NAME, "EdLib");
1928         gethostname(hostname, sizeof(hostname));
1929         set_str_prop(xd, a_WM_CLIENT_MACHINE, hostname);
1930         set_atom_prop(xd, a_WM_PROTOCOLS, a_WM_DELETE_WINDOW, a_NET_WM_PING, 0);
1931
1932         /* Configure passive grabs - shift, lock, and control only */
1933         xcb_grab_button(xd->conn, 0, xd->win,
1934                         XCB_EVENT_MASK_BUTTON_PRESS |
1935                         XCB_EVENT_MASK_BUTTON_RELEASE |
1936                         XCB_EVENT_MASK_BUTTON_MOTION,
1937                         XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC,
1938                         XCB_WINDOW_NONE, XCB_CURSOR_NONE,
1939                         XCB_BUTTON_INDEX_ANY,
1940                         XCB_MOD_MASK_SHIFT |
1941                         XCB_MOD_MASK_LOCK |
1942                         XCB_MOD_MASK_CONTROL);
1943
1944         xcb_load_icon(focus, xd, "{COMM}-icon.png");
1945         xcb_map_window(conn, xd->win);
1946         xcb_flush(conn);
1947         pane_resize(p, 0, 0, xd->charwidth*80, xd->lineheight*26);
1948         call_comm("event:read", p, &xcb_input, xcb_get_file_descriptor(conn));
1949         call_comm("event:poll", p, &xcb_input);
1950         attr_set_str(&p->attrs, "DISPLAY", d);
1951         attr_set_str(&p->attrs, "XAUTHORITY", disp_auth);
1952         snprintf(scale, sizeof(scale), "%dx%d", xd->charwidth, xd->lineheight);
1953         attr_set_str(&p->attrs, "scale:M", scale);
1954         xd->last_event = time(NULL);
1955         call("editor:request:all-displays", p);
1956         p = call_ret(pane, "editor:activate-display", p);
1957         return p;
1958 abort:
1959         kbd_free(xd);
1960         cairo_destroy(xd->cairo);
1961         cairo_surface_destroy(xd->surface);
1962         xcb_disconnect(conn);
1963         free(xd->display);
1964         free(xd->disp_auth);
1965         return NULL;
1966 }
1967
1968 DEF_CMD(xcb_new_display)
1969 {
1970         struct pane *p;
1971         const char *d = ci->str;
1972         const char *disp_auth = ci->str2;
1973
1974         if (!d)
1975                 d = pane_attr_get(ci->focus, "DISPLAY");
1976         if (!disp_auth)
1977                 disp_auth = pane_attr_get(ci->focus, "XAUTHORITY");
1978         if (!disp_auth)
1979                 disp_auth = getenv("XAUTHORITY");
1980
1981         if (!d)
1982                 return Enoarg;
1983         p = xcb_display_init(d, disp_auth, ci->focus);
1984         if (p)
1985                 home_call_ret(pane, ci->focus, "doc:attach-view", p, 1);
1986         if (p)
1987                 comm_call(ci->comm2, "cb", p);
1988         return 1;
1989 }
1990
1991 void edlib_init(struct pane *ed safe)
1992 {
1993         call_comm("global-set-command", ed, &xcb_new_display, 0, NULL,
1994                   "attach-display-x11");
1995         call_comm("global-set-command", ed, &xcb_new_display, 0, NULL,
1996                   "interactive-cmd-x11window");
1997
1998         xcb_map = key_alloc();
1999
2000         key_add(xcb_map, "window:close", &xcb_close_display);
2001         key_add(xcb_map, "window:external-viewer", &xcb_external_viewer);
2002         key_add(xcb_map, "window:fullscreen", &xcb_fullscreen);
2003         key_add(xcb_map, "window:new", &xcb_new_display);
2004
2005         key_add(xcb_map, "Close", &xcb_close);
2006         key_add(xcb_map, "Draw:clear", &xcb_clear);
2007         key_add(xcb_map, "Draw:text-size", &xcb_text_size);
2008         key_add(xcb_map, "Draw:text", &xcb_draw_text);
2009         key_add(xcb_map, "Draw:image", &xcb_draw_image);
2010         key_add(xcb_map, "Draw:image-size", &xcb_image_size);
2011         key_add(xcb_map, "Refresh:size", &xcb_refresh_size);
2012         key_add(xcb_map, "Refresh:postorder", &xcb_refresh_post);
2013         key_add(xcb_map, "all-displays", &xcb_notify_display);
2014         key_add(xcb_map, "Notify:Close", &xcb_pane_close);
2015 }