|
0
|
1 /* See LICENSE for license details. */ |
|
|
2 #include <errno.h> |
|
|
3 #include <math.h> |
|
|
4 #include <limits.h> |
|
|
5 #include <locale.h> |
|
|
6 #include <signal.h> |
|
|
7 #include <sys/select.h> |
|
|
8 #include <time.h> |
|
|
9 #include <unistd.h> |
|
|
10 #include <libgen.h> |
|
|
11 #include <X11/Xatom.h> |
|
|
12 #include <X11/Xlib.h> |
|
|
13 #include <X11/cursorfont.h> |
|
|
14 #include <X11/keysym.h> |
|
|
15 #include <X11/Xft/Xft.h> |
|
|
16 #include <X11/XKBlib.h> |
|
|
17 |
|
|
18 char *argv0; |
|
|
19 #include "arg.h" |
|
|
20 #include "st.h" |
|
|
21 #include "win.h" |
|
|
22 |
|
|
23 /* types used in config.h */ |
|
|
24 typedef struct { |
|
|
25 uint mod; |
|
|
26 KeySym keysym; |
|
|
27 void (*func)(const Arg *); |
|
|
28 const Arg arg; |
|
|
29 } Shortcut; |
|
|
30 |
|
|
31 typedef struct { |
|
|
32 uint mod; |
|
|
33 uint button; |
|
|
34 void (*func)(const Arg *); |
|
|
35 const Arg arg; |
|
|
36 uint release; |
|
|
37 } MouseShortcut; |
|
|
38 |
|
|
39 typedef struct { |
|
|
40 KeySym k; |
|
|
41 uint mask; |
|
|
42 char *s; |
|
|
43 /* three-valued logic variables: 0 indifferent, 1 on, -1 off */ |
|
|
44 signed char appkey; /* application keypad */ |
|
|
45 signed char appcursor; /* application cursor */ |
|
|
46 } Key; |
|
|
47 |
|
|
48 /* X modifiers */ |
|
|
49 #define XK_ANY_MOD UINT_MAX |
|
|
50 #define XK_NO_MOD 0 |
|
|
51 #define XK_SWITCH_MOD (1<<13|1<<14) |
|
|
52 |
|
|
53 /* function definitions used in config.h */ |
|
|
54 static void clipcopy(const Arg *); |
|
|
55 static void clippaste(const Arg *); |
|
|
56 static void numlock(const Arg *); |
|
|
57 static void selpaste(const Arg *); |
|
|
58 static void zoom(const Arg *); |
|
|
59 static void zoomabs(const Arg *); |
|
|
60 static void zoomreset(const Arg *); |
|
|
61 static void ttysend(const Arg *); |
|
|
62 |
|
|
63 /* config.h for applying patches and the configuration. */ |
|
|
64 #include "config.h" |
|
|
65 |
|
|
66 /* XEMBED messages */ |
|
|
67 #define XEMBED_FOCUS_IN 4 |
|
|
68 #define XEMBED_FOCUS_OUT 5 |
|
|
69 |
|
|
70 /* macros */ |
|
|
71 #define IS_SET(flag) ((win.mode & (flag)) != 0) |
|
|
72 #define TRUERED(x) (((x) & 0xff0000) >> 8) |
|
|
73 #define TRUEGREEN(x) (((x) & 0xff00)) |
|
|
74 #define TRUEBLUE(x) (((x) & 0xff) << 8) |
|
|
75 |
|
|
76 typedef XftDraw *Draw; |
|
|
77 typedef XftColor Color; |
|
|
78 typedef XftGlyphFontSpec GlyphFontSpec; |
|
|
79 |
|
|
80 /* Purely graphic info */ |
|
|
81 typedef struct { |
|
|
82 int tw, th; /* tty width and height */ |
|
|
83 int w, h; /* window width and height */ |
|
|
84 int ch; /* char height */ |
|
|
85 int cw; /* char width */ |
|
|
86 int mode; /* window state/mode flags */ |
|
|
87 int cursor; /* cursor style */ |
|
|
88 } TermWindow; |
|
|
89 |
|
|
90 typedef struct { |
|
|
91 Display *dpy; |
|
|
92 Colormap cmap; |
|
|
93 Window win; |
|
|
94 Drawable buf; |
|
|
95 GlyphFontSpec *specbuf; /* font spec buffer used for rendering */ |
|
|
96 Atom xembed, wmdeletewin, netwmname, netwmiconname, netwmpid; |
|
|
97 struct { |
|
|
98 XIM xim; |
|
|
99 XIC xic; |
|
|
100 XPoint spot; |
|
|
101 XVaNestedList spotlist; |
|
|
102 } ime; |
|
|
103 Draw draw; |
|
|
104 Visual *vis; |
|
|
105 XSetWindowAttributes attrs; |
|
|
106 int scr; |
|
|
107 int isfixed; /* is fixed geometry? */ |
|
|
108 int depth; /* bit depth */ |
|
|
109 int l, t; /* left and top offset */ |
|
|
110 int gm; /* geometry mask */ |
|
|
111 } XWindow; |
|
|
112 |
|
|
113 typedef struct { |
|
|
114 Atom xtarget; |
|
|
115 char *primary, *clipboard; |
|
|
116 struct timespec tclick1; |
|
|
117 struct timespec tclick2; |
|
|
118 } XSelection; |
|
|
119 |
|
|
120 /* Font structure */ |
|
|
121 #define Font Font_ |
|
|
122 typedef struct { |
|
|
123 int height; |
|
|
124 int width; |
|
|
125 int ascent; |
|
|
126 int descent; |
|
|
127 int badslant; |
|
|
128 int badweight; |
|
|
129 short lbearing; |
|
|
130 short rbearing; |
|
|
131 XftFont *match; |
|
|
132 FcFontSet *set; |
|
|
133 FcPattern *pattern; |
|
|
134 } Font; |
|
|
135 |
|
|
136 /* Drawing Context */ |
|
|
137 typedef struct { |
|
|
138 Color *col; |
|
|
139 size_t collen; |
|
|
140 Font font, bfont, ifont, ibfont; |
|
|
141 GC gc; |
|
|
142 } DC; |
|
|
143 |
|
|
144 static inline ushort sixd_to_16bit(int); |
|
|
145 static int xmakeglyphfontspecs(XftGlyphFontSpec *, const Glyph *, int, int, int); |
|
|
146 static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int); |
|
|
147 static void xdrawglyph(Glyph, int, int); |
|
|
148 static void xclear(int, int, int, int); |
|
|
149 static int xgeommasktogravity(int); |
|
|
150 static int ximopen(Display *); |
|
|
151 static void ximinstantiate(Display *, XPointer, XPointer); |
|
|
152 static void ximdestroy(XIM, XPointer, XPointer); |
|
|
153 static int xicdestroy(XIC, XPointer, XPointer); |
|
|
154 static void xinit(int, int); |
|
|
155 static void cresize(int, int); |
|
|
156 static void xresize(int, int); |
|
|
157 static void xhints(void); |
|
|
158 static int xloadcolor(int, const char *, Color *); |
|
|
159 static int xloadfont(Font *, FcPattern *); |
|
|
160 static void xloadfonts(const char *, double); |
|
|
161 static void xunloadfont(Font *); |
|
|
162 static void xunloadfonts(void); |
|
|
163 static void xsetenv(void); |
|
|
164 static void xseturgency(int); |
|
|
165 static int evcol(XEvent *); |
|
|
166 static int evrow(XEvent *); |
|
|
167 |
|
|
168 static void expose(XEvent *); |
|
|
169 static void visibility(XEvent *); |
|
|
170 static void unmap(XEvent *); |
|
|
171 static void kpress(XEvent *); |
|
|
172 static void cmessage(XEvent *); |
|
|
173 static void resize(XEvent *); |
|
|
174 static void focus(XEvent *); |
|
|
175 static uint buttonmask(uint); |
|
|
176 static int mouseaction(XEvent *, uint); |
|
|
177 static void brelease(XEvent *); |
|
|
178 static void bpress(XEvent *); |
|
|
179 static void bmotion(XEvent *); |
|
|
180 static void propnotify(XEvent *); |
|
|
181 static void selnotify(XEvent *); |
|
|
182 static void selclear_(XEvent *); |
|
|
183 static void selrequest(XEvent *); |
|
|
184 static void setsel(char *, Time); |
|
|
185 static void mousesel(XEvent *, int); |
|
|
186 static void mousereport(XEvent *); |
|
|
187 static char *kmap(KeySym, uint); |
|
|
188 static int match(uint, uint); |
|
|
189 |
|
|
190 static void run(void); |
|
|
191 static void usage(void); |
|
|
192 |
|
|
193 static void (*handler[LASTEvent])(XEvent *) = { |
|
|
194 [KeyPress] = kpress, |
|
|
195 [ClientMessage] = cmessage, |
|
|
196 [ConfigureNotify] = resize, |
|
|
197 [VisibilityNotify] = visibility, |
|
|
198 [UnmapNotify] = unmap, |
|
|
199 [Expose] = expose, |
|
|
200 [FocusIn] = focus, |
|
|
201 [FocusOut] = focus, |
|
|
202 [MotionNotify] = bmotion, |
|
|
203 [ButtonPress] = bpress, |
|
|
204 [ButtonRelease] = brelease, |
|
|
205 /* |
|
|
206 * Uncomment if you want the selection to disappear when you select something |
|
|
207 * different in another window. |
|
|
208 */ |
|
|
209 /* [SelectionClear] = selclear_, */ |
|
|
210 [SelectionNotify] = selnotify, |
|
|
211 /* |
|
|
212 * PropertyNotify is only turned on when there is some INCR transfer happening |
|
|
213 * for the selection retrieval. |
|
|
214 */ |
|
|
215 [PropertyNotify] = propnotify, |
|
|
216 [SelectionRequest] = selrequest, |
|
|
217 }; |
|
|
218 |
|
|
219 /* Globals */ |
|
|
220 static DC dc; |
|
|
221 static XWindow xw; |
|
|
222 static XSelection xsel; |
|
|
223 static TermWindow win; |
|
|
224 |
|
|
225 /* Font Ring Cache */ |
|
|
226 enum { |
|
|
227 FRC_NORMAL, |
|
|
228 FRC_ITALIC, |
|
|
229 FRC_BOLD, |
|
|
230 FRC_ITALICBOLD |
|
|
231 }; |
|
|
232 |
|
|
233 typedef struct { |
|
|
234 XftFont *font; |
|
|
235 int flags; |
|
|
236 Rune unicodep; |
|
|
237 } Fontcache; |
|
|
238 |
|
|
239 /* Fontcache is an array now. A new font will be appended to the array. */ |
|
|
240 static Fontcache *frc = NULL; |
|
|
241 static int frclen = 0; |
|
|
242 static int frccap = 0; |
|
|
243 static char *usedfont = NULL; |
|
|
244 static double usedfontsize = 0; |
|
|
245 static double defaultfontsize = 0; |
|
|
246 |
|
|
247 static char *opt_class = NULL; |
|
|
248 static char **opt_cmd = NULL; |
|
|
249 static char *opt_embed = NULL; |
|
|
250 static char *opt_font = NULL; |
|
|
251 static char *opt_io = NULL; |
|
|
252 static char *opt_line = NULL; |
|
|
253 static char *opt_name = NULL; |
|
|
254 static char *opt_title = NULL; |
|
|
255 |
|
|
256 static uint buttons; /* bit field of pressed buttons */ |
|
|
257 |
|
|
258 void |
|
|
259 clipcopy(const Arg *dummy) |
|
|
260 { |
|
|
261 Atom clipboard; |
|
|
262 |
|
|
263 free(xsel.clipboard); |
|
|
264 xsel.clipboard = NULL; |
|
|
265 |
|
|
266 if (xsel.primary != NULL) { |
|
|
267 xsel.clipboard = xstrdup(xsel.primary); |
|
|
268 clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); |
|
|
269 XSetSelectionOwner(xw.dpy, clipboard, xw.win, CurrentTime); |
|
|
270 } |
|
|
271 } |
|
|
272 |
|
|
273 void |
|
|
274 clippaste(const Arg *dummy) |
|
|
275 { |
|
|
276 Atom clipboard; |
|
|
277 |
|
|
278 clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); |
|
|
279 XConvertSelection(xw.dpy, clipboard, xsel.xtarget, clipboard, |
|
|
280 xw.win, CurrentTime); |
|
|
281 } |
|
|
282 |
|
|
283 void |
|
|
284 selpaste(const Arg *dummy) |
|
|
285 { |
|
|
286 XConvertSelection(xw.dpy, XA_PRIMARY, xsel.xtarget, XA_PRIMARY, |
|
|
287 xw.win, CurrentTime); |
|
|
288 } |
|
|
289 |
|
|
290 void |
|
|
291 numlock(const Arg *dummy) |
|
|
292 { |
|
|
293 win.mode ^= MODE_NUMLOCK; |
|
|
294 } |
|
|
295 |
|
|
296 void |
|
|
297 zoom(const Arg *arg) |
|
|
298 { |
|
|
299 Arg larg; |
|
|
300 |
|
|
301 larg.f = usedfontsize + arg->f; |
|
|
302 zoomabs(&larg); |
|
|
303 } |
|
|
304 |
|
|
305 void |
|
|
306 zoomabs(const Arg *arg) |
|
|
307 { |
|
|
308 xunloadfonts(); |
|
|
309 xloadfonts(usedfont, arg->f); |
|
|
310 cresize(0, 0); |
|
|
311 redraw(); |
|
|
312 xhints(); |
|
|
313 } |
|
|
314 |
|
|
315 void |
|
|
316 zoomreset(const Arg *arg) |
|
|
317 { |
|
|
318 Arg larg; |
|
|
319 |
|
|
320 if (defaultfontsize > 0) { |
|
|
321 larg.f = defaultfontsize; |
|
|
322 zoomabs(&larg); |
|
|
323 } |
|
|
324 } |
|
|
325 |
|
|
326 void |
|
|
327 ttysend(const Arg *arg) |
|
|
328 { |
|
|
329 ttywrite(arg->s, strlen(arg->s), 1); |
|
|
330 } |
|
|
331 |
|
|
332 int |
|
|
333 evcol(XEvent *e) |
|
|
334 { |
|
|
335 int x = e->xbutton.x - borderpx; |
|
|
336 LIMIT(x, 0, win.tw - 1); |
|
|
337 return x / win.cw; |
|
|
338 } |
|
|
339 |
|
|
340 int |
|
|
341 evrow(XEvent *e) |
|
|
342 { |
|
|
343 int y = e->xbutton.y - borderpx; |
|
|
344 LIMIT(y, 0, win.th - 1); |
|
|
345 return y / win.ch; |
|
|
346 } |
|
|
347 |
|
|
348 void |
|
|
349 mousesel(XEvent *e, int done) |
|
|
350 { |
|
|
351 int type, seltype = SEL_REGULAR; |
|
|
352 uint state = e->xbutton.state & ~(Button1Mask | forcemousemod); |
|
|
353 |
|
|
354 for (type = 1; type < LEN(selmasks); ++type) { |
|
|
355 if (match(selmasks[type], state)) { |
|
|
356 seltype = type; |
|
|
357 break; |
|
|
358 } |
|
|
359 } |
|
|
360 selextend(evcol(e), evrow(e), seltype, done); |
|
|
361 if (done) |
|
|
362 setsel(getsel(), e->xbutton.time); |
|
|
363 } |
|
|
364 |
|
|
365 void |
|
|
366 mousereport(XEvent *e) |
|
|
367 { |
|
|
368 int len, btn, code; |
|
|
369 int x = evcol(e), y = evrow(e); |
|
|
370 int state = e->xbutton.state; |
|
|
371 char buf[40]; |
|
|
372 static int ox, oy; |
|
|
373 |
|
|
374 if (e->type == MotionNotify) { |
|
|
375 if (x == ox && y == oy) |
|
|
376 return; |
|
|
377 if (!IS_SET(MODE_MOUSEMOTION) && !IS_SET(MODE_MOUSEMANY)) |
|
|
378 return; |
|
|
379 /* MODE_MOUSEMOTION: no reporting if no button is pressed */ |
|
|
380 if (IS_SET(MODE_MOUSEMOTION) && buttons == 0) |
|
|
381 return; |
|
|
382 /* Set btn to lowest-numbered pressed button, or 12 if no |
|
|
383 * buttons are pressed. */ |
|
|
384 for (btn = 1; btn <= 11 && !(buttons & (1<<(btn-1))); btn++) |
|
|
385 ; |
|
|
386 code = 32; |
|
|
387 } else { |
|
|
388 btn = e->xbutton.button; |
|
|
389 /* Only buttons 1 through 11 can be encoded */ |
|
|
390 if (btn < 1 || btn > 11) |
|
|
391 return; |
|
|
392 if (e->type == ButtonRelease) { |
|
|
393 /* MODE_MOUSEX10: no button release reporting */ |
|
|
394 if (IS_SET(MODE_MOUSEX10)) |
|
|
395 return; |
|
|
396 /* Don't send release events for the scroll wheel */ |
|
|
397 if (btn == 4 || btn == 5) |
|
|
398 return; |
|
|
399 } |
|
|
400 code = 0; |
|
|
401 } |
|
|
402 |
|
|
403 ox = x; |
|
|
404 oy = y; |
|
|
405 |
|
|
406 /* Encode btn into code. If no button is pressed for a motion event in |
|
|
407 * MODE_MOUSEMANY, then encode it as a release. */ |
|
|
408 if ((!IS_SET(MODE_MOUSESGR) && e->type == ButtonRelease) || btn == 12) |
|
|
409 code += 3; |
|
|
410 else if (btn >= 8) |
|
|
411 code += 128 + btn - 8; |
|
|
412 else if (btn >= 4) |
|
|
413 code += 64 + btn - 4; |
|
|
414 else |
|
|
415 code += btn - 1; |
|
|
416 |
|
|
417 if (!IS_SET(MODE_MOUSEX10)) { |
|
|
418 code += ((state & ShiftMask ) ? 4 : 0) |
|
|
419 + ((state & Mod1Mask ) ? 8 : 0) /* meta key: alt */ |
|
|
420 + ((state & ControlMask) ? 16 : 0); |
|
|
421 } |
|
|
422 |
|
|
423 if (IS_SET(MODE_MOUSESGR)) { |
|
|
424 len = snprintf(buf, sizeof(buf), "\033[<%d;%d;%d%c", |
|
|
425 code, x+1, y+1, |
|
|
426 e->type == ButtonRelease ? 'm' : 'M'); |
|
|
427 } else if (x < 223 && y < 223) { |
|
|
428 len = snprintf(buf, sizeof(buf), "\033[M%c%c%c", |
|
|
429 32+code, 32+x+1, 32+y+1); |
|
|
430 } else { |
|
|
431 return; |
|
|
432 } |
|
|
433 |
|
|
434 ttywrite(buf, len, 0); |
|
|
435 } |
|
|
436 |
|
|
437 uint |
|
|
438 buttonmask(uint button) |
|
|
439 { |
|
|
440 return button == Button1 ? Button1Mask |
|
|
441 : button == Button2 ? Button2Mask |
|
|
442 : button == Button3 ? Button3Mask |
|
|
443 : button == Button4 ? Button4Mask |
|
|
444 : button == Button5 ? Button5Mask |
|
|
445 : 0; |
|
|
446 } |
|
|
447 |
|
|
448 int |
|
|
449 mouseaction(XEvent *e, uint release) |
|
|
450 { |
|
|
451 MouseShortcut *ms; |
|
|
452 |
|
|
453 /* ignore Button<N>mask for Button<N> - it's set on release */ |
|
|
454 uint state = e->xbutton.state & ~buttonmask(e->xbutton.button); |
|
|
455 |
|
|
456 for (ms = mshortcuts; ms < mshortcuts + LEN(mshortcuts); ms++) { |
|
|
457 if (ms->release == release && |
|
|
458 ms->button == e->xbutton.button && |
|
|
459 (match(ms->mod, state) || /* exact or forced */ |
|
|
460 match(ms->mod, state & ~forcemousemod))) { |
|
|
461 ms->func(&(ms->arg)); |
|
|
462 return 1; |
|
|
463 } |
|
|
464 } |
|
|
465 |
|
|
466 return 0; |
|
|
467 } |
|
|
468 |
|
|
469 void |
|
|
470 bpress(XEvent *e) |
|
|
471 { |
|
|
472 int btn = e->xbutton.button; |
|
|
473 struct timespec now; |
|
|
474 int snap; |
|
|
475 |
|
|
476 if (1 <= btn && btn <= 11) |
|
|
477 buttons |= 1 << (btn-1); |
|
|
478 |
|
|
479 if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) { |
|
|
480 mousereport(e); |
|
|
481 return; |
|
|
482 } |
|
|
483 |
|
|
484 if (mouseaction(e, 0)) |
|
|
485 return; |
|
|
486 |
|
|
487 if (btn == Button1) { |
|
|
488 /* |
|
|
489 * If the user clicks below predefined timeouts specific |
|
|
490 * snapping behaviour is exposed. |
|
|
491 */ |
|
|
492 clock_gettime(CLOCK_MONOTONIC, &now); |
|
|
493 if (TIMEDIFF(now, xsel.tclick2) <= tripleclicktimeout) { |
|
|
494 snap = SNAP_LINE; |
|
|
495 } else if (TIMEDIFF(now, xsel.tclick1) <= doubleclicktimeout) { |
|
|
496 snap = SNAP_WORD; |
|
|
497 } else { |
|
|
498 snap = 0; |
|
|
499 } |
|
|
500 xsel.tclick2 = xsel.tclick1; |
|
|
501 xsel.tclick1 = now; |
|
|
502 |
|
|
503 selstart(evcol(e), evrow(e), snap); |
|
|
504 } |
|
|
505 } |
|
|
506 |
|
|
507 void |
|
|
508 propnotify(XEvent *e) |
|
|
509 { |
|
|
510 XPropertyEvent *xpev; |
|
|
511 Atom clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); |
|
|
512 |
|
|
513 xpev = &e->xproperty; |
|
|
514 if (xpev->state == PropertyNewValue && |
|
|
515 (xpev->atom == XA_PRIMARY || |
|
|
516 xpev->atom == clipboard)) { |
|
|
517 selnotify(e); |
|
|
518 } |
|
|
519 } |
|
|
520 |
|
|
521 void |
|
|
522 selnotify(XEvent *e) |
|
|
523 { |
|
|
524 ulong nitems, ofs, rem; |
|
|
525 int format; |
|
|
526 uchar *data, *last, *repl; |
|
|
527 Atom type, incratom, property = None; |
|
|
528 |
|
|
529 incratom = XInternAtom(xw.dpy, "INCR", 0); |
|
|
530 |
|
|
531 ofs = 0; |
|
|
532 if (e->type == SelectionNotify) |
|
|
533 property = e->xselection.property; |
|
|
534 else if (e->type == PropertyNotify) |
|
|
535 property = e->xproperty.atom; |
|
|
536 |
|
|
537 if (property == None) |
|
|
538 return; |
|
|
539 |
|
|
540 do { |
|
|
541 if (XGetWindowProperty(xw.dpy, xw.win, property, ofs, |
|
|
542 BUFSIZ/4, False, AnyPropertyType, |
|
|
543 &type, &format, &nitems, &rem, |
|
|
544 &data)) { |
|
|
545 fprintf(stderr, "Clipboard allocation failed\n"); |
|
|
546 return; |
|
|
547 } |
|
|
548 |
|
|
549 if (e->type == PropertyNotify && nitems == 0 && rem == 0) { |
|
|
550 /* |
|
|
551 * If there is some PropertyNotify with no data, then |
|
|
552 * this is the signal of the selection owner that all |
|
|
553 * data has been transferred. We won't need to receive |
|
|
554 * PropertyNotify events anymore. |
|
|
555 */ |
|
|
556 MODBIT(xw.attrs.event_mask, 0, PropertyChangeMask); |
|
|
557 XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, |
|
|
558 &xw.attrs); |
|
|
559 } |
|
|
560 |
|
|
561 if (type == incratom) { |
|
|
562 /* |
|
|
563 * Activate the PropertyNotify events so we receive |
|
|
564 * when the selection owner does send us the next |
|
|
565 * chunk of data. |
|
|
566 */ |
|
|
567 MODBIT(xw.attrs.event_mask, 1, PropertyChangeMask); |
|
|
568 XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, |
|
|
569 &xw.attrs); |
|
|
570 |
|
|
571 /* |
|
|
572 * Deleting the property is the transfer start signal. |
|
|
573 */ |
|
|
574 XDeleteProperty(xw.dpy, xw.win, (int)property); |
|
|
575 continue; |
|
|
576 } |
|
|
577 |
|
|
578 /* |
|
|
579 * As seen in getsel: |
|
|
580 * Line endings are inconsistent in the terminal and GUI world |
|
|
581 * copy and pasting. When receiving some selection data, |
|
|
582 * replace all '\n' with '\r'. |
|
|
583 * FIXME: Fix the computer world. |
|
|
584 */ |
|
|
585 repl = data; |
|
|
586 last = data + nitems * format / 8; |
|
|
587 while ((repl = memchr(repl, '\n', last - repl))) { |
|
|
588 *repl++ = '\r'; |
|
|
589 } |
|
|
590 |
|
|
591 if (IS_SET(MODE_BRCKTPASTE) && ofs == 0) |
|
|
592 ttywrite("\033[200~", 6, 0); |
|
|
593 ttywrite((char *)data, nitems * format / 8, 1); |
|
|
594 if (IS_SET(MODE_BRCKTPASTE) && rem == 0) |
|
|
595 ttywrite("\033[201~", 6, 0); |
|
|
596 XFree(data); |
|
|
597 /* number of 32-bit chunks returned */ |
|
|
598 ofs += nitems * format / 32; |
|
|
599 } while (rem > 0); |
|
|
600 |
|
|
601 /* |
|
|
602 * Deleting the property again tells the selection owner to send the |
|
|
603 * next data chunk in the property. |
|
|
604 */ |
|
|
605 XDeleteProperty(xw.dpy, xw.win, (int)property); |
|
|
606 } |
|
|
607 |
|
|
608 void |
|
|
609 xclipcopy(void) |
|
|
610 { |
|
|
611 clipcopy(NULL); |
|
|
612 } |
|
|
613 |
|
|
614 void |
|
|
615 selclear_(XEvent *e) |
|
|
616 { |
|
|
617 selclear(); |
|
|
618 } |
|
|
619 |
|
|
620 void |
|
|
621 selrequest(XEvent *e) |
|
|
622 { |
|
|
623 XSelectionRequestEvent *xsre; |
|
|
624 XSelectionEvent xev; |
|
|
625 Atom xa_targets, string, clipboard; |
|
|
626 char *seltext; |
|
|
627 |
|
|
628 xsre = (XSelectionRequestEvent *) e; |
|
|
629 xev.type = SelectionNotify; |
|
|
630 xev.requestor = xsre->requestor; |
|
|
631 xev.selection = xsre->selection; |
|
|
632 xev.target = xsre->target; |
|
|
633 xev.time = xsre->time; |
|
|
634 if (xsre->property == None) |
|
|
635 xsre->property = xsre->target; |
|
|
636 |
|
|
637 /* reject */ |
|
|
638 xev.property = None; |
|
|
639 |
|
|
640 xa_targets = XInternAtom(xw.dpy, "TARGETS", 0); |
|
|
641 if (xsre->target == xa_targets) { |
|
|
642 /* respond with the supported type */ |
|
|
643 string = xsel.xtarget; |
|
|
644 XChangeProperty(xsre->display, xsre->requestor, xsre->property, |
|
|
645 XA_ATOM, 32, PropModeReplace, |
|
|
646 (uchar *) &string, 1); |
|
|
647 xev.property = xsre->property; |
|
|
648 } else if (xsre->target == xsel.xtarget || xsre->target == XA_STRING) { |
|
|
649 /* |
|
|
650 * xith XA_STRING non ascii characters may be incorrect in the |
|
|
651 * requestor. It is not our problem, use utf8. |
|
|
652 */ |
|
|
653 clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); |
|
|
654 if (xsre->selection == XA_PRIMARY) { |
|
|
655 seltext = xsel.primary; |
|
|
656 } else if (xsre->selection == clipboard) { |
|
|
657 seltext = xsel.clipboard; |
|
|
658 } else { |
|
|
659 fprintf(stderr, |
|
|
660 "Unhandled clipboard selection 0x%lx\n", |
|
|
661 xsre->selection); |
|
|
662 return; |
|
|
663 } |
|
|
664 if (seltext != NULL) { |
|
|
665 XChangeProperty(xsre->display, xsre->requestor, |
|
|
666 xsre->property, xsre->target, |
|
|
667 8, PropModeReplace, |
|
|
668 (uchar *)seltext, strlen(seltext)); |
|
|
669 xev.property = xsre->property; |
|
|
670 } |
|
|
671 } |
|
|
672 |
|
|
673 /* all done, send a notification to the listener */ |
|
|
674 if (!XSendEvent(xsre->display, xsre->requestor, 1, 0, (XEvent *) &xev)) |
|
|
675 fprintf(stderr, "Error sending SelectionNotify event\n"); |
|
|
676 } |
|
|
677 |
|
|
678 void |
|
|
679 setsel(char *str, Time t) |
|
|
680 { |
|
|
681 if (!str) |
|
|
682 return; |
|
|
683 |
|
|
684 free(xsel.primary); |
|
|
685 xsel.primary = str; |
|
|
686 |
|
|
687 XSetSelectionOwner(xw.dpy, XA_PRIMARY, xw.win, t); |
|
|
688 if (XGetSelectionOwner(xw.dpy, XA_PRIMARY) != xw.win) |
|
|
689 selclear(); |
|
|
690 } |
|
|
691 |
|
|
692 void |
|
|
693 xsetsel(char *str) |
|
|
694 { |
|
|
695 setsel(str, CurrentTime); |
|
|
696 } |
|
|
697 |
|
|
698 void |
|
|
699 brelease(XEvent *e) |
|
|
700 { |
|
|
701 int btn = e->xbutton.button; |
|
|
702 |
|
|
703 if (1 <= btn && btn <= 11) |
|
|
704 buttons &= ~(1 << (btn-1)); |
|
|
705 |
|
|
706 if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) { |
|
|
707 mousereport(e); |
|
|
708 return; |
|
|
709 } |
|
|
710 |
|
|
711 if (mouseaction(e, 1)) |
|
|
712 return; |
|
|
713 if (btn == Button1) |
|
|
714 mousesel(e, 1); |
|
|
715 } |
|
|
716 |
|
|
717 void |
|
|
718 bmotion(XEvent *e) |
|
|
719 { |
|
|
720 if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) { |
|
|
721 mousereport(e); |
|
|
722 return; |
|
|
723 } |
|
|
724 |
|
|
725 mousesel(e, 0); |
|
|
726 } |
|
|
727 |
|
|
728 void |
|
|
729 cresize(int width, int height) |
|
|
730 { |
|
|
731 int col, row; |
|
|
732 |
|
|
733 if (width != 0) |
|
|
734 win.w = width; |
|
|
735 if (height != 0) |
|
|
736 win.h = height; |
|
|
737 |
|
|
738 col = (win.w - 2 * borderpx) / win.cw; |
|
|
739 row = (win.h - 2 * borderpx) / win.ch; |
|
|
740 col = MAX(1, col); |
|
|
741 row = MAX(1, row); |
|
|
742 |
|
|
743 tresize(col, row); |
|
|
744 xresize(col, row); |
|
|
745 ttyresize(win.tw, win.th); |
|
|
746 } |
|
|
747 |
|
|
748 void |
|
|
749 xresize(int col, int row) |
|
|
750 { |
|
|
751 win.tw = col * win.cw; |
|
|
752 win.th = row * win.ch; |
|
|
753 |
|
|
754 XFreePixmap(xw.dpy, xw.buf); |
|
|
755 xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h, |
|
|
756 xw.depth); |
|
|
757 XftDrawChange(xw.draw, xw.buf); |
|
|
758 xclear(0, 0, win.w, win.h); |
|
|
759 |
|
|
760 /* resize to new width */ |
|
|
761 xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec)); |
|
|
762 } |
|
|
763 |
|
|
764 ushort |
|
|
765 sixd_to_16bit(int x) |
|
|
766 { |
|
|
767 return x == 0 ? 0 : 0x3737 + 0x2828 * x; |
|
|
768 } |
|
|
769 |
|
|
770 int |
|
|
771 xloadcolor(int i, const char *name, Color *ncolor) |
|
|
772 { |
|
|
773 XRenderColor color = { .alpha = 0xffff }; |
|
|
774 |
|
|
775 if (!name) { |
|
|
776 if (BETWEEN(i, 16, 255)) { /* 256 color */ |
|
|
777 if (i < 6*6*6+16) { /* same colors as xterm */ |
|
|
778 color.red = sixd_to_16bit( ((i-16)/36)%6 ); |
|
|
779 color.green = sixd_to_16bit( ((i-16)/6) %6 ); |
|
|
780 color.blue = sixd_to_16bit( ((i-16)/1) %6 ); |
|
|
781 } else { /* greyscale */ |
|
|
782 color.red = 0x0808 + 0x0a0a * (i - (6*6*6+16)); |
|
|
783 color.green = color.blue = color.red; |
|
|
784 } |
|
|
785 return XftColorAllocValue(xw.dpy, xw.vis, |
|
|
786 xw.cmap, &color, ncolor); |
|
|
787 } else |
|
|
788 name = colorname[i]; |
|
|
789 } |
|
|
790 |
|
|
791 return XftColorAllocName(xw.dpy, xw.vis, xw.cmap, name, ncolor); |
|
|
792 } |
|
|
793 |
|
|
794 void |
|
|
795 xloadcols(void) |
|
|
796 { |
|
|
797 int i; |
|
|
798 static int loaded; |
|
|
799 Color *cp; |
|
|
800 |
|
|
801 if (loaded) { |
|
|
802 for (cp = dc.col; cp < &dc.col[dc.collen]; ++cp) |
|
|
803 XftColorFree(xw.dpy, xw.vis, xw.cmap, cp); |
|
|
804 } else { |
|
|
805 dc.collen = MAX(LEN(colorname), 256); |
|
|
806 dc.col = xmalloc(dc.collen * sizeof(Color)); |
|
|
807 } |
|
|
808 |
|
|
809 for (i = 0; i < dc.collen; i++) |
|
|
810 if (!xloadcolor(i, NULL, &dc.col[i])) { |
|
|
811 if (colorname[i]) |
|
|
812 die("could not allocate color '%s'\n", colorname[i]); |
|
|
813 else |
|
|
814 die("could not allocate color %d\n", i); |
|
|
815 } |
|
|
816 |
|
|
817 dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * alpha); |
|
|
818 dc.col[defaultbg].pixel &= 0x00FFFFFF; |
|
|
819 dc.col[defaultbg].pixel |= (unsigned char)(0xff * alpha) << 24; |
|
|
820 loaded = 1; |
|
|
821 } |
|
|
822 |
|
|
823 int |
|
|
824 xgetcolor(int x, unsigned char *r, unsigned char *g, unsigned char *b) |
|
|
825 { |
|
|
826 if (!BETWEEN(x, 0, dc.collen - 1)) |
|
|
827 return 1; |
|
|
828 |
|
|
829 *r = dc.col[x].color.red >> 8; |
|
|
830 *g = dc.col[x].color.green >> 8; |
|
|
831 *b = dc.col[x].color.blue >> 8; |
|
|
832 |
|
|
833 return 0; |
|
|
834 } |
|
|
835 |
|
|
836 int |
|
|
837 xsetcolorname(int x, const char *name) |
|
|
838 { |
|
|
839 Color ncolor; |
|
|
840 |
|
|
841 if (!BETWEEN(x, 0, dc.collen - 1)) |
|
|
842 return 1; |
|
|
843 |
|
|
844 if (!xloadcolor(x, name, &ncolor)) |
|
|
845 return 1; |
|
|
846 |
|
|
847 XftColorFree(xw.dpy, xw.vis, xw.cmap, &dc.col[x]); |
|
|
848 dc.col[x] = ncolor; |
|
|
849 |
|
|
850 if (x == defaultbg) { |
|
|
851 dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * alpha); |
|
|
852 dc.col[defaultbg].pixel &= 0x00FFFFFF; |
|
|
853 dc.col[defaultbg].pixel |= (unsigned char)(0xff * alpha) << 24; |
|
|
854 } |
|
|
855 |
|
|
856 return 0; |
|
|
857 } |
|
|
858 |
|
|
859 /* |
|
|
860 * Absolute coordinates. |
|
|
861 */ |
|
|
862 void |
|
|
863 xclear(int x1, int y1, int x2, int y2) |
|
|
864 { |
|
|
865 XftDrawRect(xw.draw, |
|
|
866 &dc.col[IS_SET(MODE_REVERSE)? defaultfg : defaultbg], |
|
|
867 x1, y1, x2-x1, y2-y1); |
|
|
868 } |
|
|
869 |
|
|
870 void |
|
|
871 xhints(void) |
|
|
872 { |
|
|
873 XClassHint class = {opt_name ? opt_name : termname, |
|
|
874 opt_class ? opt_class : termname}; |
|
|
875 XWMHints wm = {.flags = InputHint, .input = 1}; |
|
|
876 XSizeHints *sizeh; |
|
|
877 |
|
|
878 sizeh = XAllocSizeHints(); |
|
|
879 |
|
|
880 sizeh->flags = PSize | PResizeInc | PBaseSize | PMinSize; |
|
|
881 sizeh->height = win.h; |
|
|
882 sizeh->width = win.w; |
|
|
883 sizeh->height_inc = win.ch; |
|
|
884 sizeh->width_inc = win.cw; |
|
|
885 sizeh->base_height = 2 * borderpx; |
|
|
886 sizeh->base_width = 2 * borderpx; |
|
|
887 sizeh->min_height = win.ch + 2 * borderpx; |
|
|
888 sizeh->min_width = win.cw + 2 * borderpx; |
|
|
889 if (xw.isfixed) { |
|
|
890 sizeh->flags |= PMaxSize; |
|
|
891 sizeh->min_width = sizeh->max_width = win.w; |
|
|
892 sizeh->min_height = sizeh->max_height = win.h; |
|
|
893 } |
|
|
894 if (xw.gm & (XValue|YValue)) { |
|
|
895 sizeh->flags |= USPosition | PWinGravity; |
|
|
896 sizeh->x = xw.l; |
|
|
897 sizeh->y = xw.t; |
|
|
898 sizeh->win_gravity = xgeommasktogravity(xw.gm); |
|
|
899 } |
|
|
900 |
|
|
901 XSetWMProperties(xw.dpy, xw.win, NULL, NULL, NULL, 0, sizeh, &wm, |
|
|
902 &class); |
|
|
903 XFree(sizeh); |
|
|
904 } |
|
|
905 |
|
|
906 int |
|
|
907 xgeommasktogravity(int mask) |
|
|
908 { |
|
|
909 switch (mask & (XNegative|YNegative)) { |
|
|
910 case 0: |
|
|
911 return NorthWestGravity; |
|
|
912 case XNegative: |
|
|
913 return NorthEastGravity; |
|
|
914 case YNegative: |
|
|
915 return SouthWestGravity; |
|
|
916 } |
|
|
917 |
|
|
918 return SouthEastGravity; |
|
|
919 } |
|
|
920 |
|
|
921 int |
|
|
922 xloadfont(Font *f, FcPattern *pattern) |
|
|
923 { |
|
|
924 FcPattern *configured; |
|
|
925 FcPattern *match; |
|
|
926 FcResult result; |
|
|
927 XGlyphInfo extents; |
|
|
928 int wantattr, haveattr; |
|
|
929 |
|
|
930 /* |
|
|
931 * Manually configure instead of calling XftMatchFont |
|
|
932 * so that we can use the configured pattern for |
|
|
933 * "missing glyph" lookups. |
|
|
934 */ |
|
|
935 configured = FcPatternDuplicate(pattern); |
|
|
936 if (!configured) |
|
|
937 return 1; |
|
|
938 |
|
|
939 FcConfigSubstitute(NULL, configured, FcMatchPattern); |
|
|
940 XftDefaultSubstitute(xw.dpy, xw.scr, configured); |
|
|
941 |
|
|
942 match = FcFontMatch(NULL, configured, &result); |
|
|
943 if (!match) { |
|
|
944 FcPatternDestroy(configured); |
|
|
945 return 1; |
|
|
946 } |
|
|
947 |
|
|
948 if (!(f->match = XftFontOpenPattern(xw.dpy, match))) { |
|
|
949 FcPatternDestroy(configured); |
|
|
950 FcPatternDestroy(match); |
|
|
951 return 1; |
|
|
952 } |
|
|
953 |
|
|
954 if ((XftPatternGetInteger(pattern, "slant", 0, &wantattr) == |
|
|
955 XftResultMatch)) { |
|
|
956 /* |
|
|
957 * Check if xft was unable to find a font with the appropriate |
|
|
958 * slant but gave us one anyway. Try to mitigate. |
|
|
959 */ |
|
|
960 if ((XftPatternGetInteger(f->match->pattern, "slant", 0, |
|
|
961 &haveattr) != XftResultMatch) || haveattr < wantattr) { |
|
|
962 f->badslant = 1; |
|
|
963 fputs("font slant does not match\n", stderr); |
|
|
964 } |
|
|
965 } |
|
|
966 |
|
|
967 if ((XftPatternGetInteger(pattern, "weight", 0, &wantattr) == |
|
|
968 XftResultMatch)) { |
|
|
969 if ((XftPatternGetInteger(f->match->pattern, "weight", 0, |
|
|
970 &haveattr) != XftResultMatch) || haveattr != wantattr) { |
|
|
971 f->badweight = 1; |
|
|
972 fputs("font weight does not match\n", stderr); |
|
|
973 } |
|
|
974 } |
|
|
975 |
|
|
976 XftTextExtentsUtf8(xw.dpy, f->match, |
|
|
977 (const FcChar8 *) ascii_printable, |
|
|
978 strlen(ascii_printable), &extents); |
|
|
979 |
|
|
980 f->set = NULL; |
|
|
981 f->pattern = configured; |
|
|
982 |
|
|
983 f->ascent = f->match->ascent; |
|
|
984 f->descent = f->match->descent; |
|
|
985 f->lbearing = 0; |
|
|
986 f->rbearing = f->match->max_advance_width; |
|
|
987 |
|
|
988 f->height = f->ascent + f->descent; |
|
|
989 f->width = DIVCEIL(extents.xOff, strlen(ascii_printable)); |
|
|
990 |
|
|
991 return 0; |
|
|
992 } |
|
|
993 |
|
|
994 void |
|
|
995 xloadfonts(const char *fontstr, double fontsize) |
|
|
996 { |
|
|
997 FcPattern *pattern; |
|
|
998 double fontval; |
|
|
999 |
|
|
1000 if (fontstr[0] == '-') |
|
|
1001 pattern = XftXlfdParse(fontstr, False, False); |
|
|
1002 else |
|
|
1003 pattern = FcNameParse((const FcChar8 *)fontstr); |
|
|
1004 |
|
|
1005 if (!pattern) |
|
|
1006 die("can't open font %s\n", fontstr); |
|
|
1007 |
|
|
1008 if (fontsize > 1) { |
|
|
1009 FcPatternDel(pattern, FC_PIXEL_SIZE); |
|
|
1010 FcPatternDel(pattern, FC_SIZE); |
|
|
1011 FcPatternAddDouble(pattern, FC_PIXEL_SIZE, (double)fontsize); |
|
|
1012 usedfontsize = fontsize; |
|
|
1013 } else { |
|
|
1014 if (FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &fontval) == |
|
|
1015 FcResultMatch) { |
|
|
1016 usedfontsize = fontval; |
|
|
1017 } else if (FcPatternGetDouble(pattern, FC_SIZE, 0, &fontval) == |
|
|
1018 FcResultMatch) { |
|
|
1019 usedfontsize = -1; |
|
|
1020 } else { |
|
|
1021 /* |
|
|
1022 * Default font size is 12, if none given. This is to |
|
|
1023 * have a known usedfontsize value. |
|
|
1024 */ |
|
|
1025 FcPatternAddDouble(pattern, FC_PIXEL_SIZE, 12); |
|
|
1026 usedfontsize = 12; |
|
|
1027 } |
|
|
1028 defaultfontsize = usedfontsize; |
|
|
1029 } |
|
|
1030 |
|
|
1031 if (xloadfont(&dc.font, pattern)) |
|
|
1032 die("can't open font %s\n", fontstr); |
|
|
1033 |
|
|
1034 if (usedfontsize < 0) { |
|
|
1035 FcPatternGetDouble(dc.font.match->pattern, |
|
|
1036 FC_PIXEL_SIZE, 0, &fontval); |
|
|
1037 usedfontsize = fontval; |
|
|
1038 if (fontsize == 0) |
|
|
1039 defaultfontsize = fontval; |
|
|
1040 } |
|
|
1041 |
|
|
1042 /* Setting character width and height. */ |
|
|
1043 win.cw = ceilf(dc.font.width * cwscale); |
|
|
1044 win.ch = ceilf(dc.font.height * chscale); |
|
|
1045 |
|
|
1046 FcPatternDel(pattern, FC_SLANT); |
|
|
1047 FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC); |
|
|
1048 if (xloadfont(&dc.ifont, pattern)) |
|
|
1049 die("can't open font %s\n", fontstr); |
|
|
1050 |
|
|
1051 FcPatternDel(pattern, FC_WEIGHT); |
|
|
1052 FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD); |
|
|
1053 if (xloadfont(&dc.ibfont, pattern)) |
|
|
1054 die("can't open font %s\n", fontstr); |
|
|
1055 |
|
|
1056 FcPatternDel(pattern, FC_SLANT); |
|
|
1057 FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN); |
|
|
1058 if (xloadfont(&dc.bfont, pattern)) |
|
|
1059 die("can't open font %s\n", fontstr); |
|
|
1060 |
|
|
1061 FcPatternDestroy(pattern); |
|
|
1062 } |
|
|
1063 |
|
|
1064 void |
|
|
1065 xunloadfont(Font *f) |
|
|
1066 { |
|
|
1067 XftFontClose(xw.dpy, f->match); |
|
|
1068 FcPatternDestroy(f->pattern); |
|
|
1069 if (f->set) |
|
|
1070 FcFontSetDestroy(f->set); |
|
|
1071 } |
|
|
1072 |
|
|
1073 void |
|
|
1074 xunloadfonts(void) |
|
|
1075 { |
|
|
1076 /* Free the loaded fonts in the font cache. */ |
|
|
1077 while (frclen > 0) |
|
|
1078 XftFontClose(xw.dpy, frc[--frclen].font); |
|
|
1079 |
|
|
1080 xunloadfont(&dc.font); |
|
|
1081 xunloadfont(&dc.bfont); |
|
|
1082 xunloadfont(&dc.ifont); |
|
|
1083 xunloadfont(&dc.ibfont); |
|
|
1084 } |
|
|
1085 |
|
|
1086 int |
|
|
1087 ximopen(Display *dpy) |
|
|
1088 { |
|
|
1089 XIMCallback imdestroy = { .client_data = NULL, .callback = ximdestroy }; |
|
|
1090 XICCallback icdestroy = { .client_data = NULL, .callback = xicdestroy }; |
|
|
1091 |
|
|
1092 xw.ime.xim = XOpenIM(xw.dpy, NULL, NULL, NULL); |
|
|
1093 if (xw.ime.xim == NULL) |
|
|
1094 return 0; |
|
|
1095 |
|
|
1096 if (XSetIMValues(xw.ime.xim, XNDestroyCallback, &imdestroy, NULL)) |
|
|
1097 fprintf(stderr, "XSetIMValues: " |
|
|
1098 "Could not set XNDestroyCallback.\n"); |
|
|
1099 |
|
|
1100 xw.ime.spotlist = XVaCreateNestedList(0, XNSpotLocation, &xw.ime.spot, |
|
|
1101 NULL); |
|
|
1102 |
|
|
1103 if (xw.ime.xic == NULL) { |
|
|
1104 xw.ime.xic = XCreateIC(xw.ime.xim, XNInputStyle, |
|
|
1105 XIMPreeditNothing | XIMStatusNothing, |
|
|
1106 XNClientWindow, xw.win, |
|
|
1107 XNDestroyCallback, &icdestroy, |
|
|
1108 NULL); |
|
|
1109 } |
|
|
1110 if (xw.ime.xic == NULL) |
|
|
1111 fprintf(stderr, "XCreateIC: Could not create input context.\n"); |
|
|
1112 |
|
|
1113 return 1; |
|
|
1114 } |
|
|
1115 |
|
|
1116 void |
|
|
1117 ximinstantiate(Display *dpy, XPointer client, XPointer call) |
|
|
1118 { |
|
|
1119 if (ximopen(dpy)) |
|
|
1120 XUnregisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL, |
|
|
1121 ximinstantiate, NULL); |
|
|
1122 } |
|
|
1123 |
|
|
1124 void |
|
|
1125 ximdestroy(XIM xim, XPointer client, XPointer call) |
|
|
1126 { |
|
|
1127 xw.ime.xim = NULL; |
|
|
1128 XRegisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL, |
|
|
1129 ximinstantiate, NULL); |
|
|
1130 XFree(xw.ime.spotlist); |
|
|
1131 } |
|
|
1132 |
|
|
1133 int |
|
|
1134 xicdestroy(XIC xim, XPointer client, XPointer call) |
|
|
1135 { |
|
|
1136 xw.ime.xic = NULL; |
|
|
1137 return 1; |
|
|
1138 } |
|
|
1139 |
|
|
1140 void |
|
|
1141 xinit(int cols, int rows) |
|
|
1142 { |
|
|
1143 XGCValues gcvalues; |
|
|
1144 Cursor cursor; |
|
|
1145 Window parent, root; |
|
|
1146 pid_t thispid = getpid(); |
|
|
1147 XColor xmousefg, xmousebg; |
|
|
1148 XWindowAttributes attr; |
|
|
1149 XVisualInfo vis; |
|
|
1150 |
|
|
1151 if (!(xw.dpy = XOpenDisplay(NULL))) |
|
|
1152 die("can't open display\n"); |
|
|
1153 xw.scr = XDefaultScreen(xw.dpy); |
|
|
1154 |
|
|
1155 root = XRootWindow(xw.dpy, xw.scr); |
|
|
1156 if (!(opt_embed && (parent = strtol(opt_embed, NULL, 0)))) |
|
|
1157 parent = root; |
|
|
1158 |
|
|
1159 if (XMatchVisualInfo(xw.dpy, xw.scr, 32, TrueColor, &vis) != 0) { |
|
|
1160 xw.vis = vis.visual; |
|
|
1161 xw.depth = vis.depth; |
|
|
1162 } else { |
|
|
1163 XGetWindowAttributes(xw.dpy, parent, &attr); |
|
|
1164 xw.vis = attr.visual; |
|
|
1165 xw.depth = attr.depth; |
|
|
1166 } |
|
|
1167 |
|
|
1168 /* font */ |
|
|
1169 if (!FcInit()) |
|
|
1170 die("could not init fontconfig.\n"); |
|
|
1171 |
|
|
1172 usedfont = (opt_font == NULL)? font : opt_font; |
|
|
1173 xloadfonts(usedfont, 0); |
|
|
1174 |
|
|
1175 /* colors */ |
|
|
1176 xw.cmap = XCreateColormap(xw.dpy, parent, xw.vis, None); |
|
|
1177 xloadcols(); |
|
|
1178 |
|
|
1179 /* adjust fixed window geometry */ |
|
|
1180 win.w = 2 * borderpx + cols * win.cw; |
|
|
1181 win.h = 2 * borderpx + rows * win.ch; |
|
|
1182 if (xw.gm & XNegative) |
|
|
1183 xw.l += DisplayWidth(xw.dpy, xw.scr) - win.w - 2; |
|
|
1184 if (xw.gm & YNegative) |
|
|
1185 xw.t += DisplayHeight(xw.dpy, xw.scr) - win.h - 2; |
|
|
1186 |
|
|
1187 /* Events */ |
|
|
1188 xw.attrs.background_pixel = dc.col[defaultbg].pixel; |
|
|
1189 xw.attrs.border_pixel = dc.col[defaultbg].pixel; |
|
|
1190 xw.attrs.bit_gravity = NorthWestGravity; |
|
|
1191 xw.attrs.event_mask = FocusChangeMask | KeyPressMask | KeyReleaseMask |
|
|
1192 | ExposureMask | VisibilityChangeMask | StructureNotifyMask |
|
|
1193 | ButtonMotionMask | ButtonPressMask | ButtonReleaseMask; |
|
|
1194 xw.attrs.colormap = xw.cmap; |
|
|
1195 |
|
|
1196 xw.win = XCreateWindow(xw.dpy, parent, xw.l, xw.t, |
|
|
1197 win.w, win.h, 0, xw.depth, InputOutput, |
|
|
1198 xw.vis, CWBackPixel | CWBorderPixel | CWBitGravity |
|
|
1199 | CWEventMask | CWColormap, &xw.attrs); |
|
|
1200 if (parent != root) |
|
|
1201 XReparentWindow(xw.dpy, xw.win, parent, xw.l, xw.t); |
|
|
1202 |
|
|
1203 memset(&gcvalues, 0, sizeof(gcvalues)); |
|
|
1204 gcvalues.graphics_exposures = False; |
|
|
1205 dc.gc = XCreateGC(xw.dpy, xw.win, GCGraphicsExposures, |
|
|
1206 &gcvalues); |
|
|
1207 xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h, |
|
|
1208 xw.depth); |
|
|
1209 XSetForeground(xw.dpy, dc.gc, dc.col[defaultbg].pixel); |
|
|
1210 XFillRectangle(xw.dpy, xw.buf, dc.gc, 0, 0, win.w, win.h); |
|
|
1211 |
|
|
1212 /* font spec buffer */ |
|
|
1213 xw.specbuf = xmalloc(cols * sizeof(GlyphFontSpec)); |
|
|
1214 |
|
|
1215 /* Xft rendering context */ |
|
|
1216 xw.draw = XftDrawCreate(xw.dpy, xw.buf, xw.vis, xw.cmap); |
|
|
1217 |
|
|
1218 /* input methods */ |
|
|
1219 if (!ximopen(xw.dpy)) { |
|
|
1220 XRegisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL, |
|
|
1221 ximinstantiate, NULL); |
|
|
1222 } |
|
|
1223 |
|
|
1224 /* white cursor, black outline */ |
|
|
1225 cursor = XCreateFontCursor(xw.dpy, mouseshape); |
|
|
1226 XDefineCursor(xw.dpy, xw.win, cursor); |
|
|
1227 |
|
|
1228 if (XParseColor(xw.dpy, xw.cmap, colorname[mousefg], &xmousefg) == 0) { |
|
|
1229 xmousefg.red = 0xffff; |
|
|
1230 xmousefg.green = 0xffff; |
|
|
1231 xmousefg.blue = 0xffff; |
|
|
1232 } |
|
|
1233 |
|
|
1234 if (XParseColor(xw.dpy, xw.cmap, colorname[mousebg], &xmousebg) == 0) { |
|
|
1235 xmousebg.red = 0x0000; |
|
|
1236 xmousebg.green = 0x0000; |
|
|
1237 xmousebg.blue = 0x0000; |
|
|
1238 } |
|
|
1239 |
|
|
1240 XRecolorCursor(xw.dpy, cursor, &xmousefg, &xmousebg); |
|
|
1241 |
|
|
1242 xw.xembed = XInternAtom(xw.dpy, "_XEMBED", False); |
|
|
1243 xw.wmdeletewin = XInternAtom(xw.dpy, "WM_DELETE_WINDOW", False); |
|
|
1244 xw.netwmname = XInternAtom(xw.dpy, "_NET_WM_NAME", False); |
|
|
1245 xw.netwmiconname = XInternAtom(xw.dpy, "_NET_WM_ICON_NAME", False); |
|
|
1246 XSetWMProtocols(xw.dpy, xw.win, &xw.wmdeletewin, 1); |
|
|
1247 |
|
|
1248 xw.netwmpid = XInternAtom(xw.dpy, "_NET_WM_PID", False); |
|
|
1249 XChangeProperty(xw.dpy, xw.win, xw.netwmpid, XA_CARDINAL, 32, |
|
|
1250 PropModeReplace, (uchar *)&thispid, 1); |
|
|
1251 |
|
|
1252 win.mode = MODE_NUMLOCK; |
|
|
1253 resettitle(); |
|
|
1254 xhints(); |
|
|
1255 XMapWindow(xw.dpy, xw.win); |
|
|
1256 XSync(xw.dpy, False); |
|
|
1257 |
|
|
1258 clock_gettime(CLOCK_MONOTONIC, &xsel.tclick1); |
|
|
1259 clock_gettime(CLOCK_MONOTONIC, &xsel.tclick2); |
|
|
1260 xsel.primary = NULL; |
|
|
1261 xsel.clipboard = NULL; |
|
|
1262 xsel.xtarget = XInternAtom(xw.dpy, "UTF8_STRING", 0); |
|
|
1263 if (xsel.xtarget == None) |
|
|
1264 xsel.xtarget = XA_STRING; |
|
|
1265 } |
|
|
1266 |
|
|
1267 int |
|
|
1268 xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x, int y) |
|
|
1269 { |
|
|
1270 float winx = borderpx + x * win.cw, winy = borderpx + y * win.ch, xp, yp; |
|
|
1271 ushort mode, prevmode = USHRT_MAX; |
|
|
1272 Font *font = &dc.font; |
|
|
1273 int frcflags = FRC_NORMAL; |
|
|
1274 float runewidth = win.cw; |
|
|
1275 Rune rune; |
|
|
1276 FT_UInt glyphidx; |
|
|
1277 FcResult fcres; |
|
|
1278 FcPattern *fcpattern, *fontpattern; |
|
|
1279 FcFontSet *fcsets[] = { NULL }; |
|
|
1280 FcCharSet *fccharset; |
|
|
1281 int i, f, numspecs = 0; |
|
|
1282 |
|
|
1283 for (i = 0, xp = winx, yp = winy + font->ascent; i < len; ++i) { |
|
|
1284 /* Fetch rune and mode for current glyph. */ |
|
|
1285 rune = glyphs[i].u; |
|
|
1286 mode = glyphs[i].mode; |
|
|
1287 |
|
|
1288 /* Skip dummy wide-character spacing. */ |
|
|
1289 if (mode == ATTR_WDUMMY) |
|
|
1290 continue; |
|
|
1291 |
|
|
1292 /* Determine font for glyph if different from previous glyph. */ |
|
|
1293 if (prevmode != mode) { |
|
|
1294 prevmode = mode; |
|
|
1295 font = &dc.font; |
|
|
1296 frcflags = FRC_NORMAL; |
|
|
1297 runewidth = win.cw * ((mode & ATTR_WIDE) ? 2.0f : 1.0f); |
|
|
1298 if ((mode & ATTR_ITALIC) && (mode & ATTR_BOLD)) { |
|
|
1299 font = &dc.ibfont; |
|
|
1300 frcflags = FRC_ITALICBOLD; |
|
|
1301 } else if (mode & ATTR_ITALIC) { |
|
|
1302 font = &dc.ifont; |
|
|
1303 frcflags = FRC_ITALIC; |
|
|
1304 } else if (mode & ATTR_BOLD) { |
|
|
1305 font = &dc.bfont; |
|
|
1306 frcflags = FRC_BOLD; |
|
|
1307 } |
|
|
1308 yp = winy + font->ascent; |
|
|
1309 } |
|
|
1310 |
|
|
1311 /* Lookup character index with default font. */ |
|
|
1312 glyphidx = XftCharIndex(xw.dpy, font->match, rune); |
|
|
1313 if (glyphidx) { |
|
|
1314 specs[numspecs].font = font->match; |
|
|
1315 specs[numspecs].glyph = glyphidx; |
|
|
1316 specs[numspecs].x = (short)xp; |
|
|
1317 specs[numspecs].y = (short)yp; |
|
|
1318 xp += runewidth; |
|
|
1319 numspecs++; |
|
|
1320 continue; |
|
|
1321 } |
|
|
1322 |
|
|
1323 /* Fallback on font cache, search the font cache for match. */ |
|
|
1324 for (f = 0; f < frclen; f++) { |
|
|
1325 glyphidx = XftCharIndex(xw.dpy, frc[f].font, rune); |
|
|
1326 /* Everything correct. */ |
|
|
1327 if (glyphidx && frc[f].flags == frcflags) |
|
|
1328 break; |
|
|
1329 /* We got a default font for a not found glyph. */ |
|
|
1330 if (!glyphidx && frc[f].flags == frcflags |
|
|
1331 && frc[f].unicodep == rune) { |
|
|
1332 break; |
|
|
1333 } |
|
|
1334 } |
|
|
1335 |
|
|
1336 /* Nothing was found. Use fontconfig to find matching font. */ |
|
|
1337 if (f >= frclen) { |
|
|
1338 if (!font->set) |
|
|
1339 font->set = FcFontSort(0, font->pattern, |
|
|
1340 1, 0, &fcres); |
|
|
1341 fcsets[0] = font->set; |
|
|
1342 |
|
|
1343 /* |
|
|
1344 * Nothing was found in the cache. Now use |
|
|
1345 * some dozen of Fontconfig calls to get the |
|
|
1346 * font for one single character. |
|
|
1347 * |
|
|
1348 * Xft and fontconfig are design failures. |
|
|
1349 */ |
|
|
1350 fcpattern = FcPatternDuplicate(font->pattern); |
|
|
1351 fccharset = FcCharSetCreate(); |
|
|
1352 |
|
|
1353 FcCharSetAddChar(fccharset, rune); |
|
|
1354 FcPatternAddCharSet(fcpattern, FC_CHARSET, |
|
|
1355 fccharset); |
|
|
1356 FcPatternAddBool(fcpattern, FC_SCALABLE, 1); |
|
|
1357 |
|
|
1358 FcConfigSubstitute(0, fcpattern, |
|
|
1359 FcMatchPattern); |
|
|
1360 FcDefaultSubstitute(fcpattern); |
|
|
1361 |
|
|
1362 fontpattern = FcFontSetMatch(0, fcsets, 1, |
|
|
1363 fcpattern, &fcres); |
|
|
1364 |
|
|
1365 /* Allocate memory for the new cache entry. */ |
|
|
1366 if (frclen >= frccap) { |
|
|
1367 frccap += 16; |
|
|
1368 frc = xrealloc(frc, frccap * sizeof(Fontcache)); |
|
|
1369 } |
|
|
1370 |
|
|
1371 frc[frclen].font = XftFontOpenPattern(xw.dpy, |
|
|
1372 fontpattern); |
|
|
1373 if (!frc[frclen].font) |
|
|
1374 die("XftFontOpenPattern failed seeking fallback font: %s\n", |
|
|
1375 strerror(errno)); |
|
|
1376 frc[frclen].flags = frcflags; |
|
|
1377 frc[frclen].unicodep = rune; |
|
|
1378 |
|
|
1379 glyphidx = XftCharIndex(xw.dpy, frc[frclen].font, rune); |
|
|
1380 |
|
|
1381 f = frclen; |
|
|
1382 frclen++; |
|
|
1383 |
|
|
1384 FcPatternDestroy(fcpattern); |
|
|
1385 FcCharSetDestroy(fccharset); |
|
|
1386 } |
|
|
1387 |
|
|
1388 specs[numspecs].font = frc[f].font; |
|
|
1389 specs[numspecs].glyph = glyphidx; |
|
|
1390 specs[numspecs].x = (short)xp; |
|
|
1391 specs[numspecs].y = (short)yp; |
|
|
1392 xp += runewidth; |
|
|
1393 numspecs++; |
|
|
1394 } |
|
|
1395 |
|
|
1396 return numspecs; |
|
|
1397 } |
|
|
1398 |
|
|
1399 void |
|
|
1400 xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, int y) |
|
|
1401 { |
|
|
1402 int charlen = len * ((base.mode & ATTR_WIDE) ? 2 : 1); |
|
|
1403 int winx = borderpx + x * win.cw, winy = borderpx + y * win.ch, |
|
|
1404 width = charlen * win.cw; |
|
|
1405 Color *fg, *bg, *temp, revfg, revbg, truefg, truebg; |
|
|
1406 XRenderColor colfg, colbg; |
|
|
1407 XRectangle r; |
|
|
1408 |
|
|
1409 /* Fallback on color display for attributes not supported by the font */ |
|
|
1410 if (base.mode & ATTR_ITALIC && base.mode & ATTR_BOLD) { |
|
|
1411 if (dc.ibfont.badslant || dc.ibfont.badweight) |
|
|
1412 base.fg = defaultattr; |
|
|
1413 } else if ((base.mode & ATTR_ITALIC && dc.ifont.badslant) || |
|
|
1414 (base.mode & ATTR_BOLD && dc.bfont.badweight)) { |
|
|
1415 base.fg = defaultattr; |
|
|
1416 } |
|
|
1417 |
|
|
1418 if (IS_TRUECOL(base.fg)) { |
|
|
1419 colfg.alpha = 0xffff; |
|
|
1420 colfg.red = TRUERED(base.fg); |
|
|
1421 colfg.green = TRUEGREEN(base.fg); |
|
|
1422 colfg.blue = TRUEBLUE(base.fg); |
|
|
1423 XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colfg, &truefg); |
|
|
1424 fg = &truefg; |
|
|
1425 } else { |
|
|
1426 fg = &dc.col[base.fg]; |
|
|
1427 } |
|
|
1428 |
|
|
1429 if (IS_TRUECOL(base.bg)) { |
|
|
1430 colbg.alpha = 0xffff; |
|
|
1431 colbg.green = TRUEGREEN(base.bg); |
|
|
1432 colbg.red = TRUERED(base.bg); |
|
|
1433 colbg.blue = TRUEBLUE(base.bg); |
|
|
1434 XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colbg, &truebg); |
|
|
1435 bg = &truebg; |
|
|
1436 } else { |
|
|
1437 bg = &dc.col[base.bg]; |
|
|
1438 } |
|
|
1439 |
|
|
1440 /* Change basic system colors [0-7] to bright system colors [8-15] */ |
|
|
1441 if ((base.mode & ATTR_BOLD_FAINT) == ATTR_BOLD && BETWEEN(base.fg, 0, 7)) |
|
|
1442 fg = &dc.col[base.fg + 8]; |
|
|
1443 |
|
|
1444 if (IS_SET(MODE_REVERSE)) { |
|
|
1445 if (fg == &dc.col[defaultfg]) { |
|
|
1446 fg = &dc.col[defaultbg]; |
|
|
1447 } else { |
|
|
1448 colfg.red = ~fg->color.red; |
|
|
1449 colfg.green = ~fg->color.green; |
|
|
1450 colfg.blue = ~fg->color.blue; |
|
|
1451 colfg.alpha = fg->color.alpha; |
|
|
1452 XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colfg, |
|
|
1453 &revfg); |
|
|
1454 fg = &revfg; |
|
|
1455 } |
|
|
1456 |
|
|
1457 if (bg == &dc.col[defaultbg]) { |
|
|
1458 bg = &dc.col[defaultfg]; |
|
|
1459 } else { |
|
|
1460 colbg.red = ~bg->color.red; |
|
|
1461 colbg.green = ~bg->color.green; |
|
|
1462 colbg.blue = ~bg->color.blue; |
|
|
1463 colbg.alpha = bg->color.alpha; |
|
|
1464 XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colbg, |
|
|
1465 &revbg); |
|
|
1466 bg = &revbg; |
|
|
1467 } |
|
|
1468 } |
|
|
1469 |
|
|
1470 if ((base.mode & ATTR_BOLD_FAINT) == ATTR_FAINT) { |
|
|
1471 colfg.red = fg->color.red / 2; |
|
|
1472 colfg.green = fg->color.green / 2; |
|
|
1473 colfg.blue = fg->color.blue / 2; |
|
|
1474 colfg.alpha = fg->color.alpha; |
|
|
1475 XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colfg, &revfg); |
|
|
1476 fg = &revfg; |
|
|
1477 } |
|
|
1478 |
|
|
1479 if (base.mode & ATTR_REVERSE) { |
|
|
1480 temp = fg; |
|
|
1481 fg = bg; |
|
|
1482 bg = temp; |
|
|
1483 } |
|
|
1484 |
|
|
1485 if (base.mode & ATTR_BLINK && win.mode & MODE_BLINK) |
|
|
1486 fg = bg; |
|
|
1487 |
|
|
1488 if (base.mode & ATTR_INVISIBLE) |
|
|
1489 fg = bg; |
|
|
1490 |
|
|
1491 /* Intelligent cleaning up of the borders. */ |
|
|
1492 if (x == 0) { |
|
|
1493 xclear(0, (y == 0)? 0 : winy, borderpx, |
|
|
1494 winy + win.ch + |
|
|
1495 ((winy + win.ch >= borderpx + win.th)? win.h : 0)); |
|
|
1496 } |
|
|
1497 if (winx + width >= borderpx + win.tw) { |
|
|
1498 xclear(winx + width, (y == 0)? 0 : winy, win.w, |
|
|
1499 ((winy + win.ch >= borderpx + win.th)? win.h : (winy + win.ch))); |
|
|
1500 } |
|
|
1501 if (y == 0) |
|
|
1502 xclear(winx, 0, winx + width, borderpx); |
|
|
1503 if (winy + win.ch >= borderpx + win.th) |
|
|
1504 xclear(winx, winy + win.ch, winx + width, win.h); |
|
|
1505 |
|
|
1506 /* Clean up the region we want to draw to. */ |
|
|
1507 XftDrawRect(xw.draw, bg, winx, winy, width, win.ch); |
|
|
1508 |
|
|
1509 /* Set the clip region because Xft is sometimes dirty. */ |
|
|
1510 r.x = 0; |
|
|
1511 r.y = 0; |
|
|
1512 r.height = win.ch; |
|
|
1513 r.width = width; |
|
|
1514 XftDrawSetClipRectangles(xw.draw, winx, winy, &r, 1); |
|
|
1515 |
|
|
1516 /* Render the glyphs. */ |
|
|
1517 XftDrawGlyphFontSpec(xw.draw, fg, specs, len); |
|
|
1518 |
|
|
1519 /* Render underline and strikethrough. */ |
|
|
1520 if (base.mode & ATTR_UNDERLINE) { |
|
|
1521 XftDrawRect(xw.draw, fg, winx, winy + dc.font.ascent * chscale + 1, |
|
|
1522 width, 1); |
|
|
1523 } |
|
|
1524 |
|
|
1525 if (base.mode & ATTR_STRUCK) { |
|
|
1526 XftDrawRect(xw.draw, fg, winx, winy + 2 * dc.font.ascent * chscale / 3, |
|
|
1527 width, 1); |
|
|
1528 } |
|
|
1529 |
|
|
1530 /* Reset clip to none. */ |
|
|
1531 XftDrawSetClip(xw.draw, 0); |
|
|
1532 } |
|
|
1533 |
|
|
1534 void |
|
|
1535 xdrawglyph(Glyph g, int x, int y) |
|
|
1536 { |
|
|
1537 int numspecs; |
|
|
1538 XftGlyphFontSpec spec; |
|
|
1539 |
|
|
1540 numspecs = xmakeglyphfontspecs(&spec, &g, 1, x, y); |
|
|
1541 xdrawglyphfontspecs(&spec, g, numspecs, x, y); |
|
|
1542 } |
|
|
1543 |
|
|
1544 void |
|
|
1545 xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og) |
|
|
1546 { |
|
|
1547 Color drawcol; |
|
|
1548 |
|
|
1549 /* remove the old cursor */ |
|
|
1550 if (selected(ox, oy)) |
|
|
1551 og.mode ^= ATTR_REVERSE; |
|
|
1552 xdrawglyph(og, ox, oy); |
|
|
1553 |
|
|
1554 if (IS_SET(MODE_HIDE)) |
|
|
1555 return; |
|
|
1556 |
|
|
1557 /* |
|
|
1558 * Select the right color for the right mode. |
|
|
1559 */ |
|
|
1560 g.mode &= ATTR_BOLD|ATTR_ITALIC|ATTR_UNDERLINE|ATTR_STRUCK|ATTR_WIDE; |
|
|
1561 |
|
|
1562 if (IS_SET(MODE_REVERSE)) { |
|
|
1563 g.mode |= ATTR_REVERSE; |
|
|
1564 g.bg = defaultfg; |
|
|
1565 if (selected(cx, cy)) { |
|
|
1566 drawcol = dc.col[defaultcs]; |
|
|
1567 g.fg = defaultrcs; |
|
|
1568 } else { |
|
|
1569 drawcol = dc.col[defaultrcs]; |
|
|
1570 g.fg = defaultcs; |
|
|
1571 } |
|
|
1572 } else { |
|
|
1573 if (selected(cx, cy)) { |
|
|
1574 g.fg = defaultfg; |
|
|
1575 g.bg = defaultrcs; |
|
|
1576 } else { |
|
|
1577 g.fg = defaultbg; |
|
|
1578 g.bg = defaultcs; |
|
|
1579 } |
|
|
1580 drawcol = dc.col[g.bg]; |
|
|
1581 } |
|
|
1582 |
|
|
1583 /* draw the new one */ |
|
|
1584 if (IS_SET(MODE_FOCUSED)) { |
|
|
1585 switch (win.cursor) { |
|
|
1586 case 7: /* st extension */ |
|
|
1587 g.u = 0x2603; /* snowman (U+2603) */ |
|
|
1588 /* FALLTHROUGH */ |
|
|
1589 case 0: /* Blinking Block */ |
|
|
1590 case 1: /* Blinking Block (Default) */ |
|
|
1591 case 2: /* Steady Block */ |
|
|
1592 xdrawglyph(g, cx, cy); |
|
|
1593 break; |
|
|
1594 case 3: /* Blinking Underline */ |
|
|
1595 case 4: /* Steady Underline */ |
|
|
1596 XftDrawRect(xw.draw, &drawcol, |
|
|
1597 borderpx + cx * win.cw, |
|
|
1598 borderpx + (cy + 1) * win.ch - \ |
|
|
1599 cursorthickness, |
|
|
1600 win.cw, cursorthickness); |
|
|
1601 break; |
|
|
1602 case 5: /* Blinking bar */ |
|
|
1603 case 6: /* Steady bar */ |
|
|
1604 XftDrawRect(xw.draw, &drawcol, |
|
|
1605 borderpx + cx * win.cw, |
|
|
1606 borderpx + cy * win.ch, |
|
|
1607 cursorthickness, win.ch); |
|
|
1608 break; |
|
|
1609 } |
|
|
1610 } else { |
|
|
1611 XftDrawRect(xw.draw, &drawcol, |
|
|
1612 borderpx + cx * win.cw, |
|
|
1613 borderpx + cy * win.ch, |
|
|
1614 win.cw - 1, 1); |
|
|
1615 XftDrawRect(xw.draw, &drawcol, |
|
|
1616 borderpx + cx * win.cw, |
|
|
1617 borderpx + cy * win.ch, |
|
|
1618 1, win.ch - 1); |
|
|
1619 XftDrawRect(xw.draw, &drawcol, |
|
|
1620 borderpx + (cx + 1) * win.cw - 1, |
|
|
1621 borderpx + cy * win.ch, |
|
|
1622 1, win.ch - 1); |
|
|
1623 XftDrawRect(xw.draw, &drawcol, |
|
|
1624 borderpx + cx * win.cw, |
|
|
1625 borderpx + (cy + 1) * win.ch - 1, |
|
|
1626 win.cw, 1); |
|
|
1627 } |
|
|
1628 } |
|
|
1629 |
|
|
1630 void |
|
|
1631 xsetenv(void) |
|
|
1632 { |
|
|
1633 char buf[sizeof(long) * 8 + 1]; |
|
|
1634 |
|
|
1635 snprintf(buf, sizeof(buf), "%lu", xw.win); |
|
|
1636 setenv("WINDOWID", buf, 1); |
|
|
1637 } |
|
|
1638 |
|
|
1639 void |
|
|
1640 xseticontitle(char *p) |
|
|
1641 { |
|
|
1642 XTextProperty prop; |
|
|
1643 DEFAULT(p, opt_title); |
|
|
1644 |
|
|
1645 if (p[0] == '\0') |
|
|
1646 p = opt_title; |
|
|
1647 |
|
|
1648 if (Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle, |
|
|
1649 &prop) != Success) |
|
|
1650 return; |
|
|
1651 XSetWMIconName(xw.dpy, xw.win, &prop); |
|
|
1652 XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmiconname); |
|
|
1653 XFree(prop.value); |
|
|
1654 } |
|
|
1655 |
|
|
1656 void |
|
|
1657 xsettitle(char *p) |
|
|
1658 { |
|
|
1659 XTextProperty prop; |
|
|
1660 DEFAULT(p, opt_title); |
|
|
1661 |
|
|
1662 if (p[0] == '\0') |
|
|
1663 p = opt_title; |
|
|
1664 |
|
|
1665 if (Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle, |
|
|
1666 &prop) != Success) |
|
|
1667 return; |
|
|
1668 XSetWMName(xw.dpy, xw.win, &prop); |
|
|
1669 XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmname); |
|
|
1670 XFree(prop.value); |
|
|
1671 } |
|
|
1672 |
|
|
1673 int |
|
|
1674 xstartdraw(void) |
|
|
1675 { |
|
|
1676 return IS_SET(MODE_VISIBLE); |
|
|
1677 } |
|
|
1678 |
|
|
1679 void |
|
|
1680 xdrawline(Line line, int x1, int y1, int x2) |
|
|
1681 { |
|
|
1682 int i, x, ox, numspecs; |
|
|
1683 Glyph base, new; |
|
|
1684 XftGlyphFontSpec *specs = xw.specbuf; |
|
|
1685 |
|
|
1686 numspecs = xmakeglyphfontspecs(specs, &line[x1], x2 - x1, x1, y1); |
|
|
1687 i = ox = 0; |
|
|
1688 for (x = x1; x < x2 && i < numspecs; x++) { |
|
|
1689 new = line[x]; |
|
|
1690 if (new.mode == ATTR_WDUMMY) |
|
|
1691 continue; |
|
|
1692 if (selected(x, y1)) |
|
|
1693 new.mode ^= ATTR_REVERSE; |
|
|
1694 if (i > 0 && ATTRCMP(base, new)) { |
|
|
1695 xdrawglyphfontspecs(specs, base, i, ox, y1); |
|
|
1696 specs += i; |
|
|
1697 numspecs -= i; |
|
|
1698 i = 0; |
|
|
1699 } |
|
|
1700 if (i == 0) { |
|
|
1701 ox = x; |
|
|
1702 base = new; |
|
|
1703 } |
|
|
1704 i++; |
|
|
1705 } |
|
|
1706 if (i > 0) |
|
|
1707 xdrawglyphfontspecs(specs, base, i, ox, y1); |
|
|
1708 } |
|
|
1709 |
|
|
1710 void |
|
|
1711 xfinishdraw(void) |
|
|
1712 { |
|
|
1713 XCopyArea(xw.dpy, xw.buf, xw.win, dc.gc, 0, 0, win.w, |
|
|
1714 win.h, 0, 0); |
|
|
1715 XSetForeground(xw.dpy, dc.gc, |
|
|
1716 dc.col[IS_SET(MODE_REVERSE)? |
|
|
1717 defaultfg : defaultbg].pixel); |
|
|
1718 } |
|
|
1719 |
|
|
1720 void |
|
|
1721 xximspot(int x, int y) |
|
|
1722 { |
|
|
1723 if (xw.ime.xic == NULL) |
|
|
1724 return; |
|
|
1725 |
|
|
1726 xw.ime.spot.x = borderpx + x * win.cw; |
|
|
1727 xw.ime.spot.y = borderpx + (y + 1) * win.ch; |
|
|
1728 |
|
|
1729 XSetICValues(xw.ime.xic, XNPreeditAttributes, xw.ime.spotlist, NULL); |
|
|
1730 } |
|
|
1731 |
|
|
1732 void |
|
|
1733 expose(XEvent *ev) |
|
|
1734 { |
|
|
1735 redraw(); |
|
|
1736 } |
|
|
1737 |
|
|
1738 void |
|
|
1739 visibility(XEvent *ev) |
|
|
1740 { |
|
|
1741 XVisibilityEvent *e = &ev->xvisibility; |
|
|
1742 |
|
|
1743 MODBIT(win.mode, e->state != VisibilityFullyObscured, MODE_VISIBLE); |
|
|
1744 } |
|
|
1745 |
|
|
1746 void |
|
|
1747 unmap(XEvent *ev) |
|
|
1748 { |
|
|
1749 win.mode &= ~MODE_VISIBLE; |
|
|
1750 } |
|
|
1751 |
|
|
1752 void |
|
|
1753 xsetpointermotion(int set) |
|
|
1754 { |
|
|
1755 MODBIT(xw.attrs.event_mask, set, PointerMotionMask); |
|
|
1756 XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, &xw.attrs); |
|
|
1757 } |
|
|
1758 |
|
|
1759 void |
|
|
1760 xsetmode(int set, unsigned int flags) |
|
|
1761 { |
|
|
1762 int mode = win.mode; |
|
|
1763 MODBIT(win.mode, set, flags); |
|
|
1764 if ((win.mode & MODE_REVERSE) != (mode & MODE_REVERSE)) |
|
|
1765 redraw(); |
|
|
1766 } |
|
|
1767 |
|
|
1768 int |
|
|
1769 xsetcursor(int cursor) |
|
|
1770 { |
|
|
1771 if (!BETWEEN(cursor, 0, 7)) /* 7: st extension */ |
|
|
1772 return 1; |
|
|
1773 win.cursor = cursor; |
|
|
1774 return 0; |
|
|
1775 } |
|
|
1776 |
|
|
1777 void |
|
|
1778 xseturgency(int add) |
|
|
1779 { |
|
|
1780 XWMHints *h = XGetWMHints(xw.dpy, xw.win); |
|
|
1781 |
|
|
1782 MODBIT(h->flags, add, XUrgencyHint); |
|
|
1783 XSetWMHints(xw.dpy, xw.win, h); |
|
|
1784 XFree(h); |
|
|
1785 } |
|
|
1786 |
|
|
1787 void |
|
|
1788 xbell(void) |
|
|
1789 { |
|
|
1790 if (!(IS_SET(MODE_FOCUSED))) |
|
|
1791 xseturgency(1); |
|
|
1792 if (bellvolume) |
|
|
1793 XkbBell(xw.dpy, xw.win, bellvolume, (Atom)NULL); |
|
|
1794 } |
|
|
1795 |
|
|
1796 void |
|
|
1797 focus(XEvent *ev) |
|
|
1798 { |
|
|
1799 XFocusChangeEvent *e = &ev->xfocus; |
|
|
1800 |
|
|
1801 if (e->mode == NotifyGrab) |
|
|
1802 return; |
|
|
1803 |
|
|
1804 if (ev->type == FocusIn) { |
|
|
1805 if (xw.ime.xic) |
|
|
1806 XSetICFocus(xw.ime.xic); |
|
|
1807 win.mode |= MODE_FOCUSED; |
|
|
1808 xseturgency(0); |
|
|
1809 if (IS_SET(MODE_FOCUS)) |
|
|
1810 ttywrite("\033[I", 3, 0); |
|
|
1811 } else { |
|
|
1812 if (xw.ime.xic) |
|
|
1813 XUnsetICFocus(xw.ime.xic); |
|
|
1814 win.mode &= ~MODE_FOCUSED; |
|
|
1815 if (IS_SET(MODE_FOCUS)) |
|
|
1816 ttywrite("\033[O", 3, 0); |
|
|
1817 } |
|
|
1818 } |
|
|
1819 |
|
|
1820 int |
|
|
1821 match(uint mask, uint state) |
|
|
1822 { |
|
|
1823 return mask == XK_ANY_MOD || mask == (state & ~ignoremod); |
|
|
1824 } |
|
|
1825 |
|
|
1826 char* |
|
|
1827 kmap(KeySym k, uint state) |
|
|
1828 { |
|
|
1829 Key *kp; |
|
|
1830 int i; |
|
|
1831 |
|
|
1832 /* Check for mapped keys out of X11 function keys. */ |
|
|
1833 for (i = 0; i < LEN(mappedkeys); i++) { |
|
|
1834 if (mappedkeys[i] == k) |
|
|
1835 break; |
|
|
1836 } |
|
|
1837 if (i == LEN(mappedkeys)) { |
|
|
1838 if ((k & 0xFFFF) < 0xFD00) |
|
|
1839 return NULL; |
|
|
1840 } |
|
|
1841 |
|
|
1842 for (kp = key; kp < key + LEN(key); kp++) { |
|
|
1843 if (kp->k != k) |
|
|
1844 continue; |
|
|
1845 |
|
|
1846 if (!match(kp->mask, state)) |
|
|
1847 continue; |
|
|
1848 |
|
|
1849 if (IS_SET(MODE_APPKEYPAD) ? kp->appkey < 0 : kp->appkey > 0) |
|
|
1850 continue; |
|
|
1851 if (IS_SET(MODE_NUMLOCK) && kp->appkey == 2) |
|
|
1852 continue; |
|
|
1853 |
|
|
1854 if (IS_SET(MODE_APPCURSOR) ? kp->appcursor < 0 : kp->appcursor > 0) |
|
|
1855 continue; |
|
|
1856 |
|
|
1857 return kp->s; |
|
|
1858 } |
|
|
1859 |
|
|
1860 return NULL; |
|
|
1861 } |
|
|
1862 |
|
|
1863 void |
|
|
1864 kpress(XEvent *ev) |
|
|
1865 { |
|
|
1866 XKeyEvent *e = &ev->xkey; |
|
|
1867 KeySym ksym = NoSymbol; |
|
|
1868 char buf[64], *customkey; |
|
|
1869 int len; |
|
|
1870 Rune c; |
|
|
1871 Status status; |
|
|
1872 Shortcut *bp; |
|
|
1873 |
|
|
1874 if (IS_SET(MODE_KBDLOCK)) |
|
|
1875 return; |
|
|
1876 |
|
|
1877 if (xw.ime.xic) { |
|
|
1878 len = XmbLookupString(xw.ime.xic, e, buf, sizeof buf, &ksym, &status); |
|
|
1879 if (status == XBufferOverflow) |
|
|
1880 return; |
|
|
1881 } else { |
|
|
1882 len = XLookupString(e, buf, sizeof buf, &ksym, NULL); |
|
|
1883 } |
|
|
1884 /* 1. shortcuts */ |
|
|
1885 for (bp = shortcuts; bp < shortcuts + LEN(shortcuts); bp++) { |
|
|
1886 if (ksym == bp->keysym && match(bp->mod, e->state)) { |
|
|
1887 bp->func(&(bp->arg)); |
|
|
1888 return; |
|
|
1889 } |
|
|
1890 } |
|
|
1891 |
|
|
1892 /* 2. custom keys from config.h */ |
|
|
1893 if ((customkey = kmap(ksym, e->state))) { |
|
|
1894 ttywrite(customkey, strlen(customkey), 1); |
|
|
1895 return; |
|
|
1896 } |
|
|
1897 |
|
|
1898 /* 3. composed string from input method */ |
|
|
1899 if (len == 0) |
|
|
1900 return; |
|
|
1901 if (len == 1 && e->state & Mod1Mask) { |
|
|
1902 if (IS_SET(MODE_8BIT)) { |
|
|
1903 if (*buf < 0177) { |
|
|
1904 c = *buf | 0x80; |
|
|
1905 len = utf8encode(c, buf); |
|
|
1906 } |
|
|
1907 } else { |
|
|
1908 buf[1] = buf[0]; |
|
|
1909 buf[0] = '\033'; |
|
|
1910 len = 2; |
|
|
1911 } |
|
|
1912 } |
|
|
1913 ttywrite(buf, len, 1); |
|
|
1914 } |
|
|
1915 |
|
|
1916 void |
|
|
1917 cmessage(XEvent *e) |
|
|
1918 { |
|
|
1919 /* |
|
|
1920 * See xembed specs |
|
|
1921 * http://standards.freedesktop.org/xembed-spec/xembed-spec-latest.html |
|
|
1922 */ |
|
|
1923 if (e->xclient.message_type == xw.xembed && e->xclient.format == 32) { |
|
|
1924 if (e->xclient.data.l[1] == XEMBED_FOCUS_IN) { |
|
|
1925 win.mode |= MODE_FOCUSED; |
|
|
1926 xseturgency(0); |
|
|
1927 } else if (e->xclient.data.l[1] == XEMBED_FOCUS_OUT) { |
|
|
1928 win.mode &= ~MODE_FOCUSED; |
|
|
1929 } |
|
|
1930 } else if (e->xclient.data.l[0] == xw.wmdeletewin) { |
|
|
1931 ttyhangup(); |
|
|
1932 exit(0); |
|
|
1933 } |
|
|
1934 } |
|
|
1935 |
|
|
1936 void |
|
|
1937 resize(XEvent *e) |
|
|
1938 { |
|
|
1939 if (e->xconfigure.width == win.w && e->xconfigure.height == win.h) |
|
|
1940 return; |
|
|
1941 |
|
|
1942 cresize(e->xconfigure.width, e->xconfigure.height); |
|
|
1943 } |
|
|
1944 |
|
|
1945 void |
|
|
1946 run(void) |
|
|
1947 { |
|
|
1948 XEvent ev; |
|
|
1949 int w = win.w, h = win.h; |
|
|
1950 fd_set rfd; |
|
|
1951 int xfd = XConnectionNumber(xw.dpy), ttyfd, xev, drawing; |
|
|
1952 struct timespec seltv, *tv, now, lastblink, trigger; |
|
|
1953 double timeout; |
|
|
1954 |
|
|
1955 /* Waiting for window mapping */ |
|
|
1956 do { |
|
|
1957 XNextEvent(xw.dpy, &ev); |
|
|
1958 /* |
|
|
1959 * This XFilterEvent call is required because of XOpenIM. It |
|
|
1960 * does filter out the key event and some client message for |
|
|
1961 * the input method too. |
|
|
1962 */ |
|
|
1963 if (XFilterEvent(&ev, None)) |
|
|
1964 continue; |
|
|
1965 if (ev.type == ConfigureNotify) { |
|
|
1966 w = ev.xconfigure.width; |
|
|
1967 h = ev.xconfigure.height; |
|
|
1968 } |
|
|
1969 } while (ev.type != MapNotify); |
|
|
1970 |
|
|
1971 ttyfd = ttynew(opt_line, shell, opt_io, opt_cmd); |
|
|
1972 cresize(w, h); |
|
|
1973 |
|
|
1974 for (timeout = -1, drawing = 0, lastblink = (struct timespec){0};;) { |
|
|
1975 FD_ZERO(&rfd); |
|
|
1976 FD_SET(ttyfd, &rfd); |
|
|
1977 FD_SET(xfd, &rfd); |
|
|
1978 |
|
|
1979 if (XPending(xw.dpy)) |
|
|
1980 timeout = 0; /* existing events might not set xfd */ |
|
|
1981 |
|
|
1982 seltv.tv_sec = timeout / 1E3; |
|
|
1983 seltv.tv_nsec = 1E6 * (timeout - 1E3 * seltv.tv_sec); |
|
|
1984 tv = timeout >= 0 ? &seltv : NULL; |
|
|
1985 |
|
|
1986 if (pselect(MAX(xfd, ttyfd)+1, &rfd, NULL, NULL, tv, NULL) < 0) { |
|
|
1987 if (errno == EINTR) |
|
|
1988 continue; |
|
|
1989 die("select failed: %s\n", strerror(errno)); |
|
|
1990 } |
|
|
1991 clock_gettime(CLOCK_MONOTONIC, &now); |
|
|
1992 |
|
|
1993 if (FD_ISSET(ttyfd, &rfd)) |
|
|
1994 ttyread(); |
|
|
1995 |
|
|
1996 xev = 0; |
|
|
1997 while (XPending(xw.dpy)) { |
|
|
1998 xev = 1; |
|
|
1999 XNextEvent(xw.dpy, &ev); |
|
|
2000 if (XFilterEvent(&ev, None)) |
|
|
2001 continue; |
|
|
2002 if (handler[ev.type]) |
|
|
2003 (handler[ev.type])(&ev); |
|
|
2004 } |
|
|
2005 |
|
|
2006 /* |
|
|
2007 * To reduce flicker and tearing, when new content or event |
|
|
2008 * triggers drawing, we first wait a bit to ensure we got |
|
|
2009 * everything, and if nothing new arrives - we draw. |
|
|
2010 * We start with trying to wait minlatency ms. If more content |
|
|
2011 * arrives sooner, we retry with shorter and shorter periods, |
|
|
2012 * and eventually draw even without idle after maxlatency ms. |
|
|
2013 * Typically this results in low latency while interacting, |
|
|
2014 * maximum latency intervals during `cat huge.txt`, and perfect |
|
|
2015 * sync with periodic updates from animations/key-repeats/etc. |
|
|
2016 */ |
|
|
2017 if (FD_ISSET(ttyfd, &rfd) || xev) { |
|
|
2018 if (!drawing) { |
|
|
2019 trigger = now; |
|
|
2020 drawing = 1; |
|
|
2021 } |
|
|
2022 timeout = (maxlatency - TIMEDIFF(now, trigger)) \ |
|
|
2023 / maxlatency * minlatency; |
|
|
2024 if (timeout > 0) |
|
|
2025 continue; /* we have time, try to find idle */ |
|
|
2026 } |
|
|
2027 |
|
|
2028 /* idle detected or maxlatency exhausted -> draw */ |
|
|
2029 timeout = -1; |
|
|
2030 if (blinktimeout && tattrset(ATTR_BLINK)) { |
|
|
2031 timeout = blinktimeout - TIMEDIFF(now, lastblink); |
|
|
2032 if (timeout <= 0) { |
|
|
2033 if (-timeout > blinktimeout) /* start visible */ |
|
|
2034 win.mode |= MODE_BLINK; |
|
|
2035 win.mode ^= MODE_BLINK; |
|
|
2036 tsetdirtattr(ATTR_BLINK); |
|
|
2037 lastblink = now; |
|
|
2038 timeout = blinktimeout; |
|
|
2039 } |
|
|
2040 } |
|
|
2041 |
|
|
2042 draw(); |
|
|
2043 XFlush(xw.dpy); |
|
|
2044 drawing = 0; |
|
|
2045 } |
|
|
2046 } |
|
|
2047 |
|
|
2048 void |
|
|
2049 usage(void) |
|
|
2050 { |
|
|
2051 die("usage: %s [-aiv] [-c class] [-f font] [-g geometry]" |
|
|
2052 " [-n name] [-o file]\n" |
|
|
2053 " [-T title] [-t title] [-w windowid]" |
|
|
2054 " [[-e] command [args ...]]\n" |
|
|
2055 " %s [-aiv] [-c class] [-f font] [-g geometry]" |
|
|
2056 " [-n name] [-o file]\n" |
|
|
2057 " [-T title] [-t title] [-w windowid] -l line" |
|
|
2058 " [stty_args ...]\n", argv0, argv0); |
|
|
2059 } |
|
|
2060 |
|
|
2061 int |
|
|
2062 main(int argc, char *argv[]) |
|
|
2063 { |
|
|
2064 xw.l = xw.t = 0; |
|
|
2065 xw.isfixed = False; |
|
|
2066 xsetcursor(cursorshape); |
|
|
2067 |
|
|
2068 ARGBEGIN { |
|
|
2069 case 'a': |
|
|
2070 allowaltscreen = 0; |
|
|
2071 break; |
|
|
2072 case 'A': |
|
|
2073 alpha = strtof(EARGF(usage()), NULL); |
|
|
2074 LIMIT(alpha, 0.0, 1.0); |
|
|
2075 break; |
|
|
2076 case 'c': |
|
|
2077 opt_class = EARGF(usage()); |
|
|
2078 break; |
|
|
2079 case 'e': |
|
|
2080 if (argc > 0) |
|
|
2081 --argc, ++argv; |
|
|
2082 goto run; |
|
|
2083 case 'f': |
|
|
2084 opt_font = EARGF(usage()); |
|
|
2085 break; |
|
|
2086 case 'g': |
|
|
2087 xw.gm = XParseGeometry(EARGF(usage()), |
|
|
2088 &xw.l, &xw.t, &cols, &rows); |
|
|
2089 break; |
|
|
2090 case 'i': |
|
|
2091 xw.isfixed = 1; |
|
|
2092 break; |
|
|
2093 case 'o': |
|
|
2094 opt_io = EARGF(usage()); |
|
|
2095 break; |
|
|
2096 case 'l': |
|
|
2097 opt_line = EARGF(usage()); |
|
|
2098 break; |
|
|
2099 case 'n': |
|
|
2100 opt_name = EARGF(usage()); |
|
|
2101 break; |
|
|
2102 case 't': |
|
|
2103 case 'T': |
|
|
2104 opt_title = EARGF(usage()); |
|
|
2105 break; |
|
|
2106 case 'w': |
|
|
2107 opt_embed = EARGF(usage()); |
|
|
2108 break; |
|
|
2109 case 'v': |
|
|
2110 die("%s " VERSION "\n", argv0); |
|
|
2111 break; |
|
|
2112 default: |
|
|
2113 usage(); |
|
|
2114 } ARGEND; |
|
|
2115 |
|
|
2116 run: |
|
|
2117 if (argc > 0) /* eat all remaining arguments */ |
|
|
2118 opt_cmd = argv; |
|
|
2119 |
|
|
2120 if (!opt_title) |
|
|
2121 opt_title = (opt_line || !opt_cmd) ? "st" : opt_cmd[0]; |
|
|
2122 |
|
|
2123 setlocale(LC_CTYPE, ""); |
|
|
2124 XSetLocaleModifiers(""); |
|
|
2125 cols = MAX(cols, 1); |
|
|
2126 rows = MAX(rows, 1); |
|
|
2127 tnew(cols, rows); |
|
|
2128 xinit(cols, rows); |
|
|
2129 xsetenv(); |
|
|
2130 selinit(); |
|
|
2131 run(); |
|
|
2132 |
|
|
2133 return 0; |
|
|
2134 } |
