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 * 'str2' container 'mode' information.
814 * By default the image is placed centrally in the pane
815 * and scaled to use either fully height or fully width.
816 * Various letters modify this:
817 * 'S' - stretch to use full height *and* full width
818 * 'L' - place on left if full width isn't used
819 * 'R' - place on right if full width isn't used
820 * 'T' - place at top if full height isn't used
821 * 'B' - place at bottom if full height isn't used.
823 * If 'x' and 'y' are both positive, draw cursor box at
824 * p->cx, p->cy of a size so that 'x' will fit across and
827 struct xcb_data *xd = ci->home->data;
828 const char *mode = ci->str2 ?: "";
829 bool stretch = strchr(mode, 'S');
830 int w = ci->focus->w, h = ci->focus->h;
835 MagickBooleanType status;
839 cairo_surface_t *surface;
843 ps = find_pixmap(xd, ci->focus, &xo, &yo);
847 instantiate_pixmap(xd, ps);
851 if (strstarts(ci->str, "file:")) {
852 wd = NewMagickWand();
853 status = MagickReadImage(wd, ci->str + 5);
854 if (status == MagickFalse) {
855 DestroyMagickWand(wd);
858 } else if (strstarts(ci->str, "comm:")) {
859 struct call_return cr;
860 wd = NewMagickWand();
861 cr = call_ret(bytes, ci->str+5, ci->focus);
863 DestroyMagickWand(wd);
866 status = MagickReadImageBlob(wd, cr.s, cr.i);
868 if (status == MagickFalse) {
869 DestroyMagickWand(wd);
875 MagickAutoOrientImage(wd);
877 int ih = MagickGetImageHeight(wd);
878 int iw = MagickGetImageWidth(wd);
880 if (iw <= 0 || iw <= 0) {
881 DestroyMagickWand(wd);
884 if (iw * h > ih * w) {
885 /* Image is wider than space, use less height */
887 if (strchr(mode, 'B'))
890 else if (!strchr(mode, 'T'))
895 /* image is too tall, use less width */
897 if (strchr(mode, 'R'))
900 else if (!strchr(mode, 'L'))
905 MagickAdaptiveResizeImage(wd, w, h);
906 stride = cairo_format_stride_for_width(CAIRO_FORMAT_RGB24, w);
907 buf = malloc(h * stride);
908 // Cairo expects 32bit values with A in the high byte, then RGB.
909 // Magick provides 8bit values in the order requests.
910 // So depending on byte order, a different string is needed
912 fmt[0] = ('A'<<24) | ('R' << 16) | ('G' << 8) | ('B' << 0);
914 MagickExportImagePixels(wd, 0, 0, w, h, (char*)fmt, CharPixel, buf);
915 surface = cairo_image_surface_create_for_data(buf, CAIRO_FORMAT_ARGB32,
917 cairo_set_source_surface(ps->ctx, surface, x + xo, y + yo);
918 cairo_paint(ps->ctx);
919 cairo_surface_destroy(surface);
922 if (ci->x > 0 && ci->y > 0 && ci->focus->cx >= 0) {
923 struct pane *p = ci->focus;
924 cairo_rectangle(ps->ctx, p->cx + xo, p->cy + yo,
926 cairo_set_line_width(ps->ctx, 1.0);
927 cairo_set_source_rgb(ps->ctx, 1.0, 0.0, 0.0);
928 cairo_stroke(ps->ctx);
930 DestroyMagickWand(wd);
932 pane_damaged(ci->home, DAMAGED_POSTORDER);
937 DEF_CMD(xcb_image_size)
939 MagickBooleanType status;
945 if (strstarts(ci->str, "file:")) {
946 wd = NewMagickWand();
947 status = MagickReadImage(wd, ci->str + 5);
948 if (status == MagickFalse) {
949 DestroyMagickWand(wd);
952 } else if (strstarts(ci->str, "comm:")) {
953 struct call_return cr;
954 wd = NewMagickWand();
955 cr = call_ret(bytes, ci->str+5, ci->focus);
957 DestroyMagickWand(wd);
960 status = MagickReadImageBlob(wd, cr.s, cr.i);
962 if (status == MagickFalse) {
963 DestroyMagickWand(wd);
969 MagickAutoOrientImage(wd);
970 ih = MagickGetImageHeight(wd);
971 iw = MagickGetImageWidth(wd);
973 DestroyMagickWand(wd);
974 comm_call(ci->comm2, "callback:size", ci->focus,
975 0, NULL, NULL, 0, NULL, NULL,
980 static struct panes *sort_split(struct panes *p)
982 /* consider 'p' to be a list of panes with
983 * ordered subsets (ordered by p->abs_z).
984 * Remove every other such subset and return them
986 * If p is ordered, this means we return NULL.
988 struct panes *ret, **end = &ret;
991 for (; p && p->next; p = next) {
992 /* If these are not ordered, attach p->next at
993 * 'end', and make 'end' point to &p->next.
996 if (p->p->abs_z < next->p->abs_z) {
1005 static struct panes *sort_merge(struct panes *p1, struct panes *p2)
1007 /* merge p1 and p2 and return result */
1008 struct panes *ret, **end = &ret;
1009 struct panes *prev = NULL;
1012 /* Make p1 the largest (or be added first.
1013 * Then in prev is between them add p2, else p1
1015 if (p1->p->abs_z < p2->p->abs_z) {
1016 struct panes *t = p1;
1021 p1->p->abs_z > prev->p->abs_z &&
1022 prev->p->abs_z >= p2->p->abs_z) {
1023 /* p2 is the better choice */
1040 DEF_CMD(xcb_refresh_post)
1042 struct xcb_data *xd = ci->home->data;
1045 time_start(TIME_WINDOW);
1046 /* First: ensure panes are sorted */
1047 while ((ps = sort_split(xd->panes)) != NULL)
1048 xd->panes = sort_merge(xd->panes, ps);
1050 /* Then merge all update rectanges, checking for movement */
1051 if (!xd->need_update)
1052 xd->need_update = cairo_region_create();
1053 for (ps = xd->panes; ps ; ps = ps->next)
1057 rel = pane_mapxy(ps->p, ci->home, 0, 0, False);
1058 if (ps->r.x == NEVER_DRAWN) {
1061 cairo_region_union_rectangle(xd->need_update, &ps->r);
1062 } else if (rel.x != ps->r.x || rel.y != ps->r.y) {
1063 /* Moved, so refresh all.
1064 * This rectangle might be too big if it is clipped,
1065 * but that doesn't really matter.
1067 cairo_region_union_rectangle(xd->need_update, &ps->r);
1070 cairo_region_union_rectangle(xd->need_update, &ps->r);
1071 } else if (ps->need_update) {
1072 cairo_region_translate(ps->need_update, rel.x, rel.y);
1073 cairo_region_union(xd->need_update, ps->need_update);
1075 if (ps->need_update)
1076 cairo_region_destroy(ps->need_update);
1077 ps->need_update = NULL;
1079 /* Now copy all panes onto the window where an update is needed */
1080 for (ps = xd->panes; ps ; ps = ps->next) {
1081 struct xy rel, lo, hi;
1083 cairo_rectangle_int_t r;
1086 cr = cairo_region_copy(xd->need_update);
1088 rel = pane_mapxy(ps->p, ci->home, 0, 0, False);
1090 cairo_save(xd->cairo);
1092 cairo_set_source_rgb(xd->cairo,
1093 ps->bg.r, ps->bg.g, ps->bg.b);
1095 cairo_set_source_surface(xd->cairo, ps->surface,
1098 lo = pane_mapxy(ps->p, ci->home, 0, 0, True);
1099 hi = pane_mapxy(ps->p, ci->home, ps->r.width, ps->r.height, True);
1100 r.x = lo.x; r.y = lo.y;
1101 r.width = hi.x - lo.x; r.height = hi.y - lo.y;
1102 cairo_region_intersect_rectangle(cr, &r);
1103 cairo_region_subtract_rectangle(xd->need_update, &r);
1104 nr = cairo_region_num_rectangles(cr);
1105 for (i = 0; i < nr; i++) {
1106 cairo_region_get_rectangle(cr, i, &r);
1107 cairo_rectangle(xd->cairo, r.x, r.y, r.width, r.height);
1108 cairo_fill(xd->cairo);
1110 cairo_restore(xd->cairo);
1113 cairo_region_destroy(xd->need_update);
1114 xd->need_update = NULL;
1115 time_stop(TIME_WINDOW);
1116 xcb_flush(xd->conn);
1120 DEF_CMD(xcb_refresh_size)
1122 /* FIXME: should I consider resizing the window?
1123 * For now, just ensure we redraw everything.
1125 struct xcb_data *xd = ci->home->data;
1126 cairo_rectangle_int_t r = {
1129 .width = ci->home->w,
1130 .height = ci->home->h,
1133 if (!xd->need_update)
1134 xd->need_update = cairo_region_create();
1135 cairo_region_union_rectangle(xd->need_update, &r);
1136 /* Ask common code to notify children */
1137 return Efallthrough;
1140 DEF_CMD(xcb_pane_close)
1142 struct xcb_data *xd = ci->home->data;
1143 struct panes **pp, *ps;
1145 for (pp = &xd->panes; (ps = *pp) != NULL; pp = &(*pp)->next) {
1146 if (ps->p != ci->focus)
1149 if (!xd->need_update)
1150 xd->need_update = cairo_region_create();
1151 if (ps->r.x != NEVER_DRAWN)
1152 cairo_region_union_rectangle(xd->need_update, &ps->r);
1156 if (ps->need_update)
1157 cairo_region_destroy(ps->need_update);
1158 cairo_destroy(ps->ctx);
1159 cairo_surface_destroy(ps->surface);
1160 xcb_free_pixmap(xd->conn, ps->draw);
1162 pane_damaged(ci->home, DAMAGED_POSTORDER);
1168 DEF_CMD(xcb_notify_display)
1170 struct xcb_data *xd = ci->home->data;
1171 comm_call(ci->comm2, "callback:display", ci->home, xd->last_event);
1175 static void handle_button(struct pane *home safe,
1176 xcb_button_press_event_t *be safe)
1178 struct xcb_data *xd = home->data;
1179 bool press = (be->response_type & 0x7f) == XCB_BUTTON_PRESS;
1181 char key[2+2+2+9+1+1];
1183 xcb_set_input_focus(xd->conn, XCB_INPUT_FOCUS_POINTER_ROOT,
1184 xd->win, XCB_CURRENT_TIME);
1187 xd->motion_blocked = False;
1188 if (be->state & XCB_KEY_BUT_MASK_MOD_1)
1190 if (be->state & XCB_KEY_BUT_MASK_CONTROL)
1192 if (be->state & XCB_KEY_BUT_MASK_SHIFT)
1195 strcat(key, ":Press-X");
1196 } else if (be->detail >= 4)
1197 /* ignore 'release' for scroll wheel */
1200 strcpy(key, ":Release-X");
1202 key[strlen(key) - 1] = '0' + be->detail;
1203 xd->last_event = time(NULL);
1204 call("Mouse-event", home, be->detail, NULL, key,
1205 press?1:2, NULL, mod,
1206 be->event_x, be->event_y);
1209 static void handle_motion(struct pane *home safe,
1210 xcb_motion_notify_event_t *mne safe)
1212 struct xcb_data *xd = home->data;
1213 xcb_query_pointer_cookie_t c;
1214 xcb_query_pointer_reply_t *qpr;
1216 int x = mne->event_x, y = mne->event_y;
1218 if (xd->motion_blocked)
1220 ret = call("Mouse-event", home, 0, NULL, ":Motion",
1221 3, NULL, NULL, x, y);
1223 xd->motion_blocked = True;
1225 /* This doesn't seem to be needed, but the spec says
1226 * I should do this when using POINTER_MOTION_HINT
1228 c = xcb_query_pointer(xd->conn, xd->win);
1229 qpr = xcb_query_pointer_reply(xd->conn, c, NULL);
1233 static void handle_focus(struct pane *home safe, xcb_focus_in_event_t *fie safe)
1235 struct xcb_data *xd = home->data;
1236 bool in = (fie->response_type & 0x7f) == XCB_FOCUS_IN;
1241 p = pane_focus(home);
1242 pt = call_ret(mark, "doc:point", p);
1244 call("view:changed", p, 0, pt);
1246 call("pane:refocus", home);
1249 static bool select_xkb_events_for_device(xcb_connection_t *conn,
1252 xcb_generic_error_t *error;
1253 xcb_void_cookie_t cookie;
1257 (XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY |
1258 XCB_XKB_EVENT_TYPE_MAP_NOTIFY |
1259 XCB_XKB_EVENT_TYPE_STATE_NOTIFY),
1261 required_nkn_details =
1262 (XCB_XKB_NKN_DETAIL_KEYCODES),
1264 required_map_parts =
1265 (XCB_XKB_MAP_PART_KEY_TYPES |
1266 XCB_XKB_MAP_PART_KEY_SYMS |
1267 XCB_XKB_MAP_PART_MODIFIER_MAP |
1268 XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS |
1269 XCB_XKB_MAP_PART_KEY_ACTIONS |
1270 XCB_XKB_MAP_PART_VIRTUAL_MODS |
1271 XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP),
1273 required_state_details =
1274 (XCB_XKB_STATE_PART_MODIFIER_BASE |
1275 XCB_XKB_STATE_PART_MODIFIER_LATCH |
1276 XCB_XKB_STATE_PART_MODIFIER_LOCK |
1277 XCB_XKB_STATE_PART_GROUP_BASE |
1278 XCB_XKB_STATE_PART_GROUP_LATCH |
1279 XCB_XKB_STATE_PART_GROUP_LOCK),
1282 static const xcb_xkb_select_events_details_t details = {
1283 .affectNewKeyboard = required_nkn_details,
1284 .newKeyboardDetails = required_nkn_details,
1285 .affectState = required_state_details,
1286 .stateDetails = required_state_details,
1289 cookie = xcb_xkb_select_events_aux_checked(
1292 required_events, /* affectWhich */
1295 required_map_parts, /* affectMap */
1296 required_map_parts, /* map */
1297 &details); /* details */
1299 error = xcb_request_check(conn, cookie);
1308 static bool update_keymap(struct xcb_data *xd safe)
1310 struct xkb_keymap *new_keymap;
1311 struct xkb_state *new_state;
1313 new_keymap = xkb_x11_keymap_new_from_device(xd->xkb, xd->conn,
1315 XKB_KEYMAP_COMPILE_NO_FLAGS);
1319 new_state = xkb_x11_state_new_from_device(new_keymap, xd->conn,
1322 xkb_keymap_unref(new_keymap);
1326 xkb_state_unref(xd->xkb_state);
1327 xkb_keymap_unref(xd->xkb_keymap);
1328 xd->xkb_keymap = new_keymap;
1329 xd->xkb_state = new_state;
1333 static bool kbd_setup(struct xcb_data *xd safe)
1338 ret = xkb_x11_setup_xkb_extension(xd->conn,
1339 XKB_X11_MIN_MAJOR_XKB_VERSION,
1340 XKB_X11_MIN_MINOR_XKB_VERSION,
1341 XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS,
1342 NULL, NULL, &xd->first_xkb_event,
1347 xd->xkb = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
1350 xd->xkb_device_id = xkb_x11_get_core_keyboard_device_id(xd->conn);
1351 if (xd->xkb_device_id == -1)
1354 if (!update_keymap(xd))
1357 if (!select_xkb_events_for_device(xd->conn, xd->xkb_device_id))
1360 locale = setlocale(LC_CTYPE, NULL);
1362 xkb_compose_table_new_from_locale(xd->xkb, locale,
1363 XKB_COMPOSE_COMPILE_NO_FLAGS);
1364 if (xd->compose_table)
1366 xkb_compose_state_new(xd->compose_table,
1367 XKB_COMPOSE_STATE_NO_FLAGS);
1371 static void kbd_free(struct xcb_data *xd safe)
1373 if (xd->compose_table)
1374 xkb_compose_table_unref(xd->compose_table);
1376 xkb_keymap_unref(xd->xkb_keymap);
1378 xkb_context_unref(xd->xkb);
1382 char *from safe, *to safe;
1384 { "Return", ":Enter"},
1386 { "ISO_Left_Tab",":Tab"},
1387 { "Escape", ":ESC"},
1388 { "Linefeed", ":LF"},
1392 { "Right", ":Right"},
1395 { "BackSpace", ":Backspace"},
1396 { "Delete", ":Del"},
1397 { "Insert", ":Ins"},
1398 { "Next", ":Prior"},
1399 { "Prior", ":Next"},
1414 static void handle_key_press(struct pane *home safe,
1415 xcb_key_press_event_t *kpe safe)
1417 struct xcb_data *xd = home->data;
1418 xkb_keycode_t keycode = kpe->detail;
1419 xcb_keysym_t keysym;
1421 const xkb_keysym_t *syms;
1423 enum xkb_compose_status status;
1424 xkb_mod_index_t mod;
1428 bool shift=False, ctrl=False, alt=False;
1430 xd->last_event = time(NULL);
1432 keysym = xkb_state_key_get_one_sym(xd->xkb_state,
1434 if (xd->compose_state)
1435 xkb_compose_state_feed(xd->compose_state, keysym);
1436 nsyms = xkb_state_key_get_syms(xd->xkb_state, keycode,
1440 status = XKB_COMPOSE_NOTHING;
1441 if (xd->compose_state)
1442 status = xkb_compose_state_get_status(xd->compose_state);
1443 if (status == XKB_COMPOSE_COMPOSING ||
1444 status == XKB_COMPOSE_CANCELLED)
1447 for (mod = 0; mod < xkb_keymap_num_mods(xd->xkb_keymap); mod++) {
1449 if (xkb_state_mod_index_is_active(
1451 XKB_STATE_MODS_EFFECTIVE) <= 0)
1453 /* This does tells me "shift" is consumed for :C:S-l ...
1454 if (xkb_state_mod_index_is_consumed2(
1455 xd->xkb_state, keycode, mod,
1456 XKB_CONSUMED_MODE_XKB))
1459 n = xkb_keymap_mod_get_name(xd->xkb_keymap, mod);
1460 if (n && strcmp(n, "Shift") == 0)
1462 if (n && strcmp(n, "Control") == 0)
1464 if (n && strcmp(n, "Mod1") == 0)
1468 if (status == XKB_COMPOSE_COMPOSED) {
1469 sym = xkb_compose_state_get_one_sym(xd->compose_state);
1473 xkb_compose_state_get_utf8(xd->compose_state,
1478 /* Mod1 can still apply to a composed char */
1479 } else if (nsyms == 1) {
1481 sym = xkb_state_key_get_one_sym(xd->xkb_state, keycode);
1484 xkb_state_key_get_utf8(xd->xkb_state, keycode,
1486 xkb_keysym_get_name(syms[0], key, sizeof(key));
1487 for (i = 0; i < ARRAY_SIZE(key_map); i++) {
1488 if (strcmp(key, key_map[i].from) == 0) {
1489 strcpy(s, key_map[i].to);
1493 if (s[0] == '-' && s[1] >= ' ' && s[1] < 0x7f)
1494 /* Shift is included */
1496 if (s[0] == '-' && s[1] && (unsigned char)(s[1]) < ' ') {
1499 if (s[1] < 'A' || s[1] > 'Z')
1501 } else if (s[0] == '-' && !s[1] && strcmp(key, "space") == 0) {
1502 /* 'nul' becomes "C- " (ctrl-space) */
1509 if (xd->compose_state &&
1510 (status == XKB_COMPOSE_CANCELLED ||
1511 status == XKB_COMPOSE_COMPOSED))
1512 xkb_compose_state_reset(xd->compose_state);
1523 call("Keystroke", home, 0, NULL, mods);
1527 static void handle_xkb_event(struct pane *home safe,
1528 xcb_generic_event_t *ev safe)
1530 struct xcb_data *xd = home->data;
1533 xcb_xkb_new_keyboard_notify_event_t *nkne;
1534 xcb_xkb_state_notify_event_t *sne;
1535 xcb_xkb_map_notify_event_t *mne;
1536 case XCB_XKB_NEW_KEYBOARD_NOTIFY:
1538 if (nkne->deviceID == xd->xkb_device_id &&
1539 nkne->changed & XCB_XKB_NKN_DETAIL_KEYCODES)
1542 case XCB_XKB_MAP_NOTIFY:
1544 if (mne->deviceID == xd->xkb_device_id)
1547 case XCB_XKB_STATE_NOTIFY:
1549 if (sne->deviceID == xd->xkb_device_id)
1550 xkb_state_update_mask(xd->xkb_state,
1561 static void handle_configure(struct pane *home safe,
1562 xcb_configure_notify_event_t *cne safe)
1564 struct xcb_data *xd = home->data;
1566 pane_resize(home, 0, 0, cne->width, cne->height);
1567 cairo_xcb_surface_set_size(xd->surface, cne->width, cne->height);
1570 static void handle_expose(struct pane *home safe,
1571 xcb_expose_event_t *ee safe)
1573 struct xcb_data *xd = home->data;
1574 cairo_rectangle_int_t r = {
1578 .height = ee->height,
1581 if (!xd->need_update)
1582 xd->need_update = cairo_region_create();
1583 cairo_region_union_rectangle(xd->need_update, &r);
1585 pane_damaged(home, DAMAGED_POSTORDER);
1588 static void handle_client_message(struct pane *home safe,
1589 xcb_client_message_event_t *cme safe)
1591 struct xcb_data *xd = home->data;
1593 if (cme->type == xd->atoms[a_WM_PROTOCOLS] &&
1594 cme->format == 32 &&
1595 cme->window == xd->win &&
1596 cme->data.data32[0] == xd->atoms[a_WM_DELETE_WINDOW]) {
1597 call("window:close", pane_focus(home));
1601 if (cme->type == xd->atoms[a_WM_PROTOCOLS] &&
1602 cme->format == 32 &&
1603 cme->window == xd->win &&
1604 cme->data.data32[0] == xd->atoms[a_NET_WM_PING]) {
1605 cme->window = xd->screen->root;
1606 xcb_send_event(xd->conn, 0, xd->screen->root,
1607 XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
1608 XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
1612 LOG("x11 %s got unexpected client message type=%d/%d win=%x data=%d",
1614 cme->type, cme->format, cme->window, cme->data.data32[0]);
1620 struct xcb_data *xd = ci->home->data;
1621 xcb_generic_event_t *ev;
1626 /* This is a poll - only return 1 on something happening */
1629 while ((ev = xcb_poll_for_event(xd->conn)) != NULL) {
1631 switch (ev->response_type & 0x7f) {
1633 time_start(TIME_KEY);
1634 handle_key_press(ci->home, safe_cast (void*)ev);
1635 time_stop(TIME_KEY);
1637 case XCB_KEY_RELEASE:
1638 /* Ignore for now */
1640 case XCB_BUTTON_PRESS:
1641 case XCB_BUTTON_RELEASE:
1642 time_start(TIME_KEY);
1643 handle_button(ci->home, (void*)ev);
1644 time_stop(TIME_KEY);
1646 case XCB_MOTION_NOTIFY:
1647 time_start(TIME_KEY);
1648 handle_motion(ci->home, (void*)ev);
1649 time_stop(TIME_KEY);
1653 time_start(TIME_WINDOW);
1654 handle_focus(ci->home, (void*)ev);
1655 time_stop(TIME_WINDOW);
1658 time_start(TIME_WINDOW);
1659 handle_expose(ci->home, (void*)ev);
1660 time_stop(TIME_WINDOW);
1662 case XCB_CONFIGURE_NOTIFY:
1663 time_start(TIME_WINDOW);
1664 handle_configure(ci->home, (void*)ev);
1665 time_stop(TIME_WINDOW);
1667 case XCB_CLIENT_MESSAGE:
1668 time_start(TIME_WINDOW);
1669 handle_client_message(ci->home, (void*)ev);
1670 time_stop(TIME_WINDOW);
1672 case XCB_REPARENT_NOTIFY:
1673 /* Not interested */
1675 case XCB_MAP_NOTIFY:
1676 case XCB_UNMAP_NOTIFY:
1677 case XCB_MAPPING_NOTIFY:
1678 /* FIXME what to do?? */
1681 /* Don't know what this means, but I get a lot
1682 * of them so I don't want to log that it was
1687 if ((ev->response_type & 0x7f) ==
1688 xd->first_xkb_event) {
1689 handle_xkb_event(ci->home, ev);
1692 LOG("Ignored X11 event %d", ev->response_type);
1694 xcb_flush(xd->conn);
1696 if (xcb_connection_has_error(xd->conn)) {
1697 call("window:close", ci->home->parent);
1698 pane_close(ci->home);
1703 static void set_str_prop(struct xcb_data *xd safe,
1704 enum my_atoms a, const char *str safe)
1706 xcb_change_property(xd->conn,
1707 XCB_PROP_MODE_REPLACE,
1708 xd->win, xd->atoms[a], XCB_ATOM_STRING,
1709 8, strlen(str), str);
1712 static void set_utf8_prop(struct xcb_data *xd safe,
1713 enum my_atoms a, const char *str safe)
1715 xcb_change_property(xd->conn,
1716 XCB_PROP_MODE_REPLACE,
1717 xd->win, xd->atoms[a],
1718 xd->atoms[a_UTF8_STRING],
1719 8, strlen(str), str);
1722 static void set_card32_property(struct xcb_data *xd safe,
1724 const uint32_t *data, int cnt)
1726 xcb_change_property(xd->conn,
1727 XCB_PROP_MODE_REPLACE,
1728 xd->win, xd->atoms[a],
1729 XCB_ATOM_CARDINAL, 32,
1733 static void set_atom_prop(struct xcb_data *xd safe,
1734 enum my_atoms prop, enum my_atoms alist, ...)
1741 atoms[anum++] = xd->atoms[alist];
1742 va_start(ap, alist);
1743 while ((a = va_arg(ap, enum my_atoms)) != a_NONE)
1745 atoms[anum++] = xd->atoms[a];
1747 xcb_change_property(xd->conn,
1748 XCB_PROP_MODE_REPLACE,
1749 xd->win, xd->atoms[prop],
1754 static void xcb_load_icon(struct pane *p safe,
1755 struct xcb_data *xd safe,
1761 MagickBooleanType status;
1765 path = call_ret(str, "xdg-find-edlib-file", p, 0, NULL,
1766 file, 0, NULL, "data");
1770 wd = NewMagickWand();
1771 status = MagickReadImage(wd, path);
1773 if (status == MagickFalse)
1776 h = MagickGetImageHeight(wd);
1777 w = MagickGetImageWidth(wd);
1779 data = malloc(sizeof(data[0]) * n);
1784 /* Need host-endian ARGB data */
1785 fmt[0] = ('A'<<24) | ('R' << 16) | ('G' << 8) | ('B' << 0);
1787 MagickExportImagePixels(wd, 0, 0, w, h, (char*)fmt,
1789 set_card32_property(xd, a_NET_WM_ICON, data, n);
1792 DestroyMagickWand(wd);
1796 static struct pane *xcb_display_init(const char *d safe,
1797 const char *disp_auth,
1798 struct pane *focus safe)
1800 struct xcb_data *xd;
1802 xcb_connection_t *conn;
1803 xcb_intern_atom_cookie_t cookies[NR_ATOMS];
1804 xcb_screen_iterator_t iter;
1805 xcb_depth_iterator_t di;
1811 PangoLayout *layout;
1814 cairo_surface_t *surface;
1815 PangoFontDescription *fd;
1816 // FIXME SCALE from environ?? or pango_cairo_context_set_resolution dpi
1817 // 254 * width_in_pixels / width_in_millimeters / 10
1819 conn = safe_cast xcb_connect_auth(d, disp_auth, &screen);
1820 if (xcb_connection_has_error(conn))
1823 p = pane_register(pane_root(focus), 1, &xcb_handle.c);
1828 xd->motion_blocked = True;
1829 xd->in_focus = True;
1832 xd->display = strdup(d);
1834 xd->disp_auth = strdup(disp_auth);
1835 xd->setup = safe_cast xcb_get_setup(conn);
1836 iter = xcb_setup_roots_iterator(xd->setup);
1837 for (i = 0; i < screen; i++)
1838 xcb_screen_next(&iter);
1839 xd->screen = safe_cast iter.data;
1841 di = xcb_screen_allowed_depths_iterator(xd->screen);
1842 while (di.data && di.data->depth < 24)
1843 xcb_depth_next(&di);
1844 //?? look for class = TrueColor??
1845 xd->visual = xcb_depth_visuals(di.data);
1847 for (i = 0; i < NR_ATOMS; i++) {
1848 const char *n = atom_names[i];
1851 cookies[i] = xcb_intern_atom(conn, 0, strlen(n), n);
1854 xd->win = xcb_generate_id(conn);
1855 valwin[0] = xd->screen->white_pixel;
1856 valwin[1] = (XCB_EVENT_MASK_KEY_PRESS |
1857 XCB_EVENT_MASK_KEY_RELEASE |
1858 XCB_EVENT_MASK_BUTTON_PRESS |
1859 XCB_EVENT_MASK_BUTTON_RELEASE |
1860 // XCB_EVENT_MASK_ENTER_WINDOW |
1861 // XCB_EVENT_MASK_LEAVE_WINDOW |
1862 XCB_EVENT_MASK_FOCUS_CHANGE |
1863 XCB_EVENT_MASK_STRUCTURE_NOTIFY |
1864 XCB_EVENT_MASK_EXPOSURE |
1865 XCB_EVENT_MASK_BUTTON_MOTION |
1866 XCB_EVENT_MASK_POINTER_MOTION_HINT |
1869 xcb_create_window(conn, XCB_COPY_FROM_PARENT, xd->win,
1873 0, XCB_WINDOW_CLASS_INPUT_OUTPUT,
1874 xd->screen->root_visual,
1875 XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK,
1880 surface = cairo_xcb_surface_create(
1881 conn, xd->win, xd->visual, 100, 100);
1884 xd->surface = surface;
1885 cairo = safe_cast cairo_create(xd->surface);
1886 if (cairo_status(cairo) != CAIRO_STATUS_SUCCESS)
1889 fd = pango_font_description_new();
1893 pango_font_description_set_family(xd->fd, "monospace");
1894 pango_font_description_set_size(xd->fd, 12 * PANGO_SCALE);
1896 layout = pango_cairo_create_layout(xd->cairo);
1897 pango_layout_set_font_description(layout, fd);
1898 pango_layout_set_text(layout, "M", 1);
1899 pango_layout_get_pixel_extents(layout, NULL, &log);
1900 g_object_unref(layout);
1901 xd->lineheight = log.height;
1902 xd->charwidth = log.width;
1904 valwin[0] = xd->charwidth * 80;
1905 valwin[1] = xd->lineheight * 26;
1906 xcb_configure_window(conn, xd->win,
1907 XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,
1909 cairo_xcb_surface_set_size(xd->surface, valwin[0], valwin[1]);
1911 /* Now resolve all those cookies */
1912 for (i = 0; i < NR_ATOMS; i++) {
1913 xcb_intern_atom_reply_t *r;
1914 r = xcb_intern_atom_reply(conn, cookies[i], NULL);
1917 xd->atoms[i] = r->atom;
1923 * WM_PROTOCOLS _NET_WM_SYN_REQUEST??
1924 * WM_NORMAL_HINTS WM_HINTS
1927 set_str_prop(xd, a_WM_NAME, "EdLib");
1928 set_utf8_prop(xd, a_NET_WM_NAME, "EdLib");
1929 set_str_prop(xd, a_WM_ICON_NAME, "EdLib");
1930 set_utf8_prop(xd, a_NET_WM_ICON_NAME, "EdLib");
1931 gethostname(hostname, sizeof(hostname));
1932 set_str_prop(xd, a_WM_CLIENT_MACHINE, hostname);
1933 set_atom_prop(xd, a_WM_PROTOCOLS, a_WM_DELETE_WINDOW, a_NET_WM_PING, 0);
1935 /* Configure passive grabs - shift, lock, and control only */
1936 xcb_grab_button(xd->conn, 0, xd->win,
1937 XCB_EVENT_MASK_BUTTON_PRESS |
1938 XCB_EVENT_MASK_BUTTON_RELEASE |
1939 XCB_EVENT_MASK_BUTTON_MOTION,
1940 XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC,
1941 XCB_WINDOW_NONE, XCB_CURSOR_NONE,
1942 XCB_BUTTON_INDEX_ANY,
1943 XCB_MOD_MASK_SHIFT |
1945 XCB_MOD_MASK_CONTROL);
1947 xcb_load_icon(focus, xd, "{COMM}-icon.png");
1948 xcb_map_window(conn, xd->win);
1950 pane_resize(p, 0, 0, xd->charwidth*80, xd->lineheight*26);
1951 call_comm("event:read", p, &xcb_input, xcb_get_file_descriptor(conn));
1952 call_comm("event:poll", p, &xcb_input);
1953 attr_set_str(&p->attrs, "DISPLAY", d);
1954 attr_set_str(&p->attrs, "XAUTHORITY", disp_auth);
1955 snprintf(scale, sizeof(scale), "%dx%d", xd->charwidth, xd->lineheight);
1956 attr_set_str(&p->attrs, "scale:M", scale);
1957 xd->last_event = time(NULL);
1958 call("editor:request:all-displays", p);
1959 p = call_ret(pane, "editor:activate-display", p);
1963 cairo_destroy(xd->cairo);
1964 cairo_surface_destroy(xd->surface);
1965 xcb_disconnect(conn);
1967 free(xd->disp_auth);
1971 DEF_CMD(xcb_new_display)
1974 const char *d = ci->str;
1975 const char *disp_auth = ci->str2;
1978 d = pane_attr_get(ci->focus, "DISPLAY");
1980 disp_auth = pane_attr_get(ci->focus, "XAUTHORITY");
1982 disp_auth = getenv("XAUTHORITY");
1986 p = xcb_display_init(d, disp_auth, ci->focus);
1988 home_call_ret(pane, ci->focus, "doc:attach-view", p, 1);
1990 comm_call(ci->comm2, "cb", p);
1994 void edlib_init(struct pane *ed safe)
1996 call_comm("global-set-command", ed, &xcb_new_display, 0, NULL,
1997 "attach-display-x11");
1998 call_comm("global-set-command", ed, &xcb_new_display, 0, NULL,
1999 "interactive-cmd-x11window");
2001 xcb_map = key_alloc();
2003 key_add(xcb_map, "window:close", &xcb_close_display);
2004 key_add(xcb_map, "window:external-viewer", &xcb_external_viewer);
2005 key_add(xcb_map, "window:fullscreen", &xcb_fullscreen);
2006 key_add(xcb_map, "window:new", &xcb_new_display);
2008 key_add(xcb_map, "Close", &xcb_close);
2009 key_add(xcb_map, "Draw:clear", &xcb_clear);
2010 key_add(xcb_map, "Draw:text-size", &xcb_text_size);
2011 key_add(xcb_map, "Draw:text", &xcb_draw_text);
2012 key_add(xcb_map, "Draw:image", &xcb_draw_image);
2013 key_add(xcb_map, "Draw:image-size", &xcb_image_size);
2014 key_add(xcb_map, "Refresh:size", &xcb_refresh_size);
2015 key_add(xcb_map, "Refresh:postorder", &xcb_refresh_post);
2016 key_add(xcb_map, "all-displays", &xcb_notify_display);
2017 key_add(xcb_map, "Notify:Close", &xcb_pane_close);