2 * Copyright Neil Brown ©2021-2023 <neil@brown.name>
3 * May be distributed under terms of GPLv2 - see file:COPYING
5 * X11 display driver for edlib, using xcb, cairopango, libxkbcommon etc.
7 * A different connection to the server will be created for each
8 * display. Maybe that can be optimised one day.
23 /* xkb.h has a 'long' in an 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,
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;
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 {
57 /* and other fields */
58 } xcb_xkb_new_keyboard_notify_event_t;
59 typedef struct xcb_xkb_state_notify_event_t {
67 /* and other fields */
68 } xcb_xkb_state_notify_event_t;
69 typedef struct xcb_xkb_map_notify_event_t {
71 } xcb_xkb_map_notify_event_t;
73 xcb_xkb_select_events_aux_checked(xcb_connection_t *c,
74 xcb_xkb_device_spec_t deviceSpec,
80 const xcb_xkb_select_events_details_t *details);
83 #include <xcb/xcbext.h>
89 #include <cairo-xcb.h>
91 #include <wand/MagickWand.h>
93 // enums confuse sparse...
94 #define MagickBooleanType int
98 #include <pango/pango.h>
99 #include <pango/pangocairo.h>
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
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)
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*);
139 #include <xkbcommon/xkbcommon.h>
140 #include <xkbcommon/xkbcommon-compose.h>
141 #include <xkbcommon/xkbcommon-x11.h>
148 #define PANE_DATA_TYPE struct xcb_data
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,
163 static const char *atom_names[NR_ATOMS] = {
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",
184 xcb_connection_t *conn safe;
188 const xcb_setup_t *setup safe;
189 const xcb_screen_t *screen safe;
190 xcb_atom_t atoms[NR_ATOMS];
194 xcb_visualtype_t *visual;
196 cairo_surface_t *surface safe;
197 PangoFontDescription *fd safe;
198 int charwidth, lineheight;
199 cairo_region_t *need_update;
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;
217 /* FIXME use hash?? */
221 cairo_rectangle_int_t r;
225 cairo_surface_t *surface;
226 cairo_region_t *need_update;
229 #include "core-pane.h"
231 /* panes->r.x is NEVER_DRAWN if the pane has not been drawn */
232 #define NEVER_DRAWN (-60000)
234 static struct map *xcb_map;
235 DEF_LOOKUP_CMD(xcb_handle, xcb_map);
237 static struct panes *get_pixmap(struct pane *home safe,
240 struct xcb_data *xd = home->data;
241 struct panes **pp, *ps;
243 for (pp = &xd->panes; (ps = *pp) != NULL; pp = &(*pp)->next) {
246 if (ps->r.width == p->w && ps->r.height == p->h)
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);
255 cairo_destroy(ps->ctx);
257 cairo_surface_destroy(ps->surface);
259 xcb_free_pixmap(xd->conn, ps->draw);
265 ps->r.x = ps->r.y = NEVER_DRAWN;
268 ps->bg.r = ps->bg.g = ps->bg.b = 0;
270 pane_add_notify(home, p, "Notify:Close");
276 static void instantiate_pixmap(struct xcb_data *xd safe,
277 struct panes *ps safe)
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);
286 ps->ctx = cairo_create(ps->surface);
289 cairo_set_source_rgb(ps->ctx, ps->bg.r, ps->bg.g, ps->bg.b);
290 cairo_paint(ps->ctx);
294 cairo_surface_destroy(ps->surface);
297 xcb_free_pixmap(xd->conn, ps->draw);
301 static struct panes *find_pixmap(struct xcb_data *xd safe, struct pane *p safe,
302 int *xp safe, int *yp safe)
305 struct panes *ret = NULL;
307 while (!ret && p->parent != p) {
309 for (ps = xd->panes; ps ; ps = ps->next)
325 static inline double cvt(int i)
327 return (float)i / 1000.0;
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)
335 char *attrs = strdup(cattrs ?: "");
338 char *fg = NULL, *bg = NULL;
342 PangoFontDescription *fd = NULL;
343 PangoStyle style = PANGO_STYLE_NORMAL;
344 PangoVariant variant = PANGO_VARIANT_NORMAL;
345 PangoWeight weight = PANGO_WEIGHT_NORMAL;
348 fd = pango_font_description_new();
350 pango_font_description_set_family_static(fd, "monospace");
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)
358 if (strcmp(word, "small") == 0)
360 if (isdigit(word[0])) {
362 double s = strtod(word, &end);
363 if (end && end != word && !*end)
364 size = trunc(s * 1000.0);
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;
377 if (strcmp(word, "bold") == 0)
378 weight = PANGO_WEIGHT_BOLD;
379 if (strcmp(word, "nobold") == 0)
380 weight = PANGO_WEIGHT_NORMAL;
382 if (strstarts(word, "fg:"))
384 if (strstarts(word, "bg:"))
386 if (strcmp(word, "inverse") == 0)
388 if (strcmp(word, "noinverse") == 0)
390 if (strcmp(word, "underline") == 0)
392 if (strcmp(word, "nounderline") == 0)
408 struct call_return ret = call_ret(all, "colour:map", home,
411 fgp->g = cvt(ret.i2);
416 struct call_return ret = call_ret(all, "colour:map", home,
419 bgp->g = cvt(ret.i2);
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);
439 struct call_return *cr = container_of(ci->comm, struct call_return, c);
445 DEF_CMD_CLOSED(xcb_close_display)
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");
452 call("Message", ci->focus, 0, NULL, nc);
457 call_comm("editor:notify:all-displays", ci->focus, &cr.c);
461 call("Message", ci->focus, 0, NULL,
462 "Cannot close only window.");
466 static void wait_for(struct xcb_data *xd safe)
468 struct pids **pp = &xd->pids;
471 struct pids *p = *pp;
472 if (waitpid(p->pid, NULL, WNOHANG) > 0) {
480 DEF_CMD(xcb_external_viewer)
482 struct xcb_data *xd = ci->home->data;
483 const char *path = ci->str;
490 switch (pid = fork()) {
494 setenv("DISPLAY", xd->display, 1);
496 setenv("XAUTHORITY", xd->disp_auth, 1);
497 fd = open("/dev/null", O_RDWR);
505 execlp("xdg-open", "xdg-open", path, NULL);
507 default: /* parent */
508 p = malloc(sizeof(*p));
518 DEF_CMD(xcb_fullscreen)
520 struct xcb_data *xd = ci->home->data;
521 xcb_client_message_event_t msg = {};
523 msg.response_type = XCB_CLIENT_MESSAGE;
525 msg.window = xd->win;
526 msg.type = xd->atoms[a_WM_STATE];
528 msg.data.data32[0] = 1; /* ADD */
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 */
535 xcb_send_event(xd->conn, 0, xd->screen->root,
536 XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
537 XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
543 static void panes_free(struct xcb_data *xd safe)
546 struct panes *ps = xd->panes;
547 xd->panes = ps->next;
549 cairo_destroy(ps->ctx);
551 cairo_surface_destroy(ps->surface);
553 xcb_free_pixmap(xd->conn, ps->draw);
558 static void kbd_free(struct xcb_data *xd safe);
560 DEF_CMD_CLOSED(xcb_close)
562 struct xcb_data *xd = ci->home->data;
564 xcb_destroy_window(xd->conn, xd->win);
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);
574 xcb_disconnect(xd->conn);
576 cairo_region_destroy(xd->need_update);
582 struct xcb_data *xd = ci->home->data;
583 const char *attr = ci->str;
584 struct panes *src = NULL, *dest;
587 cairo_rectangle_int_t r;
590 parse_attrs(ci->home, attr, PANGO_SCALE, NULL, &bg, NULL, NULL);
592 bg.r = bg.g = bg.b = 1.0;
594 src = find_pixmap(xd, ci->focus->parent, &x, &y);
598 bg.r = bg.g = bg.b = 1.0;
599 else if (src->bg.g >= 0)
601 else if (src->surface == NULL)
602 bg.r = bg.g = bg.b = 1.0;
607 dest = get_pixmap(ci->home, ci->focus);
612 cairo_set_source_rgb(dest->ctx, bg.r, bg.g, bg.b);
613 cairo_paint(dest->ctx);
618 instantiate_pixmap(xd, dest);
620 cairo_set_source_surface(dest->ctx, src->surface, -x, -y);
621 cairo_paint(dest->ctx);
625 pane_damaged(ci->home, DAMAGED_POSTORDER);
627 if (!dest->need_update)
628 dest->need_update = cairo_region_create();
631 r.width = ci->focus->w;
632 r.height = ci->focus->h;
633 cairo_region_union_rectangle(dest->need_update, &r);
637 DEF_CMD(xcb_text_size)
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;
644 PangoFontDescription *fd;
651 if (!utf8_valid(str))
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;
663 else if (log.width <= ci->num)
664 max_bytes = strlen(str);
666 pango_layout_xy_to_index(layout, PANGO_SCALE*ci->num,
667 baseline, &max_bytes, NULL);
669 comm_call(ci->comm2, "cb", ci->focus, max_bytes, NULL, NULL,
670 baseline, NULL, NULL,
671 str && *str ? log.width : 0,
674 pango_font_description_free(fd);
675 g_object_unref(layout);
679 DEF_CMD(xcb_draw_text)
681 struct xcb_data *xd = ci->home->data;
682 const char *str = ci->str;
683 const char *attr = ci->str2;
688 PangoFontDescription *fd;
698 ps = find_pixmap(xd, ci->focus, &xo, &yo);
702 instantiate_pixmap(xd, ps);
708 if (!utf8_valid(str))
711 pane_damaged(ci->home, DAMAGED_POSTORDER);
714 scale = ci->num2 * 10 / xd->charwidth;
716 parse_attrs(ci->home, attr, scale, &fg, &bg, &ul, &fd);
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;
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);
732 cairo_set_source_rgb(ctx, fg.r, fg.g, fg.b);
734 /* Draw an underline */
735 cairo_rectangle(ctx, x+log.x, y+2+log.y,
740 cairo_move_to(ctx, x, y - baseline);
741 pango_cairo_show_layout(ctx, layout);
745 /* draw a cursor - outline box if not in-focus,
746 * inverse-video if it is.
749 bool in_focus = xd->in_focus;
750 struct pane *f = ci->focus;
751 double cx, cy, cw, ch;
753 pango_layout_index_to_pos(layout, ci->num, &curs);
754 if (curs.width <= 0) {
756 pango_layout_set_text(layout, "M", 1);
757 pango_layout_get_extents(layout, NULL, &log);
758 curs.width = log.width;
761 while (in_focus && f->parent->parent != f &&
762 f->parent != ci->home) {
763 if (f->parent->focus != f && f->z >= 0)
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);
779 /* solid fd:block with txt in bg color */
781 x+curs.x/PANGO_SCALE,
782 y-baseline+curs.y/PANGO_SCALE,
783 curs.width / PANGO_SCALE,
784 curs.height / PANGO_SCALE);
786 if (ci->num < (int)strlen(str)) {
787 const char *cp = str + ci->num;
789 pango_layout_set_text(layout, str + ci->num,
790 cp - (str + ci->num));
792 cairo_set_source_rgb(ctx, bg.r, bg.g, bg.b);
794 cairo_set_source_rgb(ctx, 1.0, 1.0, 1.0);
796 x + curs.x / PANGO_SCALE,
797 y - baseline + curs.y / PANGO_SCALE);
798 pango_cairo_show_layout(ctx, layout);
803 pango_font_description_free(fd);
804 g_object_unref(layout);
808 DEF_CMD(xcb_draw_image)
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
823 struct xcb_data *xd = ci->home->data;
824 bool stretch = ci->num & 16;
826 int w = ci->focus->w, h = ci->focus->h;
831 MagickBooleanType status;
835 cairo_surface_t *surface;
839 ps = find_pixmap(xd, ci->focus, &xo, &yo);
843 instantiate_pixmap(xd, ps);
847 if (strstarts(ci->str, "file:")) {
848 wd = NewMagickWand();
849 status = MagickReadImage(wd, ci->str + 5);
850 if (status == MagickFalse) {
851 DestroyMagickWand(wd);
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);
859 DestroyMagickWand(wd);
862 status = MagickReadImageBlob(wd, cr.s, cr.i);
864 if (status == MagickFalse) {
865 DestroyMagickWand(wd);
871 MagickAutoOrientImage(wd);
873 int ih = MagickGetImageHeight(wd);
874 int iw = MagickGetImageWidth(wd);
876 if (iw <= 0 || iw <= 0) {
877 DestroyMagickWand(wd);
880 if (iw * h > ih * w) {
881 /* Image is wider than space, use less height */
883 switch(pos & (8+4)) {
885 y = (h - ih) / 2; break;
891 /* image is too tall, use less width */
893 switch (pos & (1+2)) {
895 x = (w - iw) / 2; break;
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
909 fmt[0] = ('A'<<24) | ('R' << 16) | ('G' << 8) | ('B' << 0);
911 MagickExportImagePixels(wd, 0, 0, w, h, (char*)fmt, CharPixel, buf);
912 surface = cairo_image_surface_create_for_data(buf, CAIRO_FORMAT_ARGB32,
914 cairo_set_source_surface(ps->ctx, surface, x + xo, y + yo);
915 cairo_paint(ps->ctx);
916 cairo_surface_destroy(surface);
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,
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);
927 DestroyMagickWand(wd);
929 pane_damaged(ci->home, DAMAGED_POSTORDER);
934 DEF_CMD(xcb_image_size)
936 MagickBooleanType status;
942 if (strstarts(ci->str, "file:")) {
943 wd = NewMagickWand();
944 status = MagickReadImage(wd, ci->str + 5);
945 if (status == MagickFalse) {
946 DestroyMagickWand(wd);
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);
954 DestroyMagickWand(wd);
957 status = MagickReadImageBlob(wd, cr.s, cr.i);
959 if (status == MagickFalse) {
960 DestroyMagickWand(wd);
966 MagickAutoOrientImage(wd);
967 ih = MagickGetImageHeight(wd);
968 iw = MagickGetImageWidth(wd);
970 DestroyMagickWand(wd);
971 comm_call(ci->comm2, "callback:size", ci->focus,
972 0, NULL, NULL, 0, NULL, NULL,
977 static struct panes *sort_split(struct panes *p)
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
983 * If p is ordered, this means we return NULL.
985 struct panes *ret, **end = &ret;
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.
993 if (p->p->abs_z < next->p->abs_z) {
1002 static struct panes *sort_merge(struct panes *p1, struct panes *p2)
1004 /* merge p1 and p2 and return result */
1005 struct panes *ret, **end = &ret;
1006 struct panes *prev = NULL;
1009 /* Make p1 the largest (or be added first.
1010 * Then in prev is between them add p2, else p1
1012 if (p1->p->abs_z < p2->p->abs_z) {
1013 struct panes *t = p1;
1018 p1->p->abs_z > prev->p->abs_z &&
1019 prev->p->abs_z >= p2->p->abs_z) {
1020 /* p2 is the better choice */
1037 DEF_CMD(xcb_refresh_post)
1039 struct xcb_data *xd = ci->home->data;
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);
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)
1054 rel = pane_mapxy(ps->p, ci->home, 0, 0, False);
1055 if (ps->r.x == NEVER_DRAWN) {
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.
1064 cairo_region_union_rectangle(xd->need_update, &ps->r);
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);
1072 if (ps->need_update)
1073 cairo_region_destroy(ps->need_update);
1074 ps->need_update = NULL;
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;
1080 cairo_rectangle_int_t r;
1083 cr = cairo_region_copy(xd->need_update);
1085 rel = pane_mapxy(ps->p, ci->home, 0, 0, False);
1087 cairo_save(xd->cairo);
1089 cairo_set_source_rgb(xd->cairo,
1090 ps->bg.r, ps->bg.g, ps->bg.b);
1092 cairo_set_source_surface(xd->cairo, ps->surface,
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);
1107 cairo_restore(xd->cairo);
1110 cairo_region_destroy(xd->need_update);
1111 xd->need_update = NULL;
1112 time_stop(TIME_WINDOW);
1113 xcb_flush(xd->conn);
1117 DEF_CMD(xcb_refresh_size)
1119 /* FIXME: should I consider resizing the window?
1120 * For now, just ensure we redraw everything.
1122 struct xcb_data *xd = ci->home->data;
1123 cairo_rectangle_int_t r = {
1126 .width = ci->home->w,
1127 .height = ci->home->h,
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;
1137 DEF_CMD(xcb_pane_close)
1139 struct xcb_data *xd = ci->home->data;
1140 struct panes **pp, *ps;
1142 for (pp = &xd->panes; (ps = *pp) != NULL; pp = &(*pp)->next) {
1143 if (ps->p != ci->focus)
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);
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);
1159 pane_damaged(ci->home, DAMAGED_POSTORDER);
1165 DEF_CMD(xcb_notify_display)
1167 struct xcb_data *xd = ci->home->data;
1168 comm_call(ci->comm2, "callback:display", ci->home, xd->last_event);
1172 static void handle_button(struct pane *home safe,
1173 xcb_button_press_event_t *be safe)
1175 struct xcb_data *xd = home->data;
1176 bool press = (be->response_type & 0x7f) == XCB_BUTTON_PRESS;
1178 char key[2+2+2+9+1+1];
1180 xcb_set_input_focus(xd->conn, XCB_INPUT_FOCUS_POINTER_ROOT,
1181 xd->win, XCB_CURRENT_TIME);
1184 xd->motion_blocked = False;
1185 if (be->state & XCB_KEY_BUT_MASK_MOD_1)
1187 if (be->state & XCB_KEY_BUT_MASK_CONTROL)
1189 if (be->state & XCB_KEY_BUT_MASK_SHIFT)
1192 strcat(key, ":Press-X");
1193 } else if (be->detail >= 4)
1194 /* ignore 'release' for scroll wheel */
1197 strcpy(key, ":Release-X");
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);
1206 static void handle_motion(struct pane *home safe,
1207 xcb_motion_notify_event_t *mne safe)
1209 struct xcb_data *xd = home->data;
1210 xcb_query_pointer_cookie_t c;
1211 xcb_query_pointer_reply_t *qpr;
1213 int x = mne->event_x, y = mne->event_y;
1215 if (xd->motion_blocked)
1217 ret = call("Mouse-event", home, 0, NULL, ":Motion",
1218 3, NULL, NULL, x, y);
1220 xd->motion_blocked = True;
1222 /* This doesn't seem to be needed, but the spec says
1223 * I should do this when using POINTER_MOTION_HINT
1225 c = xcb_query_pointer(xd->conn, xd->win);
1226 qpr = xcb_query_pointer_reply(xd->conn, c, NULL);
1230 static void handle_focus(struct pane *home safe, xcb_focus_in_event_t *fie safe)
1232 struct xcb_data *xd = home->data;
1233 bool in = (fie->response_type & 0x7f) == XCB_FOCUS_IN;
1238 p = pane_focus(home);
1239 pt = call_ret(mark, "doc:point", p);
1241 call("view:changed", p, 0, pt);
1243 call("pane:refocus", home);
1246 static bool select_xkb_events_for_device(xcb_connection_t *conn,
1249 xcb_generic_error_t *error;
1250 xcb_void_cookie_t cookie;
1254 (XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY |
1255 XCB_XKB_EVENT_TYPE_MAP_NOTIFY |
1256 XCB_XKB_EVENT_TYPE_STATE_NOTIFY),
1258 required_nkn_details =
1259 (XCB_XKB_NKN_DETAIL_KEYCODES),
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),
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),
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,
1286 cookie = xcb_xkb_select_events_aux_checked(
1289 required_events, /* affectWhich */
1292 required_map_parts, /* affectMap */
1293 required_map_parts, /* map */
1294 &details); /* details */
1296 error = xcb_request_check(conn, cookie);
1305 static bool update_keymap(struct xcb_data *xd safe)
1307 struct xkb_keymap *new_keymap;
1308 struct xkb_state *new_state;
1310 new_keymap = xkb_x11_keymap_new_from_device(xd->xkb, xd->conn,
1312 XKB_KEYMAP_COMPILE_NO_FLAGS);
1316 new_state = xkb_x11_state_new_from_device(new_keymap, xd->conn,
1319 xkb_keymap_unref(new_keymap);
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;
1330 static bool kbd_setup(struct xcb_data *xd safe)
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,
1344 xd->xkb = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
1347 xd->xkb_device_id = xkb_x11_get_core_keyboard_device_id(xd->conn);
1348 if (xd->xkb_device_id == -1)
1351 if (!update_keymap(xd))
1354 if (!select_xkb_events_for_device(xd->conn, xd->xkb_device_id))
1357 locale = setlocale(LC_CTYPE, NULL);
1359 xkb_compose_table_new_from_locale(xd->xkb, locale,
1360 XKB_COMPOSE_COMPILE_NO_FLAGS);
1361 if (xd->compose_table)
1363 xkb_compose_state_new(xd->compose_table,
1364 XKB_COMPOSE_STATE_NO_FLAGS);
1368 static void kbd_free(struct xcb_data *xd safe)
1370 if (xd->compose_table)
1371 xkb_compose_table_unref(xd->compose_table);
1373 xkb_keymap_unref(xd->xkb_keymap);
1375 xkb_context_unref(xd->xkb);
1379 char *from safe, *to safe;
1381 { "Return", ":Enter"},
1383 { "ISO_Left_Tab",":Tab"},
1384 { "Escape", ":ESC"},
1385 { "Linefeed", ":LF"},
1389 { "Right", ":Right"},
1392 { "BackSpace", ":Backspace"},
1393 { "Delete", ":Del"},
1394 { "Insert", ":Ins"},
1395 { "Next", ":Prior"},
1396 { "Prior", ":Next"},
1411 static void handle_key_press(struct pane *home safe,
1412 xcb_key_press_event_t *kpe safe)
1414 struct xcb_data *xd = home->data;
1415 xkb_keycode_t keycode = kpe->detail;
1416 xcb_keysym_t keysym;
1418 const xkb_keysym_t *syms;
1420 enum xkb_compose_status status;
1421 xkb_mod_index_t mod;
1425 bool shift=False, ctrl=False, alt=False;
1427 xd->last_event = time(NULL);
1429 keysym = xkb_state_key_get_one_sym(xd->xkb_state,
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,
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)
1444 for (mod = 0; mod < xkb_keymap_num_mods(xd->xkb_keymap); mod++) {
1446 if (xkb_state_mod_index_is_active(
1448 XKB_STATE_MODS_EFFECTIVE) <= 0)
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))
1456 n = xkb_keymap_mod_get_name(xd->xkb_keymap, mod);
1457 if (n && strcmp(n, "Shift") == 0)
1459 if (n && strcmp(n, "Control") == 0)
1461 if (n && strcmp(n, "Mod1") == 0)
1465 if (status == XKB_COMPOSE_COMPOSED) {
1466 sym = xkb_compose_state_get_one_sym(xd->compose_state);
1470 xkb_compose_state_get_utf8(xd->compose_state,
1475 /* Mod1 can still apply to a composed char */
1476 } else if (nsyms == 1) {
1478 sym = xkb_state_key_get_one_sym(xd->xkb_state, keycode);
1481 xkb_state_key_get_utf8(xd->xkb_state, keycode,
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);
1490 if (s[0] == '-' && s[1] >= ' ' && s[1] < 0x7f)
1491 /* Shift is included */
1493 if (s[0] == '-' && s[1] && (unsigned char)(s[1]) < ' ') {
1496 if (s[1] < 'A' || s[1] > 'Z')
1498 } else if (s[0] == '-' && !s[1] && strcmp(key, "space") == 0) {
1499 /* 'nul' becomes "C- " (ctrl-space) */
1506 if (xd->compose_state &&
1507 (status == XKB_COMPOSE_CANCELLED ||
1508 status == XKB_COMPOSE_COMPOSED))
1509 xkb_compose_state_reset(xd->compose_state);
1520 call("Keystroke", home, 0, NULL, mods);
1524 static void handle_xkb_event(struct pane *home safe,
1525 xcb_generic_event_t *ev safe)
1527 struct xcb_data *xd = home->data;
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:
1535 if (nkne->deviceID == xd->xkb_device_id &&
1536 nkne->changed & XCB_XKB_NKN_DETAIL_KEYCODES)
1539 case XCB_XKB_MAP_NOTIFY:
1541 if (mne->deviceID == xd->xkb_device_id)
1544 case XCB_XKB_STATE_NOTIFY:
1546 if (sne->deviceID == xd->xkb_device_id)
1547 xkb_state_update_mask(xd->xkb_state,
1558 static void handle_configure(struct pane *home safe,
1559 xcb_configure_notify_event_t *cne safe)
1561 struct xcb_data *xd = home->data;
1563 pane_resize(home, 0, 0, cne->width, cne->height);
1564 cairo_xcb_surface_set_size(xd->surface, cne->width, cne->height);
1567 static void handle_expose(struct pane *home safe,
1568 xcb_expose_event_t *ee safe)
1570 struct xcb_data *xd = home->data;
1571 cairo_rectangle_int_t r = {
1575 .height = ee->height,
1578 if (!xd->need_update)
1579 xd->need_update = cairo_region_create();
1580 cairo_region_union_rectangle(xd->need_update, &r);
1582 pane_damaged(home, DAMAGED_POSTORDER);
1585 static void handle_client_message(struct pane *home safe,
1586 xcb_client_message_event_t *cme safe)
1588 struct xcb_data *xd = home->data;
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));
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,
1609 LOG("x11 %s got unexpected client message type=%d/%d win=%x data=%d",
1611 cme->type, cme->format, cme->window, cme->data.data32[0]);
1617 struct xcb_data *xd = ci->home->data;
1618 xcb_generic_event_t *ev;
1623 /* This is a poll - only return 1 on something happening */
1626 while ((ev = xcb_poll_for_event(xd->conn)) != NULL) {
1628 switch (ev->response_type & 0x7f) {
1630 time_start(TIME_KEY);
1631 handle_key_press(ci->home, safe_cast (void*)ev);
1632 time_stop(TIME_KEY);
1634 case XCB_KEY_RELEASE:
1635 /* Ignore for now */
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);
1643 case XCB_MOTION_NOTIFY:
1644 time_start(TIME_KEY);
1645 handle_motion(ci->home, (void*)ev);
1646 time_stop(TIME_KEY);
1650 time_start(TIME_WINDOW);
1651 handle_focus(ci->home, (void*)ev);
1652 time_stop(TIME_WINDOW);
1655 time_start(TIME_WINDOW);
1656 handle_expose(ci->home, (void*)ev);
1657 time_stop(TIME_WINDOW);
1659 case XCB_CONFIGURE_NOTIFY:
1660 time_start(TIME_WINDOW);
1661 handle_configure(ci->home, (void*)ev);
1662 time_stop(TIME_WINDOW);
1664 case XCB_CLIENT_MESSAGE:
1665 time_start(TIME_WINDOW);
1666 handle_client_message(ci->home, (void*)ev);
1667 time_stop(TIME_WINDOW);
1669 case XCB_REPARENT_NOTIFY:
1670 /* Not interested */
1672 case XCB_MAP_NOTIFY:
1673 case XCB_UNMAP_NOTIFY:
1674 case XCB_MAPPING_NOTIFY:
1675 /* FIXME what to do?? */
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
1684 if ((ev->response_type & 0x7f) ==
1685 xd->first_xkb_event) {
1686 handle_xkb_event(ci->home, ev);
1689 LOG("Ignored X11 event %d", ev->response_type);
1691 xcb_flush(xd->conn);
1693 if (xcb_connection_has_error(xd->conn)) {
1694 call("window:close", ci->home->parent);
1695 pane_close(ci->home);
1700 static void set_str_prop(struct xcb_data *xd safe,
1701 enum my_atoms a, const char *str safe)
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);
1709 static void set_utf8_prop(struct xcb_data *xd safe,
1710 enum my_atoms a, const char *str safe)
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);
1719 static void set_card32_property(struct xcb_data *xd safe,
1721 const uint32_t *data, int cnt)
1723 xcb_change_property(xd->conn,
1724 XCB_PROP_MODE_REPLACE,
1725 xd->win, xd->atoms[a],
1726 XCB_ATOM_CARDINAL, 32,
1730 static void set_atom_prop(struct xcb_data *xd safe,
1731 enum my_atoms prop, enum my_atoms alist, ...)
1738 atoms[anum++] = xd->atoms[alist];
1739 va_start(ap, alist);
1740 while ((a = va_arg(ap, enum my_atoms)) != a_NONE)
1742 atoms[anum++] = xd->atoms[a];
1744 xcb_change_property(xd->conn,
1745 XCB_PROP_MODE_REPLACE,
1746 xd->win, xd->atoms[prop],
1751 static void xcb_load_icon(struct pane *p safe,
1752 struct xcb_data *xd safe,
1758 MagickBooleanType status;
1762 path = call_ret(str, "xdg-find-edlib-file", p, 0, NULL,
1763 file, 0, NULL, "data");
1767 wd = NewMagickWand();
1768 status = MagickReadImage(wd, path);
1770 if (status == MagickFalse)
1773 h = MagickGetImageHeight(wd);
1774 w = MagickGetImageWidth(wd);
1776 data = malloc(sizeof(data[0]) * n);
1781 /* Need host-endian ARGB data */
1782 fmt[0] = ('A'<<24) | ('R' << 16) | ('G' << 8) | ('B' << 0);
1784 MagickExportImagePixels(wd, 0, 0, w, h, (char*)fmt,
1786 set_card32_property(xd, a_NET_WM_ICON, data, n);
1789 DestroyMagickWand(wd);
1793 static struct pane *xcb_display_init(const char *d safe,
1794 const char *disp_auth,
1795 struct pane *focus safe)
1797 struct xcb_data *xd;
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;
1808 PangoLayout *layout;
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
1816 conn = safe_cast xcb_connect_auth(d, disp_auth, &screen);
1817 if (xcb_connection_has_error(conn))
1820 p = pane_register(pane_root(focus), 1, &xcb_handle.c);
1825 xd->motion_blocked = True;
1826 xd->in_focus = True;
1829 xd->display = strdup(d);
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;
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);
1844 for (i = 0; i < NR_ATOMS; i++) {
1845 const char *n = atom_names[i];
1848 cookies[i] = xcb_intern_atom(conn, 0, strlen(n), n);
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 |
1866 xcb_create_window(conn, XCB_COPY_FROM_PARENT, xd->win,
1870 0, XCB_WINDOW_CLASS_INPUT_OUTPUT,
1871 xd->screen->root_visual,
1872 XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK,
1877 surface = cairo_xcb_surface_create(
1878 conn, xd->win, xd->visual, 100, 100);
1881 xd->surface = surface;
1882 cairo = safe_cast cairo_create(xd->surface);
1883 if (cairo_status(cairo) != CAIRO_STATUS_SUCCESS)
1886 fd = pango_font_description_new();
1890 pango_font_description_set_family(xd->fd, "monospace");
1891 pango_font_description_set_size(xd->fd, 12 * PANGO_SCALE);
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;
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,
1906 cairo_xcb_surface_set_size(xd->surface, valwin[0], valwin[1]);
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);
1914 xd->atoms[i] = r->atom;
1920 * WM_PROTOCOLS _NET_WM_SYN_REQUEST??
1921 * WM_NORMAL_HINTS WM_HINTS
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);
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 |
1942 XCB_MOD_MASK_CONTROL);
1944 xcb_load_icon(focus, xd, "{COMM}-icon.png");
1945 xcb_map_window(conn, xd->win);
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);
1960 cairo_destroy(xd->cairo);
1961 cairo_surface_destroy(xd->surface);
1962 xcb_disconnect(conn);
1964 free(xd->disp_auth);
1968 DEF_CMD(xcb_new_display)
1971 const char *d = ci->str;
1972 const char *disp_auth = ci->str2;
1975 d = pane_attr_get(ci->focus, "DISPLAY");
1977 disp_auth = pane_attr_get(ci->focus, "XAUTHORITY");
1979 disp_auth = getenv("XAUTHORITY");
1983 p = xcb_display_init(d, disp_auth, ci->focus);
1985 home_call_ret(pane, ci->focus, "doc:attach-view", p, 1);
1987 comm_call(ci->comm2, "cb", p);
1991 void edlib_init(struct pane *ed safe)
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");
1998 xcb_map = key_alloc();
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);
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);